question programmation carte arduino

[invite49ef489c]

Bonjour à tous

Voilà je débute la programmation d'une carte arduino pour mes PPE et une question se pose à moi:
(je n'ai malheureusement pas de carte sous la main pour vérifier si cela marche)

Dans le code si dessous, serais-je bloquer dans la boucle de la led clignotante ou pourrais je effectuer les actions en dessous en parrallèle?

//Le but du programme est de lancer une led verte clignotante quand l'interrupteur est sur ON
//et de lancer une led rouge en plus de la led verte clignotante quand l'interrupteur est sur ON et le bouton poussoir enclenché

int Interrupteur = 1;
int Bouton_Poussoir = 2;
int LED_verte = 3;
int LED_rouge = 4;
int Clignotant = 0; // Variable clignotement

void setup() // Définition des entrées/sorties
{
pinMode(Interrupteur,INPUT);
pinMode(Bouton_Poussoir,INPUT);
pinMode(LED_verte,OUTPUT);
pinMode(LED_rouge,OUTPUT);

}

void loop() // début du programme
{

	if (digitalRead(Interrupteur)) 
	{
	Clignotant = 1
	
		if (Clignotant == 1)
		{
		digitalWrite(LED_verte,HIGH);
		delay (1500);
		digitalWrite(LED_verte,LOW);
		delay (1500);
		}
		
		if (digitalRead (Bouton_Poussoir))
		{
		digitalWrite(LED_rouge,HIGH);
		else
		digitalWrite(LED_rouge,LOW);
                }
	}
}

-----

[invite936c567e]

Bonsoir

Je ne vois qu'une boucle, c'est « loop() » qui est appelée de façon récurrente par le système, et elle n'est pas bloquante.

Toutefois :

- Il manque un point-virgule ( ; ) à la fin de la ligne

Clignotant = 1

C'est une erreur de syntaxe que tu aurais pu voir à la compilation, même sans disposer d'une carte pour faire tourner le programme.

- Je ne vois pas l'utilité de la variable « Clignotant », qui est fixée à 1 dès le départ, et dont le test est toujours vrai.

- Tu peux faire d'autres choses à côté dans la boucle, mais pas vraiment en parallèle. En effet, les instructions seront toujours exécutées consécutivement.

[invite49ef489c]

Bonsoir,

en effet je viens de me rendre compte que la variable "clignotant" ne sert a rien, merci

Ok, donc il me sera impossible d'avoir une led verte clignotante avec en même temps une led rouge qui s'allume si j'appuie sur le bouton poussoir? (la led clignotante s'arrêtera au moment ou j'appuierai sur le bouton poussoir c'est bien sa?)
Ou une solution alternative existe?

Merci beaucoup pour cette réponse très rapide

[invite936c567e]

Ok, donc il me sera impossible d'avoir une led verte clignotante avec en même temps une led rouge qui s'allume si j'appuie sur le bouton poussoir?

Si. Et c'est finalement ce que ton programme réalise.

Ce n'est pas le maintien de l'état d'une led qui impose une consommation de temps dans ton programme, mais le fait de changer cet état. D'ailleurs pour maintenir la led verte allumée ou éteinte durant le cycle, tu ne fais rien sinon attendre que le temps passe (fonctions « delay(...) » ).

En revanche, d'après ton programme, du fait de ces attentes, la modification de l'état de la led rouge ne peut intervenir qu'à la fin de chaque cycle de clignotement (soit toutes les 3 secondes), et non pas instantanément quand on appuie ou quand on relâche le bouton-poussoir.


Si tu veux que la led rouge s'allume et s'éteigne presque instantanément, alors il faut tester le bouton-poussoir et commander la led beaucoup plus souvent. Tu pourrais par exemple le faire de la façon suivante :

int i;

void loop()
{
    // change l'état de la led verte
    if (Clignotant == 1)
    {
        digitalWrite(LED_verte, LOW);
        Clignotant = 0;
    }
    else
    {
        digitalWrite(LED_verte, HIGH);
        Clignotant = 1;
    }

    // 15 boucles de 0,1 seconde = 1,5 seconde
    for (i=0;i<15;i++)
    {
        // attente de 0,1 seconde
        delay(100);

        // change l'état de la led rouge en fonction de l'état du bouton-poussoir
        if (digitalRead(Bouton_Poussoir))
            digitalWrite(LED_rouge,HIGH);
        else
            digitalWrite(LED_rouge,LOW);
    }
}

Ici, le retard entre l'appui sur le bouton-poussoir et l'allumage de la led rouge est au plus égal à 0,1 seconde.

[A voir en vidéo sur Futura]

[invite936c567e]

Si tu envisages d'avoir des durées d'allumage et d'extinction différentes pour la led verte (par exemple 1s/2s au lieu de 1,5s/1,5s), tu pourrais procéder comme suit:

void change_led_rouge()
{
    if (digitalRead(Bouton_Poussoir))
        digitalWrite(LED_rouge,HIGH);
    else
        digitalWrite(LED_rouge,LOW);
}

int i;

void loop()
{
    digitalWrite(LED_verte, LOW);

    for (i=0;i<20;i++)
    {
         delay(100);
         change_led_rouge();
    }

    digitalWrite(LED_verte, HIGH);

    for (i=0;i<10;i++)
    {
         delay(100);
         change_led_rouge();
    }
}

[invite936c567e]

... et voici une autre façon de procéder, en utilisant « loop() » comme seule boucle du programme :

int Interrupteur = 1;
int Bouton_Poussoir = 2;
int LED_verte = 3;
int LED_rouge = 4;
int i;

void setup()
{
    pinMode(Interrupteur,INPUT);
    pinMode(Bouton_Poussoir,INPUT);
    pinMode(LED_verte,OUTPUT);
    pinMode(LED_rouge,OUTPUT);

    i = 0;
    digitalWrite(LED_verte, HIGH);
}


void loop()
{
    i++;
    if (i == 20)
        digitalWrite(LED_verte, LOW);
    else
    if (i >= 30) {
        i = 0;
        digitalWrite(LED_verte, HIGH);
    }

    delay(100);

    if (digitalRead(Bouton_Poussoir))
        digitalWrite(LED_rouge,HIGH);
    else
        digitalWrite(LED_rouge,LOW);
}

[invite49ef489c]

Merci pour ces exemples de codes, ils m'aideront beaucoup dans ma compréhension d'Arduino.

Je me rend compte que je suis enfaite piégé, car j'ai prit l'exemple de la "led rouge" pour expliqué mon problème, mais dans mon projet final, il s'agira de faire tourner un moteur pendant un temps déterminé, et je ne peux pas être dans le cycle de la led clignotante ainsi que dans le cycle du moteur qui tourne en même temps, il me reste donc comme solution de mettre une led fixe je pense.


Merci beaucoup pour ces explications

[invite936c567e]

Tu peux parfaitement continuer à faire clignoter la led et contrôler la durée de fonctionnement de ton moteur.

Il suffit pour cela de faire une boucle dont la durée d'exécution est un sous-multiple des différentes durées, et utiliser des compteurs pour chronométrer séparément les temps d'arrêt et de fonctionnement de la led et du moteur.

Par exemple, si tu veux une led qui clignote avec un cycle 2s/1s et un moteur qui tourne durant 2,25s et s'arrête après appui sur le bouton-poussoir, avec un temps de réaction à cet appui inférieur à 0,3s, alors tu peux choisir une boucle de 0,25s. Dans ce cas :
- la led reste allumée durant 8 boucles et reste éteinte durant 4 boucles, soit un cycle de 12 boucles ;
- le moteur tourne durant 9 boucles après la détection de l'appui sur le bouton-poussoir.
Le code correspondant pourrait être :

int Bouton_Poussoir = 2;
int LED = 3;
int Moteur = 4;

int Temps_LED;
int Temps_Moteur;

void setup()
{
    pinMode(Bouton_Poussoir,INPUT);
    pinMode(LED,OUTPUT);
    pinMode(Moteur,OUTPUT);

    Temps_LED = 0;
    Temps_Moteur = 0;
}


void loop()
{
    if (Temps_LED==0)  // cycle led terminé -> recommencer un cycle
    {
        digitalWrite(LED_verte, HIGH);
        Temps_LED = 12; // commencer le décompte de 12 boucles
    }
    else
    {
        if (Temps_LED==4) // éteindre la led après 8 boucles
            digitalWrite(LED_verte, LOW);

        Temps_LED--; // décompte des boucles pour la led
    }

    if (Temps_Moteur==0) // moteur arrêté -> faut-il démarrer ?
    {
        if (digitalRead(Bouton_Poussoir))
        {
            digitalWrite(Moteur,HIGH);
            Temps_Moteur = 9; // commencer le décompte de 9 boucles
        }
    }
    else
    if (Temps_Moteur==1) // fin du décompte -> arrêter le moteur
    {
            digitalWrite(Moteur,LOW);
            Temps_Moteur = 0;
    }
    else
        Temps_Moteur--; // décompte des boucles pour le moteur

    delay(250); // durée d'une boucle = 0,25 s
}

[invite49ef489c]

Bonsoir, en effet je n'aurais pas du tout pensé a une solution de se genre, merci beaucoup

je crois que j'ai encore beaucoup à apprendre en programmation de ces petites cartes qui finalement sont très puissante!

Encore merci

[invite41e1ac0d]

Bonsoir à vous deux,

j'ai un soucis similaire, j'ai donc préférer venir prendre des renseignement ici plutôt que de créer un autre post

Voilà je dois faire clignoter un feu (ou une led, donc se qui est le cas pour vous) afin de prévenir la fermeture d'une porte.
Seulement je ne peux pas utilisé le système proposer si dessus, car le moteur de la porte ferme celle ci jusqu'à se que sa fermeture soit détecter par un capteur fin de course.
Je suis donc confronté au même problème de "blocage dans un cycle" puisqu'il faudrait que je puisse faire fonctionner en même temps:

un cycle qui me permet de faire clignoter mon feu.
un cycle qui enclenche le moteur de fermeture de porte jusqu'à ce que celle si soit détectée fermée.



Merci d'avance pour vos futures idées.

[invite936c567e]

Même dans ce cas, le principe reste identique. Il suffit de contrôler périodiquement (à chaque boucle) l'état des entrées et des compteurs de boucles afin de démarrer ou arrêter les actions prévues.

Voici un exemple :
- le bouton de fermeture déclenche le clignotement de la led d'alarme durant 4 secondes
- au terme de ces 4 secondes, le moteur de la porte est actionné afin de la refermer, et le clignotement de la led continue
- lorsque le contact de fin de course "porte fermée" est atteint, on arrête le moteur et le clignotement de la led
- à tout moment, l'appui sur le bouton d'ouverture provoque la réouverture la porte après un délai de 0,5 seconde.
- à tout moment, l'appui sur le bouton d'arrêt provoque l'arrêt immédiat de la porte.

// sorties
int moteurMarche = 2;
int moteurSens = 3;
int led = 4;

// entrées
int boutonFermeture = 5;
int boutonOuverture = 6;
int boutonArret = 7;
int contactPorteFermee = 8;
int contactPorteOuverte = 9;

// états du système
enum
{
    REPOS = 0,
    PREAVIS_FERMETURE,
    FERMETURE,
    DELAI_OUVERTURE,
    OUVERTURE
};

int action;
int tempoMoteur;
int tempoClignotement;

void setup()
{
    pinMode(moteurMarche, OUTPUT);
    digitalWrite(moteurMarche, LOW);
    pinMode(moteurSens, OUTPUT);
    pinMode(led, OUTPUT);
    digitalWrite(led, LOW);

    pinMode(boutonFermeture, INPUT);
    pinMode(boutonOuverture, INPUT);
    pinMode(boutonArret, INPUT);
    pinMode(contactPorteFermee, INPUT);
    pinMode(contactPorteOuverte, INPUT);

    action = REPOS;
    tempoMoteur = 0;
    tempoClignotement = 0;
}

int i;

void loop()
{

    for (i=0; i<10; i++)
    {
        if (digitalRead(contactPorteFermee)
            || digitalRead(contactPorteOuverte)
            || digitalRead(boutonArret))
        {
            // moteur coupé en fin de course ou si l'arrêt est demandé
            digitalWrite(moteurMarche, LOW);
            action = REPOS;
        }

        // délai total 10 x 1 ms = 0,01 seconde par boucle loop()
        delay(1);
    }

    if (digitalRead(boutonOuverture))
    {
        // ouverture demandée
        switch(action)
        {
        case REPOS:
        case PREAVIS_FERMETURE:
        case FERMETURE:
            // démarre le délai avant ouverture
            action = DELAI_OUVERTURE;
            tempoMoteur = 50; // 50 boucles = 0,5 seconde
            break;
        case DELAI_OUVERTURE:
            // délai avant ouverture
            if (tempoMoteur>0)
                tempoMoteur--; // décompte du délai pour le moteur
            else
            {
                // à la fin du délai, commande l'ouverture de la porte
                digitalWrite(moteurSens, HIGH);
                digitalWrite(moteurMarche, HIGH);
                action = OUVERTURE;
            }
            break;
        case OUVERTURE:
        default:
            // ouverture de la porte en cours
            break;
        } 
    }
    else
    if (digitalRead(boutonFermeture))
    {
        // fermeture demandée
        switch(action)
        {
        case REPOS:
        case DELAI_OUVERTURE:
        case OUVERTURE:
            // démarre le délai de préavis de fermeture
            action = PREAVIS_FERMETURE;
            tempoMoteur = 400; // 400 boucles = 4 secondes
            break;
        case PREAVIS_FERMETURE:
            // délai avant fermeture
            if (tempoMoteur>0)
                tempoMoteur--; // décompte du délai pour le moteur
            else
            {
                // à la fin du délai, commande la fermeture de la porte
                digitalWrite(moteurSens, LOW);
                digitalWrite(moteurMarche, HIGH);
                action = FERMETURE;
            }
            break;
        case FERMETURE:
        default:
            // fermeture de la porte en cours
            break;
        } 
    }

    if (action==REPOS)
    {
        // led éteinte au repos
        digitalWrite(led, LOW);
        tempoClignotement = 0;
    }
    else
    {
        // led clignotante dans tous les autres cas
        if (tempoClignotement==0)
        {
            // fin du cycle -> débuter un nouveau cycle de 0,6 seconde
            tempoClignotement = 600;
            digitalWrite(led, HIGH); // led allumée
        }
        else
        {
            tempoClignotement--; // décompte du délai pour la led

            if (tempoClignotement==300)
                digitalWrite(led, LOW); // led éteinte après 0,3 seconde
        }
    }

}

(sauf erreur. j'ai écrit le code sur un coin de table et je ne l'ai pas testé)

[invite41e1ac0d]

Bonsoir, et merci pour ce code qui m'aide beaucoup à comprendre Arduino.

J'ai découverte de nouvelles boucle cependant je ne comprend pas le fonctionnement de certaines parties que vous me présentez.
(notamment la switch/case)



Merci pour votre aide.