Programme sur Arduino

Bonjour ,
j'ai acheté une carte Arduino Uno afin de réaliser des animations sur mon réseau

J'ai réalisé un petit programme pour simuler des feux routiers ( pour le moment j'utilise que 3 leds verte jaune et rouge ) et un autre programme pour simuler un flash radar (1 led bleue)

Ma question est comment faire pour avoir ces 2 programmes dans le même fichier (  téléverser ce fichier dans la carte Arduino  ) indépendant l'un de l'autre .

En fait , j'ai crée 2 boucles l'une à la suite de l'autre. la première boucle est l'animation des feux routiers, la seconde est pour le flash

Cordialement

Philippe 31

Bonjour Philippe

La réponse est : il faut faire un seul programme qui gère en même temps ton feu routier et ton radar. Copie colle ton code ici et je t'explique comment réunir les deux.

Ci dessous le code  :


// feux routier et flash
int led = 6;//  la led rouge est sur la patte 6
int led1 = 5;// la led jaune est sur la patte 5
int led2 = 3;// la led verte est sur la patte 3
int Led4 =9;// la Led bleue est sur la sortie 9
int i=0;
int lum [8]={0,0,255,0,0,0};


void setup()
{                
 // programmation des 4 Leds en sortie
 pinMode(led, OUTPUT);
 pinMode (led1, OUTPUT);
 pinMode (led2, OUTPUT);
  pinMode(Led4,OUTPUT);
}

void loop()
{
 // feux routiers
 digitalWrite(led, LOW);  
 digitalWrite(led1,LOW);
 digitalWrite(led2,HIGH);
      delay(5000);  // Led verte allumée durant 5 secondes            
 digitalWrite(led, LOW);
 digitalWrite(led1,HIGH);  
 digitalWrite(led2,LOW);
     delay(1000);   // Led jaune allumée durant 1 seconde
 digitalWrite(led, HIGH),
 digitalWrite(led1,LOW);
 digitalWrite(led2, LOW);
    delay(1500); // Led rouge allumée durant 1,5 seconde

;// Flash routier
for (i=0;i<6;i=i+1)
   {;
   analogWrite(Led4,lum[i]);
   delay(10);
    };
 delay ( 500);
}

Ton problème va être au niveau des appels à 'Delay'. Ce sont des commandes bloquantes, alors pendant le Delay(5000), soit 5 secondes, ton Flash routier ne marchera pas !
Pour contourner le problème, il faut mettre une variable globale donnant le temps de départ, et n'accomplir les actions que lorsque le delta entre le temps de départ et le temps courant atteint le seuil de 5000, par exemple.

Donc pour faire les deux choses (feu routier et flash) en même temps, il ne faut pas utiliser delay() partout qui bloque l'exécution du programme. Il faut que le temps puisse s'écouler.

Je vois dans ton programme que le plus petit delay que tu utilises est de 10ms. On va donc faire un loop() qui s'exécute toutes les 10ms :

Citation :

void loop()
{
  delay(10);
}

On va commencer par mettre la gestion du feu routier. Au lieu d'utiliser des delay, on va utiliser un compteur et des états permettant de savoir où on en est. Pour le feu routier, on va avoir les états VERT , ROUGE et JAUNE que l'on va mémoriser dans une variable et un compteur permettant de compter le temps entre deux changement d'état du feu :

Citation :

enum { VERT, ROUGE, JAUNE };

// au début le feu est VERT
byte etatFeu = VERT;
// au début compteurFeu est à 500 x 10ms = 5s pour le feu vert
int compteurFeu = 500;

Donc dans loop(), on regarde si compteurFeu est à 0. Si oui il faut changer l'état du feu et remettre le compteur à la valeur de durée du nouvel état. Si non, on décrémente compteurFeu.

Citation :

void loop()
{
  if (compteurFeu == 0) {
    // changement d'état du feu
    if (etatFeu == VERT) {
      etatFeu = JAUNE;
      compteurFeu = 100;
      // allumage du feu jaune
      digitalWrite(led, LOW),
      digitalWrite(led1,HIGH);
      digitalWrite(led2, LOW);
    }
    else if (etatFeu == JAUNE) {
      etatFeu = ROUGE;
      compteurFeu = 150;
      // allumage du feu rouge
      digitalWrite(led, HIGH);
      digitalWrite(led1,LOW);  
      digitalWrite(led2,LOW);
    }
    else if (etatFeu = ROUGE) {
      etatFeu = VERT;
      compteurFeu = 500;
      // allumage du feu vert
      digitalWrite(led, LOW);  
      digitalWrite(led1,LOW);
      digitalWrite(led2,HIGH);
    }
  }
  else {
    compteurFeu--;
  }
  
  delay(10);
}

Ajoutons maintenant le flash. C'est le même principe. On remplace le delay(500) par un compteur : compteurInterFlash qui est initialisé à 50 (50 x 10ms = 500ms) :

Citation :

// compteur entre les flash
// Intialisé à 50 x 10ms = 500ms
int compteurInterFlash = 50;

On va garder i pour compteur les analogWrite séparés par les delay(10). Donc on regarde si compteurInterFlash est égal à 0. Si oui on fait un analogWrite comme dans ton programme, on incrémente i. Si i vaut 6 on le met à 0 et on remet compteurInterFlash à 50. Si non on décrémente compteurInterFlash :

Citation :

enum { VERT, ROUGE, JAUNE };

// au début le feu est VERT
byte etatFeu = VERT;
// au début compteurFeu est à 500 x 10ms = 5s pour le feu vert
int compteurFeu = 500;

// compteur entre les flash
// Intialisé à 50 x 10ms = 500ms
int compteurInterFlash = 50;

int led  = 6;//  la led rouge est sur la patte 6
int led1 = 5;// la led jaune est sur la patte 5
int led2 = 3;// la led verte est sur la patte 3
int Led4 = 9;// la Led bleue est sur la sortie 9
int i = 0;
int lum [8] = {0, 0, 255, 0, 0, 0};

void setup()
{                
  // programmation des 4 Leds en sortie
  pinMode(led, OUTPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(Led4, OUTPUT);

  // A début le feu est vert
  digitalWrite(led, LOW);  
  digitalWrite(led1, LOW);
  digitalWrite(led2, HIGH);
}

void loop()
{
  if (compteurFeu == 0) {
    // changement d'état du feu
    if (etatFeu == VERT) {
      etatFeu = JAUNE;
      compteurFeu = 100;
      // allumage du feu jaune
      digitalWrite(led, LOW),
      digitalWrite(led1, HIGH);
      digitalWrite(led2, LOW);
    }
    else if (etatFeu == JAUNE) {
      etatFeu = ROUGE;
      compteurFeu = 150;
      // allumage du feu rouge
      digitalWrite(led, HIGH);
      digitalWrite(led1, LOW);  
      digitalWrite(led2, LOW);
    }
    else if (etatFeu = ROUGE) {
      etatFeu = VERT;
      compteurFeu = 500;
      // allumage du feu vert
      digitalWrite(led, LOW);  
      digitalWrite(led1, LOW);
      digitalWrite(led2, HIGH);
    }
  }
  else {
    compteurFeu--;
  }
  
  if (compteurInterFlash == 0) {
    analogWrite(Led4,lum[i]);
    i++;
    if (i == 6) {
      i = 0;
      compteurInterFlash = 50;
    }    
  }
  else {
    compteurInterFlash--;
  }
  
  delay(10);
}

Note que c'est extensible. Si tu veux gérer une autre séquence d'allumage pour une autre animation, il suffit de l'ajouter dans loop() en utilisant la même façon de faire.

Bonjour Jlb
Merci pour ta réponse pédagogique .
Je viens de télécharger ton programme,super . Je vais essayer de comprendre afin d'augmenter la tempo du flash  ( toutes les 10 secondes par exemple) .
Dans le même ordre d' idée , je vais essayé d'y rajouter une autre séquence ( 4 leds qui simuleront un feu de cheminée ( idem TAMS LC-5 que j'ai acheté chez cheftrainminiature )
Si j'ai des soucis , je me permettrai de te relancer
A nouveau merci
Bien cordialement
Philippe 31

Il n'y a pas de quoi Philippe

N'hésite pas à demander

Bonjour,

Quand on a besoin de réaliser beaucoup de tâches dans un programme Arduino et quand il faut garder des réactions rapides aux événements, on en arrive vite à la nécessité de ne JAMAIS utiliser l'instruction "delay()". 

Personnellement, j'utilise la méthode suivante pour gérer plusieurs tâches simultanément avec des périodicités différentes :

Par exemple, pour une tâche qui doit se dérouler toutes les secondes :

Dans la déclaration des variables globales :

Code:

unsigned long time1S;          // INTERNAL TIME FOR 1 SECOND TEMPO

Dans la procédure "setup()"

Code:

  time1S = millis();              // départ timer seconde

time1S est initialisé avec la valeur courante du compteur de temps système d'Arduino qui est augmentée de 1 automatiquement toutes les millisecondes.


Dans la boucle "loop()"

Code:

  // TACHES toutes les secondes
  
  if ((time1S+1000) < millis())  {
    time1S = time1S+1000;
    SR_second();
  }

SR_second() est une procédure qui réalise la tâche à exécuter toutes les secondes.
Par exemple, dans mon cas, je veux transmettre des données de debug à la console toutes les secondes seulement pour ne pas saturer la "loop()".
Dans mon contrôleur de circuit, j'utilise aussi cette technique pour rafraichir les commandes d'aiguillages toutes les 30 secondes : si des petits doigts innocents changent le sens d'une aiguille par inadvertance, celle-ci revient à sa position initiale automatiquement.


Bien-entendu, on peut inclure plusieurs mécanismes de ce genre, avec des tempo différentes en multipliant les variables, les bouts d'initialisation dans setup() et les appels de tâches dans loop().

On peut ainsi, pour s'amuser, réaliser une horloge avec 3 tempos : time1S pour les secondes, time1M pour les minutes et time1H pour les heures.
Pour les secondes, on aura if ((time1S+1000) < millis())
Pour les minutes, on aura if ((time1M+60000) < millis())
Pour les minutes, on aura if ((time1H+3600000) < millis())

D'où l'intérêt d'utiliser une variable "unsigned long" !

On peut réduire la charge dans la boucle loop() en imbriquant les tâches : la tâche "minute" dans la tâche "seconde" et la tâche "heure" dans la tâche "minute"

Ainsi le test des minutes se fera dans la routine SR_second() et le test des heures se fera dans la routine SR_minute().

On peut ainsi multiplier les exemples...

Dans le cas de la gestion de tes feux tricolores, tu peux utiliser cette technique en mettant tout le code qui change l'état des feux dans une routine déclenchée par une tempo de ce genre.

Bonjour à tous,

J'utilise la même technique de Jlb, avec ce délai centralisé dans la boucle principale, on compte par multiples de 10 ms. Il faut cependant faire attention à ce que le temps d'exécution des instructions de la boucle soit très petit par rapport aux 10 ms. Si ce n'est pas le cas, il vaut la peine d'utiliser un timer du micro-contrôleur et attendre la fin de la période de 10 ms. Voir mon blog pour plus d'explications.

La technique de SixtyFive est intéressante, elle garantit que les instructions sont exécutées au plus tôt après time1S+1000 ms. C'est une sorte d'attente active non bloquante!
Je définirais des constantes pour les durées afin de rendre le programme plus clair.

Merci pour ces échanges, bonne soirée.

Messieurs ,
Merci de vos réponses .
Je viens d'être démasqué pour mon incompétence en programmation
Pour le moment , je digère vos informations
je reviendrai vers vous dans peu de temps, car mon but final est d'avoir sur la même carte :
un feu routier soit 6 leds
un flash ( radar routier) soit 1 led
et un feu de cheminée  soit 5 leds

Une proposition : on pourrait créer un sujet " Arduino" dans lequel on y échangerait et y présenterait nos logiciels afin de les copier( en complément des articles de LR)

Exemple du feu de cheminée avec 3 Leds
int Led1 = 6;
int Led2 = 5;
int Led3 = 9;
long number = 0;
long t=0;

void setup()
{
 pinMode ( Led1,OUTPUT );
 pinMode ( Led2,OUTPUT );
 pinMode ( Led3,OUTPUT );
}
void loop ()
{
 number= random (150);
 analogWrite (Led1,number);
 t = random(20);
 delay (t) ;
 number= random (256);
 analogWrite (Led2,number);
 t = random(20);
 delay (t);
 number=random (100);
 analogWrite (Led3,number);
 t = random(20);
 delay (t);
}

Cordialement
Philippe 31

Mon nouveau problème est le transfert vers un Attiny 84 .
Dans la procédure que j'ai trouvé sur un autre forum , elle indique :
Compilation : Sélectionnez votre ATtiny en allant dans Outils>Type de carte>ATtiny XX[/b]
Or quand je vais sur Outils>Type de carte , je ne trouve pas Attiny etc....;
J'ai la version logiciel 1.5.5
Qu'ai je oublié dans ma manip ?

Salutations
Philippe 31

J'ai regardé, et je n'ai pas vu ATtiny non plus. Après une petite recherche (toute petite, c'est le premier résultat de ma requête 'attiny' sur le site arduino.cc, la référence) j'ai trouvé un tuto pour le rendre disponible.

Hello, tu trouveras ci-dessous un résumé des opérations à réaliser pour compiler les programmes pour la famille des ATtiny. J'ai réalisé un breadboard à enficher sur la carte Arduino Uno. A+

Précision : j'ai réalisé deux modules (Circuit de 3 cms x 2 cms) avec simulation poste de soudure à l'arc avec son et feu de cheminé, utilisant un ATtiny45.

Arduino, voila un sujet intéressant.

Je m'inscris pour la suite.

Merci à jlb, SixtyFive, SavignyExpress, ... pour les explications et pour leurs réalisations.  

En marge de cette discussion, un truc bien utile que j'utilise souvent est de connaître la durée de la fonction LOOP !

Pour cela j'utilise 2 variables globales

Code:

unsigned long looptime;
int loopduration;  

Que j'initialise dans SETUP

Code:

 looptime = micros();

Et je calcule la durée de LOOP ainsi:

Code:

 loopduration = micros() - looptime;
looptime = micros();

Il ne reste plus qu'à l'afficher !
Mais attention : le fait de l'afficher (Serial.print ou LCD.print) fausse gravement la mesure (l'affichage prend beaucoup de temps). Personnellement, je l'affiche dans une tâche périodique, toutes les secondes par exemple. Ainsi le temps affiché est bon si la tâche périodique est appellée après la mesure !!

Il faut éviter d'afficher la durée de la LOOP qui fait l'affichage !

Dans un programme que je fais en ce moment, la durée de LOOP est d'une demi-milliseconde (500 micro secondes) environ et pourtant j'ai pas loin de 20K  de code !
Il s'agit d'une centrale DCC avec un automate d'animation pour un itinéraire automatique.
Bon courage !

merci à class66 pour l'infos ,

j'avais déjà réalisé cette manip ( vu sur un autre forum ), j'ai recommencé ce matin.
Malheureusement je ne vois pas quelle erreur je fais car je ne vois pas apparaître dans outil/type de carte : attiny 84
Je continu mes recherches mais suis ouvert à toutes nouvelles idées

Cordialement
Philippe 31

Bonjour,

Quel fichier "zip" as-tu utilisé ?
Quels dossiers obtiens-tu quand tu "dézippes" ?

J'ai un Arduino Uno Rev3 et le sw 1.0.5.
Le dossier dézippé est "attiny". Il contient un dossier "variants" et un fichier "boards.txt" qui définit les paramètres de l'ATtiny...

Quand tu fais l'installation du dossier attiny dans le dossier hardware, il faut que le programme arduino.exe soit arrêté... Si tu ne vois pas apparaitre les infos sur les ATtiny (qui complètent les infos existantes Arduino), es-tu sur d'avoir mis le dossier au "bon endroit" ????

A+

Bonjour ,
je dézippe le fichier
Télécharger le dossier pour les programmer ici :
https://github.com/damellis/attiny/archive/master.zip

Voila ce que cela donne dans mon répertoire

Désolé , j'ai cliqué sur "envoyer" trop vite
Arborescence:
/hardware/Arduino
             /tools
             /attiny /variants  /tiny 8
                                    /tiny14
dans le sous répertoire tiny8 , un fichier pins-arduino.h de 3 K
dans le sous répertoire tiny14 , un fichier pins-arduino.h de 4 K
je suis la procédure de ton fichier , mais je ne vois pas les cartes attiny
Je ne comprend pas
merci de ton aide
Cordialement
Philippe 31

philippe 31 a écrit:

Arborescence:
/hardware/Arduino
             /tools
             /attiny /variants  /tiny 8
                                    /tiny14
dans le sous répertoire tiny8 , un fichier pins-arduino.h de 3 K
dans le sous répertoire tiny14 , un fichier pins-arduino.h de 4 K

Bonsoir,
Ton arborescence est correcte...
Quand tu ouvres le dossier attiny, tu dois avoir :
  variants (dossier)
  boards.txt fichier de définition type de cartes
je joins l'arborescence ...


A+

Si ça ne fonctionne pas, tu peux utiliser le fichier : arduino-tiny-0100-0018.zip (dernière version pour l'Arduino 1.0.5, que j'utilise maintenant. Il faut lire le readme, car le dossier tiny doit contenir le fichier Boards.txt que tu crées et dans lequel tu  copie les définitions d'attinyxx qui intéressent contenues dans le  fichier Prospective Boards.txt contenu dans le dossier tiny. C'est celui que j'utilise actuellement.

Merci
Je regarde cela de plus pres ce weekend
Salutations
Philippe 31

Je viens, ENFIN, de transférer sur un ATtiny 84 un programme de flash radar routier .
Merci à class 66 pour son aide précieuse .
Entre le livre de Ch Tavernier (applications avancées ) et tes explications sur l'autre forum , j'ai pu réaliser ce transfert
Cette Arduino et surtout les Attiny vont nous permettre à moindre coût de réaliser de superbes animations sur nos réseaux
Cordialement
Philippe 31

philippe 31 a écrit:

Je viens, ENFIN,  de transférer sur un ATtiny 84 un programme de flash radar routier

Bonjour,
Bravo, c'est toujours plus simple "après" !!!!
Serait-il possible que tu publies le source ? (à moins qu'il n'y ait un copyright !!!), je n'ai pas cherché de montage et ca pourrait servir de base à un montage de flash pour photographe... qui existe tout fait avec 3 personnages (HO) qui mitraille toutes les dix secondes (Ah ces paparazzi !!!). Bon, je   

Bon week-end à tous...

Le source n'est pas de moi.
Je l'ai copié sur le forum sur lequel tu interviens
Cordialement
Philippe 31

Bonjour Philippe,
Merci pour cette précision.  
Bonne journée à tous.