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

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut Conseils pour programmer MEGA 2560

    Bonjour,

    Je débute en programmation.
    J'ai suivi des tutoriels, et pratiqué quelques montages mais je ne sais pas trop comment aborder mon projet sur arduino MEGA 2560:

    Le but du projet:

    Deux séries de 25 Leds sont allumées comme suit :

    Une première série de 25 LED (rouges) s'allument d'après le temps :45 min :
    au démarrage 0 led allumées puis après 45/25 minutes, une première led, puis après 45/25 minute de plus une deuxième led s'allume etc...
    Elles sont connectées sur les sorties 4 à 28.
    pendant ce temps là,
    La deuxième série de Leds (bleues) s'allume sur la base d'un des deux types d'évènements:
    Déclenchement par bouton poussoir (entrée 3)
    ou coupure du faisceau éclairant une photorésistance (entrée 4)
    elles sont connectées sur les sorties 29 à 54

    Le compte à rebours démarre par l'appui sur un bouton poussoir (entrée 1)
    la remise à zéro se fait par un troisième bouton poussoir ( entrée 2)

    J'espère que ma description est assez claire.

    Je vous remercie pour vos conseils.

    Julien

  2. #2
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien
    Citation Envoyé par Jul04 Voir le message
    Deux séries de 25
    Elles sont connectées sur les sorties 4 à 28.
    Avant de passer aux entrées/sorties, pour ce qui concerne les LED, pourquoi ne pas passer aux LED "modernes" comme les WS2812, que l'on trouve à la pièce, au "kilomètre", en barres, en rond... et pour trois fois rien.
    Avec ce "concept", il te faut qu'un fil de commande pris sur l'Arduino ce qui fait que tu peux prendre un UNO ou un Nano pour ce faire.
    Pour jouer avec ces LED il te faut la bibliothèque Adafruit_NeoPixel.h.
    Quand il y a beaucoup de LED, attention à l'alimentation, le régulateur 5V. de l'Arduino arrive assez rapidement à ses limites. Avec beaucoup de LED WS 2812, j'alimente l'Arduino avec un adaptateur 9V. sur le jack et reprends ces 9V. sur la broche Vin, pour alimenter un petit module qui abaissera la tension à 5V. (à régler manuellement)

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  3. #3
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,

    Merci pour ta réponse rapide et très instructive !
    Je garde l'info pour mes prochains travaux, car en l’occurrence sur ce projet, j'ai déjà acquis le matériel, et commencé ma maquette, du coup je dois faire avec ce que j'ai sous la main.
    Du point de vue programmation, comment aborderais-tu la chose avec des LEDS à l'ancienne?
    Quelles fonctions me serait les plus utiles?
    Je sais pas comment construire le programme en fait.

    Merci

  4. #4
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien
    Citation Envoyé par Jul04 Voir le message
    Je sais pas comment construire le programme en fait.
    As-tu déjà un bout de programme, si oui, publies-le, ou rien du tout?

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  5. #5
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,

    J'ai essayé des choses, en copiant des exemples, mais ca ne correspondait pas du tout au résultat souhaité (chenillards, ou autres rendus), mais je me dis que le mieux est de repartir d'une page vierge.

    Qu'en penses-tu?

    Merci

  6. #6
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien
    Citation Envoyé par Jul04 Voir le message
    mais je me dis que le mieux est de repartir d'une page vierge.
    Qu'en penses-tu?
    Que du bien!

    Citation Envoyé par Jul04 Voir le message
    Du point de vue programmation, comment aborderais-tu la chose avec des LEDS à l'ancienne?
    Quelles fonctions me serait les plus utiles?
    Faire ce projet avec des LED "à l'ancienne", n'enlève ren à cette remarque.
    Citation Envoyé par jpbbricole Voir le message
    Quand il y a beaucoup de LED, attention à l'alimentation, le régulateur 5V. de l'Arduino arrive assez rapidement à ses limites. Avec beaucoup de LED WS 2812, j'alimente l'Arduino avec un adaptateur 9V. sur le jack et reprends ces 9V. sur la broche Vin, pour alimenter qui abaissera la tension à 5V. (à régler manuellement)
    Alors, départ!

    Pour débuter, comme 2 x 25 LED ça fait du monde! il faut bien étudier l'initialisation d'une pareille quantité de sorties.
    Pour éviter d'écrire 50 fois pinMode(nn, OUTPUT);, il faut mettre les pin des LED en tableaux, c'est très bien expliqué ici.
    Fais 2 tableaux, un pour les LED rouges et 1 pour les LED bleues.

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  7. #7
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,


    Pour le problème d'alimentation, je pensais réduire l'intensité des leds en mettant une résistance en série, sur la sortie 5V, car en fait les Leds sont déjà trop lumineuses avec juste 150 et 100ohm. la maquette sera installée dans une pièce, et du coup peu de lumière du jour.
    Dans l'absolu, si j’utilisais un chargeur de téléphone 5VDC avec 1A je pourrait le faire fonctionner à ta méthode, vu que je commute l'allumage vers le potentiel 0V=> LOW

    Est-ce-qu'avec cela, c'est bien parti?

    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
    //--Définitions
     
    //Constantes:
    //Temps
    const byte compteRebours = 45 ; // durée du programme en minutes
    const float tempsms = compteRebours*60000 ; // durée en ms => à utiliser pour les calculs
    const float periodeRedLed = tempsms/25 ; // durée d'un intervale entre l'allumage de la led rouge suivante
     
    //Sorties
    const byte pinOutRed[] = {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}; 
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    const byte pinOutBuzz = 4 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
     
    //Entrées
    const byte pinInStart = 1;  // Le Pin 1 (repéré 0) est affecté au démarrage 
    const byte pinInRAZ = 2 ; // Le pin 2 (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInEvent = 3 ; // le pin 3 (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A0 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
     
     
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
     
     
    //-- Initialisation
    void setup() {
          for (int i = 0; i < 24; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
            pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
            digitalWrite(pinOutRed[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
            pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
            digitalWrite(pinOutBlue[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
          } // Fin de la boucle for
     
        } // Fin Setup
     
    //--Boucle Principale
    void loop() {
      // put your main code here, to run repeatedly:
     
    }
    ensuite, j'imagine, que je dois déclarer mes entrées pour qu'elles puisse être utilisées?
    clairement ca je n'ai pas trop d'idée comment m'y prendre, car je dois aussi stocker le nombre d'évènements et le temps qui passe.

    Merci pour ton aide.

    Julien

  8. #8
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonsoir Julien
    Citation Envoyé par Jul04 Voir le message
    Est-ce-qu'avec cela, c'est bien parti?
    Oui, même très bien! T'est tu basé sur les articles de LOCODUINO?

    Citation Envoyé par Jul04 Voir le message
    Pour le problème d'alimentation, je pensais réduire l'intensité des leds en mettant une résistance en série, sur la sortie 5V, car en fait les Leds sont déjà trop lumineuses avec juste 150 et 100ohm. la maquette sera installée dans une pièce, et du coup peu de lumière du jour.
    Dans l'absolu, si j’utilisais un chargeur de téléphone 5VDC avec 1A je pourrait le faire fonctionner à ta méthode, vu que je commute l'allumage vers le potentiel 0V=> LOW
    C'est bien, quand c'est possible, de diminuer la consomation des LED, pour ce qui est de l'alimentation du montage, pour moi, il y a 3 méthodes avec un chargeur USB:
    1) connecter le câble USB sur le connecteur de l'Arduino et reprendre le 5V. sur la borne de l'Arduino pour alimenter les LED, pour moi, dans ce cas la moins bonne méthode car le courant des LED passe par le régulateur de l'Arduino.
    2) Faire un câble USB en Y pour alimenter l'Arduino et les LED "séparément".
    3) Alimenter les LED par le chargeuur et reprendre ce 5V. et alimenter l'Arduino par sa borne 5V. Dans ce cas, attention si ce montage est alimenté, en même temps par ce biais et par un câble USB sur son connecteur, la coéxistance est possible mais pas conseillée.

    Citation Envoyé par Jul04 Voir le message
    ensuite, j'imagine, que je dois déclarer mes entrées pour qu'elles puisse être utilisées?
    clairement ca je n'ai pas trop d'idée comment m'y prendre, car je dois aussi stocker le nombre d'évènements et le temps qui passe.
    Pour les autres entrées/sorties fais une liste et demain on s'attaque au sujet.

    Bonne soirée
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  9. #9
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,

    Oui le site de locoduino m'aide beaucoup, j'avais essayé de démarrer avec le blog d'eskimon (qui m'a aidé à pas mal de choses aussi), mais je me suis vite éparpillé.

    J'ai essayé de lister les différentes entrées sorties et variables:
    du coup je me suis dit que pour capter la variation de résistances de la photorésistance, il valait mieux une entrée analogique, avec un réglage de seuils.
    Ce qui m'a libéré une E/S numérique pour un éventuel buzzer.,
    de manière générale, pour les boutons poussoirs, est-ce que j'ai intérêt à plutôt utiliser les entrées numériques ou analogiques?
    j'aurais tendance à dire les numériques avec toujours comme possibilité d'utiliser les analogiques pour des raisons pratiques ( position du câblage, nombre d'E/S dispo...)
    Ou alors il y une simplicité différente à utiliser tel ou tel type d'entrées?

    Est-ce que le code ci-dessous semble cohérent?
    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
     
    //--Définitions
     
    //Constantes:
    //Temps
    const byte compteRebours = 45 ; // durée du programme en minutes
    const float tempsms = compteRebours*60000 ; // durée en ms => à utiliser pour les calculs
    const float periodeRedLed = tempsms/25 ; // durée d'un intervale entre l'allumage de la led rouge suivante
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté 
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement, 
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant 
    ( valeurs a tester sur maquette)*/
     
    //Sorties
    const byte pinOutRed[] = {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}; 
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    const byte pinOutBuzz = 4 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
     
    //Entrées
    const byte pinInStart = 1;  // Le Pin 1 (repéré 0) est affecté au démarrage 
    const byte pinInRAZ = 2 ; // Le pin 2 (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInEvent = 3 ; // le pin 3 (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A0 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
    const byte photoRseuilBas = 50 ; // seuil de déclenchement représentant la coupure du faisceau=> valeur à tester entre 0 et 1023
    const byte photoRseuilHaut = 800 ; // seuil de NON déclenchement représentant la NON coupure du faisceau=> valeur à tester entre 0 et 1023
     
     
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
     
    //-- Initialisation
    void setup() {
          for (int i = 0; i < 24; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
            pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
            digitalWrite(pinOutRed[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
            pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
            digitalWrite(pinOutBlue[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
          } // Fin de la boucle for
     
        } // Fin Setup
     
    //--Boucle Principale
    void loop() {
      // put your main code here, to run repeatedly:
     
    }
    Est-ce que ca tient la route pour l'instant?

    Pour ce qui est de l'alim Je pense que je vais prendre une alim 230V /USB 5V 1-1.5A, et confectionner un cordon Y. je prévoie un fusible verre rapide 0.5A pour protéger l'arduino en cas de court circuit?

    Merci
    Julien

  10. #10
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien

    Pour les entrées analogiques, elles peuvent s'utiliser de façon "numérique" exactement comme toutes les E/S numériques, avec les mêmes instructions.

    Pour la photorésistance, si un seuil précis n'est pas nécessaire, en mettant une résistance bien ajustée en série avec la cellule, c'est à dire, le GND, la cellule, la résistance et le 5V. la pin de l'Arduino connectée entre le cellule et la résistance, au moment de l'insolation, tu as un 0 ou LOW à la lecture du port.

    Pour les boutons poussoir, j'utilise toujours des entrées logiques initialisées input avec PULL_UP, ainsi pas besoin de résistances de polarisation de l'entrée donc simplification du câblage, ceci, pour autant que le milieu n'est pas trop perturbé electro-statiquement parlant. Si le milieu est perturbé, tu le remarquera assez rapidement, le fonctionnement de tes boutons devient erratique. Ainsi, tes boutons sont câblés "contre" GND et fournissent un 0 ou LOW sur l'entrée. Penses à étudier les divers façons d'éviter les rebonds des boutons.

    Ton code semble correct, j'aime beaucoup ta façon de nommer les variable, c'est claire et parlant. Nommer des variables de cette façon, même si c'est parfois assez long, évite souvent de mettre des remarques, il faut éviter des variables "plates" comme cellulenumeropin et mettre des majuscules celluleNumeroPin, ce que tu fais très bien.

    Pour régler le tempo (periodeRedLed) de ton programme, tu dois travailler avec la fonction millis() dans void loop(), millis() est l'horloge interne de l'Arduino en millisecondes qui s'utilise comme variable unsigned long (delay(), dans ce cas n'est pas possible)

    Ca avance super bien!
    Bonne journée.

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  11. #11
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    bonjour jpbbricole,

    Voic là ou je pense avoir atteint un certain niveau de désorientation.

    Car je ne sais pas comment construire à partir de là, la boucle principale.

    Peux-tu m'orienter à ce sujet?

    Merci

    Voici ce que j'ai adapté suite à tes conseils:

    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
    //--Définitions
     
    //Constantes:
    //Temps
    const byte compteRebours = 45 ; // durée en minutes du programme en minutes
    const float periodeRedLed = compteRebours/25 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté 
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement, 
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant 
    ( valeurs a tester sur maquette)*/
     
    //Sorties
    const byte pinOutRed[] = {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}; 
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    const byte pinOutBuzz = 4 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
     
    //Entrées
    const byte pinInBpStart = 1;  // Le Pin 1 (repéré 0) est affecté au démarrage 
    const byte pinInBpRAZ = 2 ; // Le pin 2 (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = 3 ; // le pin 3 (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A0 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
     
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
     
    //-- Initialisation
    void setup() {
          for (int i = 0; i < 24; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
            pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
            digitalWrite(pinOutRed[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
            pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
            digitalWrite(pinOutBlue[i], HIGH); // Toutes les pins ont pour valeur HIGH => éteintes
          } // Fin de la boucle for
     
        {// initialisation en tant que BP sans résistance additionnelle
        pinMode(pinInBpEvent,INPUT_PULLUP); 
        pinMode(pinInBpRAZ,INPUT_PULLUP);
        pinMode(pinInBpEvent,INPUT_PULLUP);
        }//fin intialisation BP
     
      } // Fin Setup
     
    //--Boucle Principale
    void loop() {
      // put your main code here, to run repeatedly:
     
    }
    Merci et bonne journée

  12. #12
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien

    J'ai ajouté quelques variables pour rendre le programme plus "confortable"
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED 
    ...
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
    ...
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    Le traitement des temps, en conjonction avec l'horloge interne, en millis() se fait, en général, avec des variables du type unsigned long.
    Tu remarquera l'usage du point d'exclamation ! devant une variable, cela veut dir NOT en logique booléenne et ça inverse la valeur. Ainsi, pour allumer une LED on utilise la valeur ledPinOnValue (déclarée à LOW donc 0) pour allumer la LED et son inverse !ledPinOnValue pour éteindre. Si, par exemple, tu désires utiliser des 1 pour allumer tes LED câblées "contre" GND, tu n'as qu'à changer:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    const byte ledPinOnValue = LOW;
    par
    const byte ledPinOnValue = HIGH;
    Si tu veux changer le nombre de LED, modifies la valeur de la variable ledsIndexMax.

    Je t'ai fais un exemple comment faire le tempo des LED rouges, elle doivent s'allumer, les unes après les autres. Joues avec ça. Tout tourne autour de l'usage de millis(). L'usage de delay() pour créer un tempo n'est pas possible car c'est une fonction "bloquante" et l'Arduino ne fait plus rien pendant ce temps. Avec la méthode des millis() le boucle loop() tourne toujours.
    Pour accélérer l'essai, j'ai baissé des variables, elle sont précédées pau un //!!!.
    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
    //--Définitions
     
    //Constantes:
    //Temps
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED 
    //!!!
    const byte compteRebours = 1; //45 ; // durée en minutes du programme en minutes 
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
     
    //!!!
    unsigned long ledRougePeriode = (compteRebours*12000)/ledsIndexMax+1 ; //(compteRebours*60000)/ledsIndexMax+1 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement,
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant
    ( valeurs a tester sur maquette)*/
     
    //Sorties
    const byte pinOutRed[] = {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};
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    const byte pinOutBuzz = 4 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
     
    //Entrées
    const byte pinInBpStart = 1;  // Le Pin 1 (repéré 0) est affecté au démarrage
    const byte pinInBpRAZ = 2 ; // Le pin 2 (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = 3 ; // le pin 3 (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A0 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
     
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
     
    //-- Initialisation
    void setup() {
    	Serial.begin(115200);
     
    	for (int i = 0; i <= ledsIndexMax; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
    		pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
    		digitalWrite(pinOutRed[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
    		pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
    		digitalWrite(pinOutBlue[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
    	} // Fin de la boucle for
     
    	{// initialisation en tant que BP sans résistance additionnelle
    		pinMode(pinInBpEvent,INPUT_PULLUP);
    		pinMode(pinInBpRAZ,INPUT_PULLUP);
    		pinMode(pinInBpEvent,INPUT_PULLUP);
    	}//fin intialisation BP
     
    	ledRougeIndex = -1; ledBleueIndex = 0;
    	Serial.println(ledRougePeriode);
    } // Fin Setup
     
    //--Boucle Principale
    void loop() {
    	//--------------------------------- Tempo des LED rouges
    	if (millis() - ledRougePeriodeStart >= ledRougePeriode)
    	{
    		ledRougeIndex ++;
    		if (ledRougeIndex > ledsIndexMax)
    		{
    			ledRougeIndex = 0;
    		}
    		//----------------------------- Eteindre la LED precedente
    		if (ledRougeIndex == 0)  // Si c'est la premiere
    		{
    			digitalWrite(pinOutRed[ledsIndexMax], !ledPinOnValue); // Eteindre la derniere LED
    		} 
    		else
    		{
    			digitalWrite(pinOutRed[ledRougeIndex-1], !ledPinOnValue); // Eteindre la LED precedente
    		}
     
    		digitalWrite(pinOutRed[ledRougeIndex], ledPinOnValue); // Allumer la LED courante
     
    		ledRougePeriodeStart = millis();         // Redemarrage du chrono de la periode
    	}
     
    }
    Pour la suite, fais une liste des événements du déroulement de ce que tu veux faire.

    Bonne journée
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  13. #13
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,

    J'ai injecté ton code, et ca fonctionne à merveille!
    (Ligne 77) :j'ai juste enlevé le point d’interrogation, pour ne pas éteindre la Led précédente, afin de voir l'ensemble des leds déjà écoulées allumées.

    Ensuite je souhaite que le démarrage de toute la boucle se fasse avec l'appui sur le BP ( pinInBpStart),
    à chaque fois qu'un jeton passe devant la photo résistance ( pinInPhotoR), le changement de sa valeur, suivant les temps à régler , ajoute une Led bleue.
    ou à chaque fois que le BP pinInBpEvent est préssé, on ajoute une Led bleue.

    Le BP pinInBpRAZ devra reseter le programme

    Et si possible lorsque la dernière Led Rouge est allumée, le buzzer peut être enclenché 10 secondes.

    Merci pour cette belle avancée!

  14. #14
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jppbricole,

    J'ai réussi à faire démarrer la boucle et la réinitialiser par commande de boutons poussoir, par contre je sais pas trop comment aborder l'allumage des leds bleues, en effet je souhaites qu'elles s'allument en fonction des deux evènements BPevent et photoR, mais je dois pas écrire correctement ma déclaration de variable comme étant la somme des deux évènements. Ensuite, je ne sais pas trop comment faire s'allumer toutes les leds de 0 à celle active.
    As-tu des pistes à me donner?

    Merci et bonne journée

    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    //--Définitions
     
    //Constantes:
    //Temps
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED 
    //!!!
    const byte compteRebours = 1; //45 ; // durée en minutes du programme en minutes 
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
     
    //!!!
    unsigned long ledRougePeriode = (compteRebours*10000)/ledsIndexMax+1 ; //(compteRebours*60000)/ledsIndexMax+1 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement,
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant
    ( valeurs a tester sur maquette)*/
     
    //Sorties
    const byte pinOutRed[] = {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};
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    //const byte pinOutBuzz = 0 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
     
    //Entrées
    const byte pinInBpStart = 0;  // Le Pin  (repéré 0) est affecté au démarrage
    const byte pinInBpRAZ = 1 ; // Le pin  (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = 2 ; // le pin  (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = 3 ; // le pin 3 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
     
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
     
    //-- Initialisation
    void setup() {
      Serial.begin(9600);
     
      for (int i = 0; i <= ledsIndexMax; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
        pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
        digitalWrite(pinOutRed[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
        pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
        digitalWrite(pinOutBlue[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
      } // Fin de la boucle for
     
      {// initialisation en tant que BP sans résistance additionnelle
        pinMode(pinInBpStart,INPUT_PULLUP);
        pinMode(pinInBpRAZ,INPUT_PULLUP);
        pinMode(pinInBpEvent,INPUT_PULLUP);
      }//fin intialisation BP
     
      ledRougeIndex = -1; ledBleueIndex = 0;
      Serial.println(ledBleueIndex);
    
    //  nombre de led bleues à allumer :
    int ledBleueIndex = evCountBPEvent + evCountPhotoR;
    
      
    } // Fin Setup
     
    //--Boucle Principale
    void loop() {
    
     // ------------ Démmarage du compte à rebours 
      if(digitalRead (pinInBpStart) == LOW) {// si le bouton START est appuyé 
        delay (1000); // pendant au moins 1 seconde
         if(digitalRead (pinInBpStart) == LOW){ //le bouton est encore appuyé
      evCountBPStart ++;// ajoute 1 au compteur d'évènements
      }}
      
      if(evCountBPStart > 0){// démarrage du programme
    
      
      //--------------------------------- Tempo des LED rouges
      if (millis() - ledRougePeriodeStart >= ledRougePeriode)
      {
        ledRougeIndex ++;
        if (ledRougeIndex > ledsIndexMax)
        {
          ledRougeIndex = 0;
        }
        //----------------------------- Eteindre la LED precedente
        if (ledRougeIndex == 0)  // Si c'est la premiere
        {
          //digitalWrite(pinOutRed[ledsIndexMax], !ledPinOnValue); // Eteindre la derniere LED
        } 
        else
        {
         // digitalWrite(pinOutRed[ledRougeIndex-1], ledPinOnValue); // Eteindre la LED precedente
        }
     
        digitalWrite(pinOutRed[ledRougeIndex], ledPinOnValue); // Allumer la LED courante
     
        ledRougePeriodeStart = millis();         // Redemarrage du chrono de la periode
      }
    //---------- Allummage LED Bleues
    
    
      if(digitalRead (pinInBpEvent) == LOW) {// si le bouton Event est appuyé 
        delay (1000); // pendant au moins 1 secondes
         if(digitalRead (pinInBpEvent) == LOW){ //le bouton est encore appuyé
      evCountBPEvent +1;// ajoute 1 au compteur d'évènements
      }}
       digitalWrite(pinOutBlue[ledBleueIndex], ledPinOnValue);
        
      }
    //
    
    
    //  ------- Redémarrage par bouton poussoir : reset-----
    
      if(digitalRead (pinInBpRAZ) == LOW) {// si le bouton RAZ est appuyé 
        delay (2000); // pendant au moins 2 secondes
         if(digitalRead (pinInBpRAZ) == LOW){ //le bouton est encore appuyé
      evCountBPRAZ ++;// ajoute 1 au compteur d'évènements
      }}
      
      if(evCountBPRAZ > 0){
        // Redémarre le programme depuis le début mais ne 
    // réinitialiser pas les périphériques et les registres
    
      asm volatile ("  jmp 0"); 
    } }

  15. #15
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien

    J'ai tenté de répondre à tes questions, voici le code corrigé pour te donner une idée.
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    //--Définitions
    
    //Constantes:
    //Temps
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED
    //!!!
    const byte compteRebours = 1; //45 ; // durée en minutes du programme en minutes
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
    
    //!!!
    unsigned long ledRougePeriode = (compteRebours*10000)/ledsIndexMax+1 ; //(compteRebours*60000)/ledsIndexMax+1 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement,
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant
    ( valeurs a tester sur maquette)*/
    
    //Sorties
    const byte pinOutRed[] = {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};
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    //const byte pinOutBuzz = 0 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
    
    //Entrées
    const byte pinInBpStart = 0;  // Le Pin  (repéré 0) est affecté au démarrage
    const byte pinInBpRAZ = 1 ; // Le pin  (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = 2 ; // le pin  (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = 3 ; // le pin 3 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
    
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
    
    //-- Initialisation
    void setup() {
    	Serial.begin(9600);
    	
    	for (int i = 0; i <= ledsIndexMax; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
    		pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
    		digitalWrite(pinOutRed[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
    		pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
    		digitalWrite(pinOutBlue[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
    	} // Fin de la boucle for
    	
    	{// initialisation en tant que BP sans résistance additionnelle
    		pinMode(pinInBpStart,INPUT_PULLUP);
    		pinMode(pinInBpRAZ,INPUT_PULLUP);
    		pinMode(pinInBpEvent,INPUT_PULLUP);
    	}//fin intialisation BP
    	
    	ledRougeIndex = -1; ledBleueIndex = 0;
    	Serial.println(ledBleueIndex);
    
    	//  nombre de led bleues à allumer :
    //	int ledBleueIndex = evCountBPEvent + evCountPhotoR; //***
    
    	
    } // Fin Setup
    
    //--Boucle Principale
    void loop() {
    
    	// ------------ Démmarage du compte à rebours
    	if(digitalRead (pinInBpStart) == LOW) {// si le bouton START est appuyé
    		delay (1000); // pendant au moins 1 seconde
    		if(digitalRead (pinInBpStart) == LOW){ //le bouton est encore appuyé
    			evCountBPStart ++;// ajoute 1 au compteur d'évènements
    		}}
    		
    		if(evCountBPStart > 0){// démarrage du programme
    
    			
    			//--------------------------------- Tempo des LED rouges
    			if (millis() - ledRougePeriodeStart >= ledRougePeriode)
    			{
    				ledRougeIndex ++;
    				if (ledRougeIndex > ledsIndexMax)
    				{
    					ledRougeIndex = 0;
    				}
    				//----------------------------- Eteindre la LED precedente
    				if (ledRougeIndex == 0)  // Si c'est la premiere
    				{
    					//digitalWrite(pinOutRed[ledsIndexMax], !ledPinOnValue); // Eteindre la derniere LED
    				}
    				else
    				{
    					// digitalWrite(pinOutRed[ledRougeIndex-1], ledPinOnValue); // Eteindre la LED precedente
    				}
    				
    				digitalWrite(pinOutRed[ledRougeIndex], ledPinOnValue); // Allumer la LED courante
    				
    				ledRougePeriodeStart = millis();         // Redemarrage du chrono de la periode
    			}
    			//---------- Allummage LED Bleues
    
    
    			if(digitalRead (pinInBpEvent) == LOW || digitalRead (pinInPhotoR) == LOW ) {// si le bouton Event est appuyé ou événement faisceau //***
    				delay (1000); // pendant au moins 1 secondes
    				if(digitalRead (pinInBpEvent) == LOW || digitalRead (pinInPhotoR) == LOW ){ //le bouton est encore appuyé  //***
    					evCountBPEvent +1;// ajoute 1 au compteur d'évènements
    				}}
    				//digitalWrite(pinOutBlue[ledBleueIndex], ledPinOnValue);  //***
    				if (evCountBPEvent > ledsIndexMax)  // Contrôler que l'on ne dépasse pas l'indes des LED  //***
    				{evCountBPEvent = ledsIndexMax;}
    				//--------------------- Allumage des LEDs bleues concernées et extinctions des autres
    				for (byte i = 0; i <= ledsIndexMax; i ++)
    				{
    					if (i < evCountBPEvent)  // Si dans la zone allumée    //***
    					{
    						digitalWrite(pinOutBlue[i], ledPinOnValue);
    					}
    					else
    					{
    						digitalWrite(pinOutBlue[i], !ledPinOnValue);
    					}
    	}
    			}
    			//
    
    
    			//  ------- Redémarrage par bouton poussoir : reset-----
    
    			if(digitalRead (pinInBpRAZ) == LOW) {// si le bouton RAZ est appuyé
    				delay (2000); // pendant au moins 2 secondes
    				if(digitalRead (pinInBpRAZ) == LOW){ //le bouton est encore appuyé
    					evCountBPRAZ ++;// ajoute 1 au compteur d'évènements
    				}}
    				
    				if(evCountBPRAZ > 0){
    					// Redémarre le programme depuis le début mais ne
    					// réinitialiser pas les périphériques et les registres
    
    					asm volatile ("  jmp 0");
    				} }
    J'ai fais des modifications aux endroits ou régions marquées par un //***
    J'ai pas pu essayer, mais ça compile nickel!

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  16. #16
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    août 2019
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes de Haute Provence (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : août 2019
    Messages : 9
    Points : 1
    Points
    1

    Par défaut

    Bonjour jpbbricole,

    En fait ce que je souhaiterai plutôt c'est que :
    au démarrage de la boucle aucune led bleue ne soit allumée et qu'ensuite, dès qu'on appuie sur le BPevent, ou que lorsque le faisceau est interrompu, une nouvelle led bleue s'allume, et ainsi on augmente le nombre de leds bleues allumées.
    au début aucune led bleu allumée puis par pression, la led1 s'allume, puis par la photorésistance la led 2 s'ajoute , puis la led 3 en plus avec de nouveau le passage d'un jeton devant la photo résistance et ainsi de suite jusqu'à la fin

    J'ai essayé de bidouiller avec le code que tu as écris, mais je n'arrive pas tout à fait à faire fonctionner cela .

    Car en réalité le jeton a une vitesse de passage variable, et du coup j’aurais aimé que pour compter un nouvel évènement, je repasse au dessus du seuil fixé (photoSeuil)
    De plus parfois l'évènement du jeton devant la photorésistance n'est pas pris en compte, même avec le temps et éclairage correct. j'ai l'impression que la boucle se fige pendant ce temps là. comment résoudre ce soucis?


    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    //--Définitions
    
    //Constantes:
    //Temps
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED
    //!!!
    const byte compteRebours = 1; //45 ; // durée en minutes du programme en minutes
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
    
    //!!!
    const int photoSeuil=200;
    unsigned long ledRougePeriode = (compteRebours*60000)/ledsIndexMax+1 ; //(compteRebours*60000)/ledsIndexMax+1 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement,
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant
    ( valeurs a tester sur maquette)*/
    
    //Sorties
    const byte pinOutRed[] = {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};
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    //const byte pinOutBuzz = 0 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
    
    //Entrées
    const byte pinInBpStart = 0;  // Le Pin  (repéré 0) est affecté au démarrage
    const byte pinInBpRAZ = 1 ; // Le pin  (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = 2 ; // le pin  (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A1 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
    
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
    int valPhotoR = 0;
    
    
    
    //-- Initialisation
    void setup() {
      Serial.begin(115200);
      
      for (int i = 0; i <= ledsIndexMax; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
        pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
        digitalWrite(pinOutRed[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
        pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
        digitalWrite(pinOutBlue[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
      } // Fin de la boucle for
      
      {// initialisation en tant que BP sans résistance additionnelle
        pinMode(pinInBpStart,INPUT_PULLUP);
        pinMode(pinInBpRAZ,INPUT_PULLUP);
        pinMode(pinInBpEvent,INPUT_PULLUP);
        pinMode(pinInPhotoR, INPUT);
      }//fin intialisation BP + photorésistance
      
      ledRougeIndex = -1; ledBleueIndex = -1;
      Serial.println(valPhotoR);
    
      //  nombre de led bleues à allumer :
    //  int ledBleueIndex = evCountBPEvent + evCountPhotoR; //***
    
      
    } // Fin Setup
    
    //--Boucle Principale
    void loop() {
    valPhotoR = analogRead(pinInPhotoR) ;
      // ------------ Démmarage du compte à rebours
      if(digitalRead (pinInBpStart) == LOW) {// si le bouton START est appuyé
        delay (1000); // pendant au moins 1 seconde
        if(digitalRead (pinInBpStart) == LOW){ //le bouton est encore appuyé
          evCountBPStart ++;// ajoute 1 au compteur d'évènements
        }}
        
        if(evCountBPStart > 0){// démarrage du programme
    
          
          //--------------------------------- Tempo des LED rouges
          if (millis() - ledRougePeriodeStart >= ledRougePeriode)
          {
            ledRougeIndex ++;
            if (ledRougeIndex > ledsIndexMax)
            {
              ledRougeIndex = 0;
            }
           /* //----------------------------- Eteindre la LED precedente
            if (ledRougeIndex == 0)  // Si c'est la premiere
            {
              digitalWrite(pinOutRed[ledsIndexMax], !ledPinOnValue); // Eteindre la derniere LED
            }
            else
            {
              digitalWrite(pinOutRed[ledRougeIndex-1], ledPinOnValue); // Eteindre la LED precedente
            }*/
            
            digitalWrite(pinOutRed[ledRougeIndex], ledPinOnValue); // Allumer la LED courante
            
            ledRougePeriodeStart = millis();         // Redemarrage du chrono de la periode
          }
          
          //---------- Allummage LED Bleues par Bouton
    
    
          if(digitalRead (pinInBpEvent) == LOW ) {// si le bouton Event est appuyé ou événement faisceau //***
            delay (1000); // pendant au moins 1 secondes
            if(digitalRead (pinInBpEvent) == LOW  ){ //le bouton est encore appuyé  //***
              evCountBPEvent = evCountBPEvent + 1;// ajoute 1 au compteur d'évènements
            }}
          
           //---------- Allummage LED Bleues par photoRésistance
           
           if(analogRead (pinInPhotoR) >photoSeuil ) {// si le bouton Event est appuyé ou événement faisceau //***
            delay (300); // pendant au moins 50 milisecondes
            if(analogRead (pinInPhotoR) >photoSeuil ){ //le jeton est encore appuyé  //***
            
              evCountBPEvent = evCountBPEvent + 1;// ajoute 1 au compteur d'évènements
            }}
            //digitalWrite(pinOutBlue[ledBleueIndex], ledPinOnValue);  //***
            
                 if (evCountBPEvent > ledsIndexMax)  // Contrôler que l'on ne dépasse pas l'indes des LED  //***
                       { evCountBPEvent = ledsIndexMax;}
    
         
            //--------------------- Allumage des LEDs bleues concernées et extinctions des autres
    
            
            for (byte i = 0; i <= ledsIndexMax; i ++)
            {
             if (i < evCountBPEvent)  // Si dans la zone allumée    //***
              {
                digitalWrite(pinOutBlue[i], ledPinOnValue);
              /*}
            //  else
             // {
              //  digitalWrite(pinOutBlue[i], !ledPinOnValue);
                }*/
              }
          }
          //
    
    
          //  ------- Redémarrage par bouton poussoir : reset-----
    
          if(digitalRead (pinInBpRAZ) == LOW) {// si le bouton RAZ est appuyé
            delay (2000); // pendant au moins 2 secondes
            if(digitalRead (pinInBpRAZ) == LOW){ //le bouton est encore appuyé
              evCountBPRAZ ++;// ajoute 1 au compteur d'évènements
            }}
            
            if(evCountBPRAZ > 0){
              // Redémarre le programme depuis le début mais ne
              // réinitialiser pas les périphériques et les registres
    
              asm volatile ("  jmp 0");
            } 
            }}
    merci beaucoup

    Julien

  17. #17
    Membre du Club
    Homme Profil pro
    savant fou
    Inscrit en
    septembre 2019
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : savant fou

    Informations forums :
    Inscription : septembre 2019
    Messages : 34
    Points : 53
    Points
    53

    Par défaut

    Citation Envoyé par Jul04 Voir le message
    Car en réalité le jeton a une vitesse de passage variable, et du coup j’aurais aimé que pour compter un nouvel évènement, je repasse au dessus du seuil fixé (photoSeuil)
    De plus parfois l'évènement du jeton devant la photorésistance n'est pas pris en compte, même avec le temps et éclairage correct. j'ai l'impression que la boucle se fige pendant ce temps là. comment résoudre ce soucis?
    Votre souci c’est l’usage de la fonction delay() pour voir si un événement se produit pendant plus d’une seconde. Si le premier front «*bouton*» est détecté vous rentrez dans un délai qui fait que plus rien d’autre est testé pendant ce temps là et si un jeton arrive, il n’est pas «vu».

    Si c’est bien de cela dont vous parlez, Il faudrait donc changer d’approche et traiter la structure du code différemment (avec un graphe d’états ou machine à états) en utilisant la fonction millis() . ça nécessite une refonte sérieuse du code, donc est-ce bien le souci que vous décrivez ?


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    unsigned long ledRougePeriode = (compteRebours*60000)/ledsIndexMax+1 ; //(
    Attention aux règles mathématiques dans les calculs, parfois ça peut jouer des tours... il serait bin de préciser 60000UL pour forcer le calcul en unsigned long.

  18. #18
    Membre éclairé
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    février 2013
    Messages
    265
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : février 2013
    Messages : 265
    Points : 679
    Points
    679

    Par défaut

    Bonjour Julien

    J'ai réattribué les pin des boutons, tu utilisait les entrées 0, 1, 2 et 0 et 1 sont aussi les ports de communications de l'USB et peuvent âtre en conflits suivant l'usage de tes boutons.
    Comme il ne reste plus que les ports analogiques de libre on peut très bien les utiliser en logique.
    Contrôle la condition
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    	if(digitalRead (pinInPhotoR) == LOW ) {// si le bouton Event est appuyé ou événement faisceau //***
    quand la pièce est devant la cellule si tu as bien LOW.

    J'ai ajouté une fonction void ledsAllumerJusqua, tu comprendra assez vite son utilité.
    Comme je n'ai pas assez de LEDs, j'ai inclu une "simulation" dans ton programme et elles s'affichent dans la console.
    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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    //--Définitions
    
    //Constantes:
    //Temps
    const byte ledsIndexMax = 24;   // Numeratotation maximum des LED
    //!!!
    const byte compteRebours = 1; //45 ; // durée en minutes du programme en minutes
    byte ledRougeIndex, ledBleueIndex;   // Pour memoriser la position de la led "en travail"
    const byte ledPinOnValue = LOW;        // Quel valeur sur le port pour allumer la LED
    
    //!!!
    const int photoSeuil=200;
    unsigned long ledRougePeriode = (compteRebours*60000)/ledsIndexMax+1 ; //(compteRebours*60000)/ledsIndexMax+1 ; // durée en minutes d'un intervale entre l'allumage de la led rouge suivante
    unsigned long ledRougePeriodeStart = millis();   // Chrono de la periode des LED rouges
    const int photoRcapture = 50; /* durée en ms du passage du jeton devant le faisceau pour être compté
    comme évènement déclenchant ( a tester sur maquette)*/
    const int photoRcaptureoff=150; /* durée en ms du NON passage de jeton devant le faisceau pour permettre un nouveau comptage d'évènement,
    en repassant par le seuil haut , un nouvel enregistrement de seuil bas permet alors d'être compté comme évènement déclenchant
    ( valeurs a tester sur maquette)*/
    
    //Sorties
    const byte pinOutRed[] = {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};
    // Déclaration et initialisation d'un tableau leds rouges (qui doivent évoluer avec le temps), connectées au broches repérées 4 (pos.Tabl.0) à 28(pos.Tabl.24)
    const byte pinOutBlue[] = {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};
    // Déclaration et initialisation d'un tableau Bleues (qui doivent évoluer avec les évènements), connectées au broches repérées 29 (pos.Tabl.0) à 53 (pos.Tabl.24)
    //const byte pinOutBuzz = 0 ; // le pin 4 (repéré 3)sera utilisé pour allumer un buzzer =>> option
    
    //Entrées
    const byte pinInBpStart = A1;  // Le Pin  (repéré 0) est affecté au démarrage
    const byte pinInBpRAZ = A2 ; // Le pin  (repéré 1)sert à l'arret et la réinitialisation du compte à rebours
    const byte pinInBpEvent = A3 ; // le pin  (repéré 2)sera utilisé pour ajouter un évènement, et augmenter le nombre  de Led Bleues alumées
    const byte pinInPhotoR = A0 ; // le pin A0 (repéré A0)sera utilisé pour ajouter un évènement sur rupture du faisceau de la photorésistance, et augmenter le nombre  de Led Bleues alumées
    
    //Variables
    int evCountBPStart = 0 ; // comptage du nombre de pression démarrage => 0 au début
    int evCountBPRAZ = 0 ;  // comptage du nombre de pression remise à Zero de la boucle principale => 0 au début
    int evCountBPEvent = 0 ;  // comptage du nombre de pression sur le bouton évènement manuel => 0 au début
    int evCountPhotoR = 0 ;  // comptage du nombre de passage devant le faisceau de la photorésistance => 0 au début
    int valPhotoR = 0;
    
    
    
    //-- Initialisation
    void setup() {
      Serial.begin(115200);
      
      for (int i = 0; i <= ledsIndexMax; i++) {//pour les entiers de 0 à 24, définissons,pour chacun d'eux, un par un de plus:
        pinMode(pinOutRed[i], OUTPUT);    // Toutes les pins ROUGES  sont commutées en OUT
        digitalWrite(pinOutRed[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
        pinMode(pinOutBlue[i], OUTPUT);    // Toutes les pins BLEUES sont commutées en OUT
        digitalWrite(pinOutBlue[i], !ledPinOnValue); // Toutes les pins ont pour valeur HIGH => éteintes
      } // Fin de la boucle for
      
      {// initialisation en tant que BP sans résistance additionnelle
        pinMode(pinInBpStart,INPUT_PULLUP);
        pinMode(pinInBpRAZ,INPUT_PULLUP);
        pinMode(pinInBpEvent,INPUT_PULLUP);
        pinMode(pinInPhotoR, INPUT_PULLUP);
      }//fin intialisation BP + photorésistance
      
      ledRougeIndex = -1; ledBleueIndex = -1;
      Serial.println(valPhotoR);
    
      //  nombre de led bleues à allumer :
    //  int ledBleueIndex = evCountBPEvent + evCountPhotoR; //***
    
      
    } // Fin Setup
    
    //--Boucle Principale
    void loop() {
    valPhotoR = analogRead(pinInPhotoR) ;
    
      // ------------ Démmarage du compte à rebours
      if(digitalRead (pinInBpStart) == LOW) {// si le bouton START est appuyé
        delay (1000); // pendant au moins 1 seconde
        if(digitalRead (pinInBpStart) == LOW){ //le bouton est encore appuyé
          evCountBPStart ++;// ajoute 1 au compteur d'évènements
          Serial.println("Start");}}
    	  
        if(evCountBPStart > 0){// démarrage du programme      
          //--------------------------------- Tempo des LED rouges
          if (millis() - ledRougePeriodeStart >= ledRougePeriode)
          {
            ledRougeIndex ++;
            if (ledRougeIndex > ledsIndexMax)
            {
              ledRougeIndex = 0;
            }
    		ledsAllumerJusqua(pinOutRed, ledsIndexMax, ledRougeIndex, "r");
            
            //digitalWrite(pinOutRed[ledRougeIndex], ledPinOnValue); // Allumer la LED courante
            
            ledRougePeriodeStart = millis();         // Redemarrage du chrono de la periode
          }
          
          //---------- Allummage LED Bleues par Bouton
    
    
        if(digitalRead (pinInBpEvent) == LOW ) 
    	{// si le bouton Event est appuyé ou événement faisceau //***
            delay (1000); // pendant au moins 1 secondes
            if(digitalRead (pinInBpEvent) == LOW  ) { //le bouton est encore appuyé  //***
              evCountBPEvent = evCountBPEvent + 1;// ajoute 1 au compteur d'évènements
    		  ledsAllumerJusqua(pinOutBlue, ledsIndexMax, evCountBPEvent, "b");
    		  while(digitalRead (pinInBpEvent) == LOW){}; // Tant que le bouton est pressé pour éviter la répétition
            }}
          
           //---------- Allummage LED Bleues par photoRésistance
           
    	if(digitalRead (pinInPhotoR) == LOW ) {// si le bouton Event est appuyé ou événement faisceau //***
    		delay (300); // pendant au moins 50 milisecondes
    		if(digitalRead (pinInPhotoR) == LOW ){ //le jeton est encore appuyé  //***
    
    			evCountBPEvent = evCountBPEvent + 1;// ajoute 1 au compteur d'évènements
    			ledsAllumerJusqua(pinOutBlue, ledsIndexMax, evCountBPEvent, "b");
    		    while(digitalRead (pinInPhotoR) == LOW ){}; // Tant que le bouton est pressé pour éviter la répétition
            }}
          
    
    
          //  ------- Redémarrage par bouton poussoir : reset-----
    
          if(digitalRead (pinInBpRAZ) == LOW) {// si le bouton RAZ est appuyé
            delay (2000); // pendant au moins 2 secondes
            if(digitalRead (pinInBpRAZ) == LOW){ //le bouton est encore appuyé
              evCountBPRAZ ++;// ajoute 1 au compteur d'évènements
            }}
            
            if(evCountBPRAZ > 0){
             // Redémarre le programme depuis le début mais ne
              // réinitialiser pas les périphériques et les registres
    
              asm volatile ("  jmp 0");
            } 
            }}
    		
    /*------------------------------------------------------------------------
    	Allumer les LED jusqu'a une position
    	Si position < 0 = tout eteindre
    	Entrée, tableau, dimension du tableau, jusqu'à quelle LED, couleur en texte
      ------------------------------------------------------------------------
    */
    void ledsAllumerJusqua(byte tableauPin[], byte tableauPinDim, byte ledJusqua, String colStr)	
    {
    	String pseudoLeds = "";
    	
    	if (ledJusqua > tableauPinDim) {ledJusqua = tableauPinDim;}
    	for (byte i = 0; i <= tableauPinDim; i ++)
    	{
    		if (i > ledJusqua)  // Si pas dans la zone allumée donc éteindre
    		{
    			colStr.toLowerCase();
    			digitalWrite(tableauPin[i], !ledPinOnValue);
    			pseudoLeds += colStr;
    		}
    		else
    		{
    			colStr.toUpperCase();
    			digitalWrite(tableauPin[i], ledPinOnValue);
    			pseudoLeds += colStr;
    		}
    	}
    	Serial.println(pseudoLeds);
    }
    Atention à l'usage de dalay(), pendant ce temps, ton programme "ne fait rien", comme l'a indiqué @Jay M dans son post précédent, pendant un delay(), si une pièce passe devant la cellule, tu ne va rien voire!

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

Discussions similaires

  1. Réponses: 0
    Dernier message: 30/12/2016, 18h32
  2. Réponses: 7
    Dernier message: 14/08/2016, 23h58
  3. [Mobile] Petit conseil pour programmer sur un Nokia N70
    Par GarulfoLinux dans le forum Mobiles
    Réponses: 8
    Dernier message: 09/03/2007, 11h41
  4. Réponses: 16
    Dernier message: 15/11/2005, 20h07
  5. Conseils pour démarrer en programmation ?
    Par Osirex dans le forum Débuter
    Réponses: 5
    Dernier message: 06/10/2005, 18h28

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