Forums LR PRESSE

Où il est question de trains, petits et grands

  • Advertisement

Salle de TP d'Arduino

Toutes les discussions sur l'Arduino !

Modérateur: MOD

Re: Salle de TP d'Arduino

Publié: Dim 28 Fév 2016, 14:55 
Je sais que ce n'est pas l'objet, mais on pourrait utiliser à nouveau la même fonction que j'avais écrite pour la gare à 2 voies :`

Code: Tout sélectionner
// appel
GererFeux(Feu_4, Feu_1);


void GererFeux(int LedH, int LedL) {
  digitalWrite(LedH, HIGH);
  digitalWrite(LedL, LOW);
}


D'où l'interêt des fonctions que l'on peut réutiliser sans avoir besoin de les ré-ecrire
RGP49
alanya
Papotier
 
Messages: 175
Inscrit le: Jeu 14 Août 2008, 13:33
Localisation: Saumur
Âge: 61
Echelle pratiquée: N et 0e
Prénom: Yves
Club: RGP49

Re: Salle de TP d'Arduino

Publié: Dim 28 Fév 2016, 19:09 
Absolument ! D'ailleurs, en écrivant plein de fonctions comme étant des mini-programmes, on se prépare des sortes de briques de construction qu'on peut réutiliser un jour.

Un peu comme l'électronique câblée où on peut avoir des schémas pour des fonctions bien précises qu'on assemble pour réaliser quelque chose de plus élaboré.
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Lun 29 Fév 2016, 10:31 
Rappel de l’exercice N° 2

La même chose mais avec des signaux à trois feux (vert-rouge-jaune).

Image


Cette fois, il faut commander chaque feu indépendamment pour chaque signal, ce qui représente donc 12 sorties (4 x 3). Les ILS représentent 4 entrées comme pour l’exercice précédent. Nous avons donc besoin au total de 16 E/S sur le module Uno et il faut donc utiliser les entrées analogiques A0 à A3 comme des entrées numériques numérotées 14 à 17.

Pour que les programmes soient interchangeables, il est intéressant de construire la même maquette. Voici ce qui a été décidé concernant les E/S du module Uno :

Image


Les signaux sont constitués de trois DEL montées en cathodes communes ; chaque DEL est donc commandée par un signal HIGH sur la sortie. Il n’y a qu’une seule DEL allumée à la fois ; on peut mettre la résistance de limitation du courant sur le fil commun aux cathodes permettant le retour du courant comme le montre la figure TP7.

Image


La figure TP8 montre la maquette à construire. Les fils reliant les ILS sont en violet, les fils reliant les DEL sont de la couleur de celle-ci. La masse (GND) est en bleue.

Image
Figure TP8


Une fois cette maquette réalisée, vous n'avez plus qu'à écrire le programme qui la fera fonctionner en vous inspirant du programme précédent (pour signaux à deux feux). Demain, je vous proposerai ma solution, mais j'attends aussi la votre... :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Lun 29 Fév 2016, 21:35 
C'est vrai qu'une sortie commune pour un feu au lieu de 1 pour chaque LED, c'est plus pratique :p
Du coup je vais remettre a jour mon schéma!
Avatar de l’utilisateur
tgvdu88
Papotier
 
Messages: 178
Inscrit le: Sam 25 Oct 2008, 17:45

Re: Salle de TP d'Arduino

Publié: Mar 01 Mars 2016, 00:54 
Au début, ce qui compte c'est d'obtenir un schéma qui fonctionne avec un programme qui fonctionne et tu y es arrivé.

Avec l'habitude, on optimise les composants et aussi les lignes de code.

Et mon rôle, c'est de vous faire profiter de ces petites astuces que mon expérience a appris à connaitre à force de pratiquer des schémas et des programmes. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mar 01 Mars 2016, 01:08 
Minuit, l'heure du cours ! :lol: Bon, comme je serai occupé demain matin, je vous donne la suite du TP dès maintenant (après tout, nous sommes demain...)

Le programme

La surveillance des boutons poussoirs ou des ILS est identique au programme de l’exercice N°1. Lorsque le B/P ou ILS du canton N est déclenché, il faut mettre au rouge le signal du canton N, et à l’orange celui du canton N – 1, les autres feux étant au vert. Ceci ne présente pas de difficulté à condition de penser à éteindre les autres feux du signal qui ont été allumés précédemment.

Code: Tout sélectionner
/*  CANTON AVEC SIGNAL TROIS FEUX
*   
*  Ce programme gere des signaux a trois feux sur un canton
*  commencant par un ILS. A l initialisation, les feux sont
*  tous au vert. Des que la locomotive arrive sur le canton 1
*  elle fait demarrer le cycle et les feux se positionnent
*  en fonction de l'avancee de la locomotive.
*  Les signaux sont constitues de 3 DEL allumees par un signal
*  HIGH (feux à cathodes communes).
*/

const byte ILS_1 = 14; // ILS_1 sur entree 14 (A0)
const byte ILS_2 = 15; // ILS_2 sur entree 15 (A1)
const byte ILS_3 = 16; // ILS_3 sur entree 16 (A2)
const byte ILS_4 = 17; // ILS_4 sur entree 17 (A3)
const byte LED_V1 = 2; // Feu vert de canton 1 sur entree 2
const byte LED_R1 = 3; // Feu rouge de canton 1 sur entree 3
const byte LED_O1 = 4; // Feu jaune de canton 1 sur entree 4
const byte LED_V2 = 5; // Feu vert de canton 2 sur entree 5
const byte LED_R2 = 6; // Feu rouge de canton 2 sur entree 6
const byte LED_O2 = 7; // Feu jaune de canton 2 sur entree 7
const byte LED_V3 = 8; // Feu vert de canton 3 sur entree 8
const byte LED_R3 = 9; // Feu rouge de canton 3 sur entree 9
const byte LED_O3 = 10; // Feu jaune de canton 3 sur entree 10
const byte LED_V4 = 11; // Feu vert de canton 4 sur entree 11
const byte LED_R4 = 12; // Feu rouge de canton 4 sur entree 12
const byte LED_O4 = 13; // Feu jaune de canton 4 sur entree 13

void setup() {
// Entrees
pinMode (ILS_1, INPUT_PULLUP);
pinMode (ILS_2, INPUT_PULLUP);
pinMode (ILS_3, INPUT_PULLUP);
pinMode (ILS_4, INPUT_PULLUP);
// Sorties
pinMode (LED_V1, OUTPUT);
pinMode (LED_R1, OUTPUT);
pinMode (LED_O1, OUTPUT);
pinMode (LED_V2, OUTPUT);
pinMode (LED_R2, OUTPUT);
pinMode (LED_O2, OUTPUT);
pinMode (LED_V3, OUTPUT);
pinMode (LED_R3, OUTPUT);
pinMode (LED_O3, OUTPUT);
pinMode (LED_V4, OUTPUT);
pinMode (LED_R4, OUTPUT);
pinMode (LED_O4, OUTPUT);
// Tous les feux au vert
digitalWrite (LED_V1, HIGH);
digitalWrite (LED_V2, HIGH);
digitalWrite (LED_V3, HIGH);
digitalWrite (LED_V4, HIGH);
}

void loop() {
// Lorsque train arrive sur canton, signal du canton au rouge,
// et signal du canton precedent a l orange,
// autres signaux au vert.

while (digitalRead(ILS_1) == HIGH){
  // Ne rien faire
}
// ILS_1 declenche
// train sur canton 1
digitalWrite (LED_V1, LOW);
digitalWrite (LED_R1, HIGH);
digitalWrite (LED_O1, LOW);
digitalWrite (LED_V4, LOW);
digitalWrite (LED_R4, LOW);
digitalWrite (LED_O4, HIGH);
digitalWrite (LED_V3, HIGH);
digitalWrite (LED_R3, LOW);
digitalWrite (LED_O3, LOW);
digitalWrite (LED_V2, HIGH);
digitalWrite (LED_R2, LOW);
digitalWrite (LED_O2, LOW);

while (digitalRead(ILS_2) == HIGH){
  // Ne rien faire
}
// ILS_2 declenche
// train sur canton 2
digitalWrite (LED_V2, LOW);
digitalWrite (LED_R2, HIGH);
digitalWrite (LED_O2, LOW);
digitalWrite (LED_V1, LOW);
digitalWrite (LED_R1, LOW);
digitalWrite (LED_O1, HIGH);
digitalWrite (LED_V4, HIGH);
digitalWrite (LED_R4, LOW);
digitalWrite (LED_O4, LOW);
digitalWrite (LED_V3, HIGH);
digitalWrite (LED_R3, LOW);
digitalWrite (LED_O3, LOW);

while (digitalRead(ILS_3) == HIGH){
  // Ne rien faire
}
// ILS_3 declenche
// train sur canton 3
digitalWrite (LED_V3, LOW);
digitalWrite (LED_R3, HIGH);
digitalWrite (LED_O3, LOW);
digitalWrite (LED_V2, LOW);
digitalWrite (LED_R2, LOW);
digitalWrite (LED_O2, HIGH);
digitalWrite (LED_V1, HIGH);
digitalWrite (LED_R1, LOW);
digitalWrite (LED_O1, LOW);
digitalWrite (LED_V4, HIGH);
digitalWrite (LED_R4, LOW);
digitalWrite (LED_O4, LOW);

while (digitalRead(ILS_4) == HIGH){
  // Ne rien faire
}
// ILS_4 déclenche
// train sur canton 4
digitalWrite (LED_V4, LOW);
digitalWrite (LED_R4, HIGH);
digitalWrite (LED_O4, LOW);
digitalWrite (LED_V3, LOW);
digitalWrite (LED_R3, LOW);
digitalWrite (LED_O3, HIGH);
digitalWrite (LED_V2, HIGH);
digitalWrite (LED_R2, LOW);
digitalWrite (LED_O2, LOW);
digitalWrite (LED_V1, HIGH);
digitalWrite (LED_R1, LOW);
digitalWrite (LED_O1, LOW);

// Recommencer le cycle de surveillance
}



Si vous avez bien respecter les E/S à utiliser pour votre maquette, vous devez pouvoir utiliser ce programme en l'important dans votre IDE et constater qu'il fonctionne. Demain, je vous donnerai une autre version de ce programme qui sera réécrit en utilisant des tableaux, une bonne occasion pour faire un peu de cours. Mais ça se passera ici, en salle de TP. :moi:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mar 01 Mars 2016, 19:20 
Voici une petite vidéo du fonctionnement de la maquette pour signaux à trois feux :
https://vimeo.com/157300463
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 10:30 
Aujourd'hui, nous allons reprendre un peu de cours en étudiant les tableaux et en prenant comme exemple le programme des cantons à 3 feux. Pour la continuité du sujet, ce morceau de cours a donc lieu ici. :geek:

Programme utilisant des tableaux

L’intérêt du programme précédent est qu’il se lit assez bien, mais cette longue énumération d’actions à faire n’est pas très élégante. Pour raccourcir la longueur du programme source, nous allons faire appel à des tableaux pour attribuer les broches d’entrées-sorties. Cela nous donnera l’occasion de parler des tableaux dans le langage d’Arduino.

Un tableau (array) est une suite de données indexée, regroupée sous un même nom et dont chaque élément est repéré par son index. Prenons un exemple : les ILS sont reliés aux broches 14 à 17, soit A0 à A3. Pour attribuer les broches à nos ILS, nous n’avons besoin que d’un seul index, donc nous utiliserons un tableau à une dimension, l’index allant de 0 à 3 (on commence toujours par 0 et il faudra vous y habituer :roll: ).

Nous allons donc déclarer ce tableau comme cela :

const byte ILS[4] ;

Même si l’index ne va que jusqu’à 3, on a besoin de 4 valeurs puisqu’il y a 4 ILS, de plus l’index allant de 0 à 3 implique bien 4 valeurs.

On peut aussi déclarer le tableau et l’initialiser en même temps comme cela :

const byte ILS[] = {14, 15, 16, 17} ;

Dans ce cas, il n’est pas nécessaire de préciser le nombre de « cases » de notre tableau, le compilateur se débrouillera tout seul puisqu’il a les différentes valeurs.

Attention, les ILS ne sont plus numérotés de 1 à 4, mais de 0 à 3. L’ILS du premier canton est relié à la broche 14 qui vaut ILS[0]. La seule difficulté pour utiliser un tableau, c’est de comprendre que les indices commencent toujours par 0. Le quatrième ILS (celui du canton N°4) est ILS[3] et non ILS[4] et si vous écrivez ILS[4], le programme ira chercher une donnée en mémoire qui ne correspondra à rien, ce qui occasionnera un mauvais fonctionnement de votre programme. Attention donc à ce point.

Pour attribuer les broches des DEL (ou LED en anglais), nous aurons besoin d’un tableau de 3 lignes et de 4 colonnes, comme en témoigne le tableau ci-dessous (voir les cases jaunes) :

Image


Nous avons donc besoin cette fois d’un tableau à deux dimensions, mais le principe est absolument le même. Le premier index est celui de la ligne (de 0 à 2), le deuxième index est celui de la colonne (de 0 à 3). On voit dans le tableau ci-dessus que la première ligne (celle d’index égal à 0) représente les LED vertes, la deuxième ligne les rouges et la troisième ligne les oranges.

Il ne reste plus qu’à attribuer les broches de ces différentes LED :

const byte LED[3][4] = {{2, 5, 8, 11},{3, 6, 9, 12},{4, 7, 10, 13}};

La première série de données entre accolades représente les LED vertes (ligne 0), la deuxième les rouges (ligne 1) et la troisième les oranges (ligne 2). La LED verte du premier canton est repérée par l’index de ligne 0 et l’index de colonne 0, et ici la valeur du tableau est 2.

Dans le programme, au lieu d’écrire :

digitalWrite (LED_V1, HIGH) ;

on écrira :

digitalWrite (LED[0][0] ; HIGH) ;

L’avantage d’utiliser des tableaux est qu’on peut les initialiser en utilisant des boucles for et en faisant varier l’index de la boucle. Pour un tableau à deux dimensions, on utilise deux boucles imbriquées l’une dans l’autre, la première pour faire varier l’index de ligne, la deuxième pour faire varier l’index de colonne. Ceci raccourcit considérablement la longueur du programme source comme en témoigne le programme suivant construit sur le principe d’utilisation de tableaux.

/*  CANTON AVEC SIGNAL TROIS FEUX
 *   
 *  Ce programme utilise des tableaux à 1 ou 2 dimensions
 *  
 *  Ce programme gere des signaux a trois feux sur un canton
 *  commencant par un ILS. A l initialisation, les feux sont 
 *  tous au vert. Des que la locomotive arrive sur le canton 1
 *  elle fait demarrer le cycle et les feux se positionnent
 *  en fonction de l'avancee de la locomotive.
 *  Les signaux sont constitues de 3 DEL allumees par un signal 
 *  HIGH (feux à cathodes communes).
 */
 
const byte ILS[] = {14, 15, 16, 17};
// ILS_0 sur entree 14 (A0)
// ILS_1 sur entree 15 (A1)
// ILS_2 sur entree 16 (A2)
// ILS_3 sur entree 17 (A3)
const byte LED[3][4] = {{2, 5, 8, 11},{3, 6, 9, 12},{4, 7, 10, 13}};
// Tableau 3 lignes, 4 colonnes pour repérer les broches de sortie. 
// Ligne 0 : LED vertes, ligne 1 : LED rouges, ligne 2 : LED oranges
int n = 0; // canton N
int nm1 = 3; // canton N moins 1
int nm2 = 2; // canton N moins 2
int nm3 = 1; // canton N moins 3

void setup() {
  // Entrees
  for (int i = 0; i < 4; i++) {
    pinMode (ILS[i], INPUT_PULLUP);
  }
  // Sorties
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
      pinMode (LED[i][j], OUTPUT);
    }
  }
  // Tous les feux au vert
  for (int i = 0; i < 4; i++) {
    digitalWrite (LED[0][i], HIGH);
  }
}

void loop() {
// Lorsque train arrive sur canton, signal du canton au rouge,
// et signal du canton precedent a l orange,
// autres signaux au vert.

while (digitalRead(ILS[n]) == HIGH){
  // Ne rien faire
}
// ILS_N declenche
// train sur canton N, signal au rouge sur N
digitalWrite (LED[0][n], LOW);
digitalWrite (LED[1][n], HIGH);
digitalWrite (LED[2][n], LOW);
// signal a l orange sur N - 1
digitalWrite (LED[0][nm1], LOW);
digitalWrite (LED[1][nm1], LOW);
digitalWrite (LED[2][nm1], HIGH);
// signal au vert sur N - 2 et N - 3
digitalWrite (LED[0][nm2], HIGH);
digitalWrite (LED[1][nm2], LOW);
digitalWrite (LED[2][nm2], LOW);
digitalWrite (LED[0][nm3], HIGH);
digitalWrite (LED[1][nm3], LOW);
digitalWrite (LED[2][nm3], LOW);

// Prochain canton
n = n + 1;
if (n == 4) {n = 0;}
nm1 =nm1 + 1;
if (nm1 == 4) {nm1 = 0;}
nm2 = nm2 + 1;
if (nm2 == 4) {nm2 = 0;}
nm3 = nm3 + 1;
if (nm3 == 4) {nm3 = 0;}

// Recommencer le cycle de surveillance
}



Ce programme nécessite 1488 octets en mémoire alors que le programme initial en nécessitait 1506 ; la deuxième solution est plus élégante, comporte moins de lignes de programme mais n’apporte pas un gain conséquent en place mémoire de programme.

Le numéro de canton en cours de surveillance est repéré par la variable n qui est initialisée à 0 et qui augmente d’une unité à la fin de la boucle loop pour passer à la surveillance du canton suivant. Il est important que ce numéro de canton aille de 0 à 3 (et non de 1 à 4) puisqu’on l’utilise comme index dans nos tableaux. C’est pourquoi il est impératif de s’habituer à compter à partir de zéro en informatique.

A retenir :
- Un tableau (array) est une suite de données indexée, regroupée sous un même nom et dont chaque élément est repéré par son index
- L’index commence toujours par 0 et va jusqu’à une valeur égale au nombre d’éléments du tableau moins 1
- L’index d’un tableau est mis entre crochets [ ] et non entre parenthèses
- La première valeur d’un tableau est TAB[0] et non TAB[1)
- Un tableau peut avoir deux dimensions et se présente alors sous la forme d’une matrice ayant un certain nombre de lignes et un certain nombre de colonnes, comme un tableau de traitement de texte
- Il faut donc deux index pour se repérer dans un tableau à deux dimensions, le premier est l’index de ligne, le deuxième est l’index de colonne
- Index de ligne et index de colonne commencent également à 0
- La première valeur d’un tableau à deux dimensions est TAB[0][0] et non TAB[1][1]
- Il faut déclarer le type de variables contenues dans le tableau (int, byte, float, char, etc.)
- Les différentes valeurs du tableau doivent toutes avoir le même type
- L’avantage des tableaux est qu’on peut utiliser des boucles pour manipuler les différentes valeurs du tableau
- La véritable difficulté d’utilisation des tableaux est de se rappeler que les index doivent toujours être dans un certain intervalle commençant par 0. C’est pourquoi il est impératif en informatique de s’habituer à compter à partir de zéro.

Voici maintenant le programme pour le télécharger et l'essayer sur votre maquette : :wink:

Code: Tout sélectionner
/*  CANTON AVEC SIGNAL TROIS FEUX
*   
*  Ce programme utilise des tableaux à 1 ou 2 dimensions

*  Ce programme gere des signaux a trois feux sur un canton
*  commencant par un ILS. A l initialisation, les feux sont
*  tous au vert. Des que la locomotive arrive sur le canton 1
*  elle fait demarrer le cycle et les feux se positionnent
*  en fonction de l'avancee de la locomotive.
*  Les signaux sont constitues de 3 DEL allumees par un signal
*  HIGH (feux à cathodes communes).
*/

const byte ILS[] = {14, 15, 16, 17};
// ILS_0 sur entree 14 (A0)
// ILS_1 sur entree 15 (A1)
// ILS_2 sur entree 16 (A2)
// ILS_3 sur entree 17 (A3)
const byte LED[3][4] = {{2, 5, 8, 11},{3, 6, 9, 12},{4, 7, 10, 13}};
// Tableau 3 lignes, 4 colonnes pour repérer les broches de sortie.
// Ligne 0 : LED vertes, ligne 1 : LED rouges, ligne 2 : LED oranges
int n = 0;  // canton N
int nm1 = 3; // canton N moins 1
int nm2 = 2; // canton N moins 2
int nm3 = 1; // canton N moins 3

void setup() {
  // Entrees
  for (int i = 0; i < 4; i++) {
    pinMode (ILS[i], INPUT_PULLUP);
  }
  // Sorties
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
      pinMode (LED[i][j], OUTPUT);
    }
  }
  // Tous les feux au vert
  for (int i = 0; i < 4; i++) {
    digitalWrite (LED[0][i], HIGH);
  }
}

void loop() {
// Lorsque train arrive sur canton, signal du canton au rouge,
// et signal du canton precedent a l orange,
// autres signaux au vert.

while (digitalRead(ILS[n]) == HIGH){
  // Ne rien faire
}
// ILS_N declenche
// train sur canton N, signal au rouge sur N
digitalWrite (LED[0][n], LOW);
digitalWrite (LED[1][n], HIGH);
digitalWrite (LED[2][n], LOW);
// signal a l orange sur N - 1
digitalWrite (LED[0][nm1], LOW);
digitalWrite (LED[1][nm1], LOW);
digitalWrite (LED[2][nm1], HIGH);
// signal au vert sur N - 2 et N - 3
digitalWrite (LED[0][nm2], HIGH);
digitalWrite (LED[1][nm2], LOW);
digitalWrite (LED[2][nm2], LOW);
digitalWrite (LED[0][nm3], HIGH);
digitalWrite (LED[1][nm3], LOW);
digitalWrite (LED[2][nm3], LOW);

// Prochain canton
n = n + 1;
if (n == 4) {n = 0;}
nm1 =nm1 + 1;
if (nm1 == 4) {nm1 = 0;}
nm2 = nm2 + 1;
if (nm2 == 4) {nm2 = 0;}
nm3 = nm3 + 1;
if (nm3 == 4) {nm3 = 0;}

// Recommencer le cycle de surveillance
}
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 10:52 
Pour terminer l'exercice des cantons à trois feux, je vous invite à réfléchir aux points faibles de ce programme et aux améliorations qu'on peut lui apporter afin d'obtenir un vrai B.A.L (Block Automatique Lumineux) type SNCF permettant à deux trains de se suivre sans se rattraper. :ugeek: :?: :?: :roll: :idea: :D

J'attends donc vos remarques... :siffle:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 20:18 
On pourrait ajouter la coupure de voie un peu comme dans l'exercice de la gare a 2 voies.
Pour le feu rouge : arret
Feu orange: on doit pouvoir reussi a faire ralentir le train?

L'arret ne devrait pas poser de probleme mais le ralentissement hmm hmm
Avatar de l’utilisateur
tgvdu88
Papotier
 
Messages: 178
Inscrit le: Sam 25 Oct 2008, 17:45

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 20:47 
C'est une excellente idée, mais avant cela, j'aimerais que tu trouves quel est le défaut principal de ce que nous avons développé (car il y en a un énorme ! :lol: )
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 21:04 
On ne peut pas mettre plusieurs trains? ^^
Avatar de l’utilisateur
tgvdu88
Papotier
 
Messages: 178
Inscrit le: Sam 25 Oct 2008, 17:45

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 21:14 
C'est bien là le principal problème.
Donc, pour donner une suite à cet exercice, j'aimerais que nous nous mettions à travailler sur un véritable B.A.L que je pourrai monter sur mon locodrome dans le but d'y mettre deux trains.
Cet exercice a déjà été évoqué dans le forum Arduino mais son auteur n'a jamais terminé, ce qui est bien dommage car c'était un des forums les plus consultés. Mais c'est un problème complexe si on cherche à le rendre fonctionnel toutes conditions (pousse, UM, voie dans les deux sens, etc.)
Donc, je propose de partir d'un cas simple : un circuit à une voie parcourue dans un seul sens, quatre cantons qui cette fois ne seront plus fictifs. Et deux petits trains qui se suivent à la queue leu leu... :lol:

On compliquera par la suite :siffle:

Quelqu'un pour me suivre sur ce coup là ? :moi:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Salle de TP d'Arduino

Publié: Mer 02 Mars 2016, 21:17 
Yep moi je suis sur le cas là. :D tout en continuant sur mon Pn :mdr:
Avatar de l’utilisateur
tgvdu88
Papotier
 
Messages: 178
Inscrit le: Sam 25 Oct 2008, 17:45

Re: Salle de TP d'Arduino

Publié: Jeu 03 Mars 2016, 20:34 
J'espère qu'il y en aura d'autres pour nous rejoindre.

Voilà comment je vois les choses :
- créer pour chaque canton une zone de pleine voie et une zone d'arrêt (c'est déjà fait sur mon locodrome)
- remplacer les ILS par un détecteur d'occupation pour le canton (éventuellement carte de détection du commerce)
- voir quel type de module est nécessaire (Uno, Mega, Nano)
- éventuellement, un module par canton (à base de Nano ou Mini ou même un autre µC comme l'ATtiny)
- introduire la PWM pour faire ralentir et démarrer progressivement les trains

Rien d'insurmontable :lol:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

PrécédentSuivant

Retour vers Arduino

Qui est en ligne ?

Utilisateur(s) parcourant actuellement ce forum : Aucun utilisateur inscrit et 1 invité