11 leds indépendantes

Bonjour
voici mon projet, a partir d'une carte maritime, j'ai représenté les phares par des leds (11 en tous) et qu'ils s'allument en "temps reel"
comme tous les phares ne s'allument et ne s'éteintes pas en même temps ,il faut que je puisse contrôlé chaque led, une qui va s'allumé 2 fois1 sec et s'éteindre 6 sec et recommencé sont cycle , l'autre s'allume 9 fois 0.5sec et s'éteindre 10sec ...
Chaque LED est branché sur une broche de mon arduino de la broche 2 a la broche 12
Le problème que je rencontre et que c'est un montage en serie , ca fait qu'il prend en conte une led par une led, et du coup il lit broche N°2, broche N°3...
je travail avec une carte elegoo uno R3

dsl voici les codes un peu bricolé pour pouvoir réallumé mes leds 2 sec plus tard,
si quelqu'un un une petite idee elle sera la bienvenue :wink:

void setup() {
pinMode(12,OUTPUT); // led bleu
pinMode(11,OUTPUT); // led rouge
pinMode(10,OUTPUT); // led verte
pinMode(9,OUTPUT); // led jaune
pinMode(8,OUTPUT); // led bleu
pinMode(7,OUTPUT); // led bleu
pinMode(6,OUTPUT); // led bleu
pinMode(5,OUTPUT); // led bleu
pinMode(4,OUTPUT); // led bleu
pinMode(3,OUTPUT); // led bleu
pinMode(2,OUTPUT); // led bleu
}

void loop() {
digitalWrite(12,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(12,LOW); // led bleu éteinte
delay(500);
digitalWrite(12,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(12,LOW); // led bleu éteinte
delay(100);
digitalWrite(11,HIGH); //led vrte allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,LOW); //led jaune allumée
digitalWrite(10,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(9,HIGH); //led bleu allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,LOW); //led jaune allumée
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);
digitalWrite(7,HIGH); //led vrte allumée
delay(500); // pause 0.5 seconde
digitalWrite(7,LOW); // led bleu éteinte
delay(1000);
digitalWrite(6,HIGH); //led jaune allumée
delay(1000); // pause 0.5 seconde
digitalWrite(6,LOW); // led bleu éteinte
delay(500);
digitalWrite(8,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,LOW); //led jaune allumée
digitalWrite(5,HIGH); //led bleu allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);
digitalWrite(8,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,LOW); //led jaune allumée
digitalWrite(7,HIGH); //led vrte allumée
delay(500); // pause 0.5 seconde
digitalWrite(7,LOW); // led bleu éteinte
delay(1000);
digitalWrite(3,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(3,LOW); // led bleu éteinte
delay(50);
digitalWrite(6,HIGH); //led jaune allumée
delay(1000); // pause 0.5 seconde
digitalWrite(6,LOW); // led bleu éteinte
delay(500);
digitalWrite(2,HIGH); //led jaune allumée
delay(500);
digitalWrite(2,LOW); // led bleu éteinte
delay(500);// pause 0.5 seconde
digitalWrite(8,HIGH); //led rouge allumée
delay(500); // pause 0.5 seconde
digitalWrite(8,LOW); //led jaune allumée
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);
digitalWrite(4,HIGH); //led jaune allumée
delay(500); // pause 0.5 seconde
digitalWrite(4,LOW); // led bleu éteinte
delay(500);

}

Bonjour,

Met ton code entre balises de code.

Regarde l'exemple blink without delay

2 Likes

Bonsoir rem29

Pour te simplifier le câblage et la programmation, n'aurais-tu pas intérêt à utiliser des LED RGB du type WS2812, tu n'aurais qu'un fil (plus l'alimentation) qui se "promènerai " d'un phare à l'autre.

Cordialement
jpbbricole

1 Like

Peut être des idées à prendre si vous lisez cette discussion ici

1 Like

merci pour ta réponse , mon souci c'est que 5 phares peu clignotés en mm temps mais pas dans les mm délai sur 11 phares mon problème c'est un phares qui clignote puis un autre ,

Bonsoir rem29

Ma suggestion d'utiliser des LED RGB de type WS2812 était pour te faciliter le câblage et la gestion mais ne résolvait pas ton problème de timing. Pour ce type de tempos indépendants, il faut impérativement travailler avec millis() et avec des machines à état, @J-M-L en est le spécialiste.

Cordialement
jpbbricole

1 Like

je te remercie jpbbricole :wink:

je voulais savoir si mon branchement et bon et d'avoir un debut de code :smiley:

Pour vérifier un branchement c'est quand même mieux d'avoir un schéma :grinning:
Mais à mon avis tu n'en es pas encore au schéma électrique.

Pour tes 11 phares effectivement le mieux serait une machine à état.

Mais avant voici ce que je ferai pour préparer l'écriture du code.
Les phares sont tous différents tant en rythme qu'en successions d'éclats et période de récurence.

Je prendrais une feuille de papier.
je dessinerais le "signal de phare, un phare par ligne soit 11 lignes.
Cela permettra de visualiser le travail a faire.

Il faut commencer par trouver le PPCM (plus petit commun multiple) de toutes les périodes de récurrence.
C'est obligatoire pour fixer ce qu'il y aura dans la fonction loop().
Exemple si P1 à une période de 2 et P4 une période de 3,5, quand P1 et P4 termineront-ils un cycle ensemble ?
Le PPCM de 2 et 3,5 est 14 donc, P1 aura fait 7 cycles quand P4 en aura fait 4.

Je pense qu'il faut aussi trouver le PGCD (plus grand commun diviseur) pour les temps de 1 et de 0 ce qui permettra de définir l'incrément de temps pour le test dans la machine à état.

2 Likes

Bonsoir

Sujet intéressant!

Je travaillerai avec l'unité de temps la plus petite, c'est à dire, 0,5 secondes.
Il y aurait un tempo réglé par millis() de 0,5 sec.
Une structure pour définir un phare avec nombre de clignotements, tempo du clignotement, compteur de clignotements, temps de pause, etat (en clignotement ou en pause) et mémorisation des millis(), le tout mis en tableau[11].
Le tableau serait mis à jour et évalué par le tempo de 0.5 sec. Ainsi on aurait 11 machines indépendantes.

Cordialement
jpbbricole

1 Like

Le plus simple serait d'utiliser une bibliothèque pour créer et gérer des machines d'états. Je crois que @bricoleau en propose une. S'il passe par ici, il peut en parler.

1 Like

Chaque phare est indépendant, on ne parle pas de timing à la microseconde donc on peut appliquer simplement blink without delay : juste 11 structures dans un tableau, chaque structure décrit un phare donné et la loop vérifie les 11 phares, définit l’état de chaque led puis les allume ou éteint…pas besoin de pgcd ou ppcm, juste un usage de millis répété 11 fois (dans une boucle)

1 Like

Bon, je suis d'accord avec ce que propose @68tjs. La séquence d'un phare peut être représentée de cette manière :

Nous mettons l'un en dessous de l'autre et nous prenons graphiquement le PGCD , qui dans le graphique précédent sont des secondes, presque certainement un certain nombre de millis sortira. Et c'est tout, un certain nombre de delay (x) suivi de 11 digital.Write. Pour moi, une autre chose est de me compliquer la vie.
Salutations à tous.

1 Like

merci J-M-L
C'est un code comme celui la qu'il faut que j'utilise ?
je peux juste changer la valeur de mon clignotement mais pas faire mes 2 clignotements de 1 sec et de le mettre en pause pendant 6 sec, tu aurai pas une petite idée ?
const int ledPin = 6; // the number of the LED pin

// Variables will change :
int ledState = LOW; // ledState used to set the LED

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0; // will store last time LED was updated

// constants won't change :
const long interval = 1000; // interval at which to blink (milliseconds)

void setup() {
// set the digital pin as output:
pinMode(ledPin, OUTPUT);
}

void loop() {
// here is where you'd put code that needs to be running all the time.

// check to see if it's time to blink the LED; that is, if the
// difference between the current time and last time you blinked
// the LED is bigger than the interval at which you want to
// blink the LED.
unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;

// if the LED is off turn it on and vice-versa:
if (ledState == LOW) {
  ledState = HIGH;
} else {
  ledState = LOW;
}

// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);

}
}
merci

Désolé d'insister, mais il existe des bibliothèques pour faire ça :

Tu trouveras un exemple de blink dans ce lien, il suffit de créer 11 instances (il appelle ça des tâches) et ça roule tout seul.

Dans ton cas, comme tes phares font du morse, c'est un peu plus compliqué, mais c'est faisable. Une solution est d'utiliser des compteurs dans les tâches.

La tâche s'exécute toutes les secondes : à chaque fois tu incrémentes le compteur. S'il vaut 0, tu allumes, s'il vaut 1 tu éteins, 2 tu allumes, 3 tu éteins, 9 tu recommences à 0.

Merci de prendre en compte les recommandations listées dans "Les bonnes pratiques du Forum Francophone” et d'éditer votre post #15 pour rajouter les balises de code.

Il faudra définir exactement ce qu'est un "clignotement" (par exemple "2 clignotements de 1 sec et de le mettre en pause pendant 6 sec" n'est pas suffisant, il faut préciser si 1s c'est la durée ON puis OFF ou si c'est la durée totale.) et trouver un mode de représentation adapté

il existe une codification formelle des feux cf Sentinelles des Mers, peut être s'en inspirer (mais ne pas traiter tous les cas)

La liste des noms des phares concernés serait aussi bien utile et agréable.

Sur ce forum les échanges ne se font pas à sens unique du demandeur vers les aidants.

Les aidants apprécient aussi de découvrir des nouveaux domaines, donc pas de rétention d'information.

Bonjour rem29

Je me suis "amusé" à l'exercice :wink:

Le tout s'articule autour de la structure phare. Le timing est assuré par les millis().
L'unité de base de temps est
const unsigned long phareTempoTemps = 500; // Unité base de temps en milliSecondes

Il y a seulement 5 phares, mais c'est facile d'en ajouter, il suffit uniquement de dupliquer une de ces ligne et d'en modifier les paramètres.
{"Phare 5", 8, phareEtatClignottement, 6, 0, phareTempoTemps1, 3000, 0},*
Je pense que le nom des variables et les remarques sont suffisamment explicites, mais je suis à ta disposition pour toutes questions, remarques.

Je réitère ma remarque sur le fait que ce serai encore plus fun avec des LEED de type WS2812. C''est aisément adaptable. Le câblage est aussi plus simple et aisément extensible, si tu veux augmenter le nombre de phares, tu n'auras pas besoin de changer d'Arduino puisque ces LED RGB ne nécessitent qu'un port en tout et pour tout, pour leur bus..

Le programme:

/*
    Name:       ARDFR_PharesIndependants.ino
    Created:	03.11.2021 08:32:05
    Author:     jpbbricole
*/

const unsigned long phareTempoTemps = 500;     // Unité base de temps en milliSecondes
unsigned long phareTempoBaseMillis = millis();     // Chrono pour tempo
enum phareEtatIndex {phareEtatClignottement, phareEtatPause, phareEtatNombre};

const int ledOnEtat = HIGH;     // Etat pour allumer la LED

//-------------------------------------Définition des phares
struct phareDef
{
	const String nom;     // Nom du phare
	const int ledPin;     // Pin de la LED
	int etat;     // En pause ou en clignotement
	const int clignNombre;     // Nombre de clignotements
	int clignCompteur;     // Compteur de clignotements
	const unsigned long clignTemps;     // Temps de clignotements
	const unsigned long pauseTemps;     // Temps de la pause
	unsigned long phareTemps;     // Temps du clign ou de la pause
	unsigned long phareMillis;     // Millis du clign ou de la pause
};

//********************************** Paramètres par défaut **********************************
phareDef phare[] =     
{
	//   Nom,    pin LED,           Etat,             Clign nombre,   compteur   clign tempo,             Pause temps       
	{"Phare 1",    12,     phareEtatClignottement,      6,              0,         phareTempoTemps*1,         3000,       0},
	{"Phare 2",    11,     phareEtatPause,              2,              0,         phareTempoTemps*3,         3000,       0},
	{"Phare 3",    10,     phareEtatClignottement,      10,             0,         phareTempoTemps*1,         7000,       0},
	{"Phare 4",     9,     phareEtatPause,              7,              0,         phareTempoTemps*2,         7000,       0},
	{"Phare 5",     8,     phareEtatClignottement,      6,              0,         phareTempoTemps*1,         3000,       0},
};
const int pharesNombreMax = sizeof(phare)/sizeof(phare[0]);


void setup()
{
	Serial.begin(115200);
	// Initialisation des phares d'après les paramètres par défaut
	for (int ph = 0; ph < pharesNombreMax; ph ++)
	{
		pinMode(phare[ph].ledPin, OUTPUT);
		digitalWrite(phare[ph].ledPin, !ledOnEtat);     // Extinction dee LED
		
		switch(phare[ph].etat)
		{
			case phareEtatClignottement:
				phare[ph].phareTemps = phare[ph].clignTemps;
				break;
			case phareEtatPause:
				phare[ph].phareTemps = phare[ph].pauseTemps;
				break;
			default:
				phare[ph].phareTemps = 0;
				break;
		}
		phare[ph].phareMillis = millis();
	}
}

void loop()
{
	if (millis()-phareTempoBaseMillis >= phareTempoTemps)
	{
		for (int ph = 0; ph < pharesNombreMax; ph ++)
		{
			switch(phare[ph].etat)
			{
				case phareEtatClignottement:
					if (millis()-phare[ph].phareMillis >= phare[ph].phareTemps)     // Si fin de periode de clignotrement
					{
						phare[ph].clignCompteur ++;
						if (phare[ph].clignCompteur > phare[ph].clignNombre*2)     // Si fin séquence clignotement
						{
							phare[ph].clignCompteur = 0;
							phare[ph].phareTemps = phare[ph].pauseTemps;
							digitalWrite(phare[ph].ledPin, !ledOnEtat);
							phare[ph].etat = phareEtatPause;     // Changement d'état
						} 
						else
						{
							digitalWrite(phare[ph].ledPin, !digitalRead(phare[ph].ledPin));     // Inversion de la LED
						}
						phare[ph].phareMillis = millis();
					}
					break;
				case phareEtatPause:
					if (millis()-phare[ph].phareMillis >= phare[ph].phareTemps)     // Si fin de periode pause
					{
						phare[ph].phareMillis = millis();
						phare[ph].phareTemps = phare[ph].clignTemps;
						phare[ph].etat = phareEtatClignottement;     // Changement d'état
					}
					break;
			}
		}
		phareTempoBaseMillis = millis();
	}

}

Mise à par l'illumination de phares, c'est idéal pour animer un sapin de Noël!

Cordialement
jpbbricole

oui dsl 68 tjs voici comment ce présente le projet
ici nous avons une carte SHOM une carte maritime qui représente le Finistère sud , de la pointe de Penmarc'h a la pointe de Trevignon
on peut compté 11 phares en tout, comme le phare de d'eckmuhl ,phare men hir " pointe de penmarc'h", le phare de la croix "concarneau" phare des moutons "ile de glenan"
sur la carte on trouve la légende FI (3) WG 6S 12M
FI (3) cela veut dire "éclat groupé" dans 6 sec il va avoir 3 éclats
les 12M c'est la hauteur du phare !
un site est très bien fait pour les éclats
https://detienne.net/phares/divers_codes.php



:wink: