IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

[PIC16] Faire 2 actions avec un bouton PIC16F84


Sujet :

Embarqué

  1. #1
    Membre à l'essai
    Homme Profil pro
    Ingénieur validation
    Inscrit en
    Novembre 2015
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Drôme (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur validation

    Informations forums :
    Inscription : Novembre 2015
    Messages : 25
    Points : 16
    Points
    16
    Par défaut [PIC16] Faire 2 actions avec un bouton PIC16F84
    Bonjour,

    Je travaille sur un programme permettant de gérer un carrefour avec des feux tricolores et il faut aussi gérer un bouton qui active/désactive le jour.
    Et si ce bouton est activé les feux doivent clignoter orange avec un délai de 2 sec mais avant cela il faut que tous les feux passent au rouge et pas d'un coup sinon imaginez les accidents .

    Voici le programme

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
                                    // Programme permettant de gérer des feux tricolores
    //////////////////////////////////////////////////////////
    // prototypes de fonctions
    void init( ); // Procédure d’initialisation du PIC
    void allumage_feux( ); // Sous programme de l'allumage de feux
    //////////////////////////////////////////////////////////
    // Constantes
    #define feu_voltaire_rouge PORTB.F0
    #define feu_voltaire_orange PORTB.F1
    #define feu_voltaire_vert PORTB.F2
    #define feu_michel_rouge PORTB.F3
    #define feu_michel_orange PORTB.F4
    #define feu_michel_vert PORTB.F5
    #define ETEINT 0
    #define ALLUME 1
    #define capteur_nuit PORTA.F0
    //////////////////////////////////////////////////////////
    // Fonction principale
    void main()
    {
    init (); // appel de la procédure « init »
    while (1)
    {
    allumage_feux() ; // appel de la procédure « allumage_feux »
    }
    }
    //////////////////////////////////////////////////////////
    void init ( ) // sous programme d’initialistion du PIC, des variables, etc …
    {
    trisb = 0x00; // config du port B en sortie
    portb = 0x00; // Tous les feux sont éteints à l'init
    trisa = 0xFF; // config du port A en sortie
    }
    //////////////////////////////////////////////////////////
    void allumage_feux ( ) // sous programme 
    {
         int boucle;
         
             if ( capteur_nuit == ALLUME) // On demande si le bouton 1 (Capteur jour/nuit) est allumé
             {
                           while ( capteur_nuit == ALLUME) // Tant qu'il est allumé on fait clignoter les feux orange toutes les 2 sec
                           {
                                    feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
                                    feu_michel_orange = ALLUME; // Feu Michel orange allumé
                                    delay_ms(2000); // Pendant 2 sec
                                    feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
                                    feu_michel_orange = ETEINT; // Feu Michel orange éteint
                                    delay_ms(2000); // Pendant 2 sec
                           }
             }
             else // Sinon mise en route du système de feu classique
             {
                           while(boucle < 5) // Boucle qui permet de faire clignoter les feux oranges 5 sec
                           {
                                        feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
                                        feu_michel_orange = ALLUME; // Feu Michel orange allumé
                                        delay_ms(500); // Tempo 500 ms
                                        feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
                                        feu_michel_orange = ETEINT; // Feu Michel orange éteint
                                        delay_ms(500); // Tempo 500 ms
                                        boucle ++; // Incrémente la variable boucle
                           }
             }
                                        // Début circulation
                                        // Circulation Voltaire
                                        feu_voltaire_rouge = ALLUME; // Feu Voltaire rouge allumé
                                        feu_michel_rouge = ALLUME; // Feu Michel rouge allumé
                                        delay_ms(1000); // Pendant 1 sec
                                        feu_voltaire_rouge = ETEINT; // Feu Voltaire rouge éteint
                                        feu_voltaire_vert = ALLUME; // Feu Voltaire vert allumé
                                        delay_ms(10000); // A modifier 10 s
                                        // Circulation Michel
                                        feu_voltaire_vert = ETEINT; // Feu Voltaire vert éteint
                                        feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
                                        delay_ms(1000); // Pendant 1 sec
                                        feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
                                        feu_voltaire_rouge = ALLUME; // Feu Voltaire rouge allumé
                                        delay_ms(1000); // Pendant 1 sec
                                        feu_michel_rouge = ETEINT; // Feu Michel rouge éteint
                                        feu_michel_vert = ALLUME; // Feu Michel vert allumé
                                        delay_ms(10000); // A modifier 10 s
    
                                        feu_michel_vert = ETEINT; // Feu Michel vert éteint
                                        feu_michel_orange = ALLUME; // Feu Michel orange allumé
                                        delay_ms(1000); // Pendant 1 sec
                                        feu_michel_orange = ETEINT; // Feu Michel orange éteint
                                        feu_michel_rouge = ALLUME; // Feu Michel rouge allumé
                                        delay_ms(1000); // Pendant 1 sec
    
    }
    Je précise que l'algo n'est pas terminé.
    J'ai plus besoin d'aide pour le début avec le fameux bouton jour/nuit, j'ai fait un classique if else mais ça ne marche pas.
    Je m'explique admettons que le capteur jour/nuit soit allumé dès le début donc les feux vont clignoter indéfiniment orange avec le délai de 2 sec mais si je relâche le bouton l'étape de la boucle (ligne 53-62 je crois) est complétement ignorée et le programme passe à la suite.

    Bien entendu je ne veux pas les réponses directement, j'ai juste besoin d'un coup de pouce.

    Merci

  2. #2
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    Hello,

    Pour ce genre de problème, une FSM est utile.

    Ton problème peut se schématiser comme ça :


    Après, tu peux implémenter cette FSM avec un switch.
    A chaque itération, tu regardes dans quel état tu te trouves, tu exécutes cet état et passe au suivant en fonction des entrées (ici le bouton jour / nuit).
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    enum State {
        ALL_RED,
        BLINK_ORANGE,
        VOLTAIRE,
        MICHEL
    };
     
    enum Color {
        RED,
        ORANGE,
        GREEN,
        OFF
    };
     
    int readDay() {
        /* ... */
    }
     
    void writeVoltaireMichel(Color v, Color m) {
        /* ... */
    }
     
    int main(int, char**) {
     
        State st = ALL_RED;
     
        while(1) {
            switch(st) {
            case ALL_RED:
                writeVoltaireMichel(RED, RED);
                delay(1000);
                st = (readDay() == 0 ? VOLTAIRE: BLINK_ORANGE);
                break;
     
            case BLINK_ORANGE:
                writeVoltaireMichel(OFF, OFF);
                delay(100);
                writeVoltaireMichel(ORANGE, ORANGE);
                delay(100);
                st = (readDay() == 1 ? ALL_RED: BLINK_ORANGE);
                break;
     
            case VOLTAIRE:
                writeVoltaireMichel(RED, GREEN);
                delay(1000);
                writeVoltaireMichel(RED, ORANGE);
                delay(100);
                writeVoltaireMichel(RED, RED);
                st = (readDay() == 1 ? ALL_RED: MICHEL);
                break;
     
            case MICHEL:
                writeVoltaireMichel(GREEN, RED);
                delay(1000);
                writeVoltaireMichel(ORANGE, RED);
                delay(100);
                writeVoltaireMichel(RED, RED);
                st = ALL_RED;
                break;
     
            default: exit(-1);           
            }
        }
        return 0;
    }

  3. #3
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 190
    Points : 11 573
    Points
    11 573
    Par défaut
    +1 Iradrille,
    Une machine a état c'est très efficace !

    Par contre... là
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    readDay() == 0 ? VOLTAIRE: BLINK_ORANGE
    Tu vas achever notre jeune ami Caenem ! Les opérateurs ternaires c'est bien en raccourci d'écriture mais quand on en met partout je trouve que ça nuis à la compréhension.


    @Caenem,
    Le problème que tu rencontres est normal.

    Regarde mes commentaires :
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    // Lorsque qu'on arrive face à ton test il n'y a que deux choix possibles ! Soit on entre dans le if soit dans le else
    // mais si on est rentré dans le if quoi qui se passe on n'ira jamais dans le else.
             if ( capteur_nuit == ALLUME) 
             {
                           while ( capteur_nuit == ALLUME) 
                           {
                                    ... 
                           }
             }
             else 
             {
                           while(boucle < 5) 
                           {
                                        ...
                           }
             }
    Donc lorsque tu as une condition if / else il est impossible de sortir du if pour aller dans le else car c'est soit l'un soit l'autre.

    Si tu relâches capteur_nuit (éteint) alors que tu es dans le if et plus précisément dans le while ( capteur_nuit == ALLUME) alors tu vas sortir du while car la condition va être fausse et sortir directement après le else
    Il faut que tu revois ton algorithme en fonction du fonctionnement du couple if / else

    A+
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  4. #4
    Membre à l'essai
    Homme Profil pro
    Ingénieur validation
    Inscrit en
    Novembre 2015
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Drôme (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur validation

    Informations forums :
    Inscription : Novembre 2015
    Messages : 25
    Points : 16
    Points
    16
    Par défaut
    Donc il faudrait un if pour si il est à 1 et un autre si il est à 0 ?

  5. #5
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 190
    Points : 11 573
    Points
    11 573
    Par défaut
    Si j'ai bien compris ton programme alors "Oui tout à fait" mais c'est pas terrible !
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
     
     
    int boucle; // variable globale
     
    void allumage_feux ( ) // sous programme 
    {
        /* int boucle;  mettre boucle en variable globale */
             if ( capteur_nuit == ALLUME) 
             {
                           while ( capteur_nuit == ALLUME) 
                           {
                                    ... 
                           }
             }
             if ( capteur_nuit == ETEINT) 
             {
                           while(boucle < 5) 
                           {
                                        ...
                           }
             }
     
             ... reste du programme ...
    }

    Ou bien revoir l'algorithme afin de simplifier tout ça :

    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    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
     
    int boucle; // variable globale
     
    void allumage_feux ( ) // sous programme 
    {
             /* int boucle;  mettre boucle en variable globale */
     
             while ( capteur_nuit == ALLUME) // tant qu'il fait noir on est bloqué dans cette boucle
             {
                             ...
                             boucle = 0; //important car ça permettra d'exécuter le clignotement des feux oranges 1 fois le matin
             }
     
    // si je suis ici c'est qu'il ne fait plus noir : donc il fait jour 
    // et forcément capteur_nuit == ETEINT, inutile de le tester !
     
             while(boucle < 5) 
             {
                             ...
                             boucle++;
             }
     
     
             ... reste du programme ...
    }
    Dans cet algo plus de if / else. Tu remarqueras que la variable boucle doit être en variable globale tout en haut du programme.
    Je ne suis plus sur avec le compilateur C18 mais je crois que si tu laisses la variable boucle là où elle est mais en la mettant en static alors ça devrait aller. A essayer !
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
    void allumage_feux ( ) // sous programme 
    {
             static int boucle;  
     
             while ( capteur_nuit == ALLUME) // tant qu'il fait noir on est bloqué dans cette boucle
             {
                             ...
                             boucle = 0; //important car ça permettra d'exécuter le clignotement des feux oranges 1 fois le matin
             }
     
    // si je suis ici c'est qu'il ne fait plus noir : donc il fait jour 
    // et forcément capteur_nuit == ETEINT, inutile de le tester !
     
             while(boucle < 5) 
             {
                             ...
                             boucle++;
             }
     
     
             ... reste du programme ...
    }

    Est ce que tu peux tester les deux algo ? Pareil, j'ai fait ça de tête et peut être que j'ai mal compris ta demande.
    A+
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  6. #6
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    @Caenem,

    Ta solution est bizarre.

    Soit tu veux une fonction qui sera appelé régulièrement (et qui doit donc retourner rapidement, pas de boucle dedans).
    Soit tu veux une fonction qui contienne cette boucle.

    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    32
    33
    // soit
    void allumage_feux ( ) {
       if(jour) {
          // UN clignotement orange, pas de boucle
       }
       else {
          // un passage de feu VERT -> ORANGE -> ROUGE, encore une fois pas de boucle
       }
    }
    // cette fonction sera appelée depuis une boucle, type
    int main(int, char**) {
       while(1) {
          allumage_feux();
       }
       return 0;
    }
     
    // soit le while est dans ta fonction
    void allumage_feux ( ) {
       while(1) {
          while(jour) {
             // clignotement orange
          }
          while(nuit) {
             // passage de feu VERT -> ORANGE -> ROUGE
          }
       }
    }
    // cette fonction sera appelée une fois, type
    int main(int, char**) {
       allumage_feux();
       return 0;
    }

    Si tu es dans le premier cas, tu devrais éviter d'y placer des boucles. C'est généralement parce que quelque chose d'autre doit s’exécuter aussi à intervalle régulier et donc tu dois lâcher la main régulièrement.

    @Vincent, la variable statique marche et est préférable à une variable globale. Pense par contre à l'initialiser..

  7. #7
    Membre à l'essai
    Homme Profil pro
    Ingénieur validation
    Inscrit en
    Novembre 2015
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Drôme (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur validation

    Informations forums :
    Inscription : Novembre 2015
    Messages : 25
    Points : 16
    Points
    16
    Par défaut
    En fait ce que je voudrais c'est que si j'appuie sur le bouton capteur nuit/jour ça fasse ce qu'il a à faire et si on relâche ça fait l'autre condition mais je voudrais que par exemple si on ré-appuie sur ce bouton ça refasse ce qu'il doit faire parce que dans mon algo ça ne marche pas ça ignore, ça doit passer à d'autres instructions plus bas.

    Je pense qu'il faudrait que je rajoute des fonctions, par exemple un void nuit etc ... Je pense que je m'y retrouverai mieux.

  8. #8
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 190
    Points : 11 573
    Points
    11 573
    Par défaut
    Comment ça ?
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
                                    // Programme permettant de gérer des feux tricolores
    //////////////////////////////////////////////////////////
    // prototypes de fonctions
    void init( ); // Procédure d?initialisation du PIC
    void allumage_feux( ); // Sous programme de l'allumage de feux
    //////////////////////////////////////////////////////////
    // Constantes
    #define feu_voltaire_rouge PORTB.F0
    #define feu_voltaire_orange PORTB.F1
    #define feu_voltaire_vert PORTB.F2
    #define feu_michel_rouge PORTB.F3
    #define feu_michel_orange PORTB.F4
    #define feu_michel_vert PORTB.F5
    #define ETEINT 0
    #define ALLUME 1
    #define capteur_nuit PORTA.F0
    //////////////////////////////////////////////////////////
    // Fonction principale
    void main()
    {
    	init (); // appel de la procédure « init »
    	while (1)
    	{
    		allumage_feux() ; // appel de la procédure « allumage_feux »
    	}
    }
    //////////////////////////////////////////////////////////
    void init ( ) // sous programme d?initialistion du PIC, des variables, etc ?
    {
    	trisb = 0x00; // config du port B en sortie
    	portb = 0x00; // Tous les feux sont éteints à l'init
    	trisa = 0xFF; // config du port A en sortie
    }
    //////////////////////////////////////////////////////////
    void allumage_feux ( ) // sous programme 
    {
         	static int boucle = 0;
     
    	while (capteur_nuit == ALLUME) // Tant qu'il est allumé on fait clignoter les feux orange toutes les 2 sec
            {
            	feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
            	feu_michel_orange = ALLUME; // Feu Michel orange allumé
            	delay_ms(2000); // Pendant 2 sec
            	feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
            	feu_michel_orange = ETEINT; // Feu Michel orange éteint
            	delay_ms(2000); // Pendant 2 sec
    		boucle = 0;
    	}
     
    	while(boucle < 5) // Boucle qui permet de faire clignoter les feux oranges 5 sec
    	{
    		feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
    		feu_michel_orange = ALLUME; // Feu Michel orange allumé
    		delay_ms(500); // Tempo 500 ms
    		feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
    		feu_michel_orange = ETEINT; // Feu Michel orange éteint
    		delay_ms(500); // Tempo 500 ms
    		boucle ++; // Incrémente la variable boucle
    	}
     
    	// Début circulation
    	// Circulation Voltaire
    	feu_voltaire_rouge = ALLUME; // Feu Voltaire rouge allumé
    	feu_michel_rouge = ALLUME; // Feu Michel rouge allumé
    	delay_ms(1000); // Pendant 1 sec
    	feu_voltaire_rouge = ETEINT; // Feu Voltaire rouge éteint
    	feu_voltaire_vert = ALLUME; // Feu Voltaire vert allumé
    	delay_ms(10000); // A modifier 10 s
    	// Circulation Michel
    	feu_voltaire_vert = ETEINT; // Feu Voltaire vert éteint
    	feu_voltaire_orange = ALLUME; // Feu Voltaire orange allumé
    	delay_ms(1000); // Pendant 1 sec
    	feu_voltaire_orange = ETEINT; // Feu Voltaire orange éteint
    	feu_voltaire_rouge = ALLUME; // Feu Voltaire rouge allumé
    	delay_ms(1000); // Pendant 1 sec
    	feu_michel_rouge = ETEINT; // Feu Michel rouge éteint
    	feu_michel_vert = ALLUME; // Feu Michel vert allumé
    	delay_ms(10000); // A modifier 10 s
     
    	feu_michel_vert = ETEINT; // Feu Michel vert éteint
    	feu_michel_orange = ALLUME; // Feu Michel orange allumé
    	delay_ms(1000); // Pendant 1 sec
    	feu_michel_orange = ETEINT; // Feu Michel orange éteint
    	feu_michel_rouge = ALLUME; // Feu Michel rouge allumé
    	delay_ms(1000); // Pendant 1 sec
     
    }
    Normalement avec cet algo :
    1) Si tu appuies sur le bouton, les feux oranges clignoteront toutes les 2 secondes et si tu le relâches les feux oranges clignoteront toutes les 5s puis on passe en "Début circulation" indéfiniment.
    2) Si tu appuies de nouveau sur le bouton, tu recommences en 1)

    Ou bien ce n'est pas ce que tu souhaites faire ?

    @Iradrille,
    Ok pour static
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

Discussions similaires

  1. 2 actions avec 1 bouton
    Par shmuel dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 4
    Dernier message: 18/01/2016, 21h54
  2. Faire un tableau avec des boutons et du texte
    Par Avatar36 dans le forum Qt Creator
    Réponses: 5
    Dernier message: 13/05/2014, 09h22
  3. Action avec des boutons
    Par Pif_Paf_Pouf dans le forum Débuter avec Java
    Réponses: 2
    Dernier message: 03/05/2014, 15h20
  4. [MySQL] comment faire un lien avec un bouton pour ouvrir une page en php
    Par Debutant10 dans le forum PHP & Base de données
    Réponses: 8
    Dernier message: 10/04/2012, 21h11
  5. Pb pour double action avec un bouton
    Par Dawax dans le forum Flash
    Réponses: 11
    Dernier message: 02/07/2006, 17h54

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo