Bonjour à tous

[deneb2119]

Salut,

j'ai refait le shémas avec un peu plus de précision

[deneb2119]

avec des photos jointes

[deneb2119]

les modules se trouvent en desous de la plaque et les leds IR de part et d'autres de la voie ( les amoires fabriquées avec une imprimante 3D) à la sortie du module, une masse permanente qui est coupée part le pâssage du train .....

[patrick]

As-tu essayé de mesurer les valeurs qui sortent du détecteur en branchant la sortie sur un input analogique de l'Arduino? Juste par curiosité...

Peut-être qu'une pullup pourrait aider à supprimer les fluctuations?

En général, lorsque j'ai des problèmes de ce genre, c'est à cause d'une masse non reliée aux autres... Mais là, on dirait un problème généralisé d'alimentation...

[bobyAndCo]

Bonsoir Guy,

Je ne comprends pas bien ton montage puisque sur la photo de l'IR que tu présentes l'émetteur et le récepteur sont sur la même carte alors que ta photo des voies semble indiquer qu'émetteur et récepteur sont face à face. Quoi qu'il en soit et dans la mesure où la solution semble bien difficile à trouver, je t'invite, si émetteur et récepteurs sont séparées bien sûr, à alimenter l'émetteur en 1,1 ou 1,2 Volt (pas plus). Le récepteur restant lui en 5 Volts.

D'après les symptômes que tu décris, je ne suis pas certain que ça t'apporte la solution mais cela peut être une astuce pour ceux qui veulent mettre de l'IR sur leur réseau et qui rencontrent des problèmes de détection. Sur mon réseau, avec des capteurs éloignées de 13 à 15 cm, ça fonctionne au poil avec utilisation de la bibliothèque "IRremote".

Bien à toi

[deneb2119]

Bonsoir Boby..

oui effectivement je dessoude les leds IR du module pour les utilisées en barriere de part et d'autre de la voie

[Dominique]

En tout cas je suis désolé de constater qu'il y a des parasites dans l'orthographe 

J'aimerais que les fautes soient corrigées svp. Je viens de corriger ta présentation initiale, et si le bouton "corriger" est toujours visible, je te laisse faire le reste. Ensuite j'enlèverai ce commentaire.

J'avoue surtout que je ne comprends plus où est le problème. Qu'est-ce qui ne marche pas ? Est-ce le programme qui se plante, les capteurs qui ne sont pas captés, ... ?
Faire un schéma après coup, c'est peu courant. À quel endroit du montage les parasites ont été observés ?
Comment réagit le programme aux parasites: as-tu mis des serial.Print(..) partout où un test serait utile ?
Il faut prendre le temps d'expliquer en se mettant à la place du lecteur, autant que possible.

On reset cette discussion et on repart du bon pied 

Merci.

[bobyAndCo]

Merci Dominique.

Bretons et alsaciens pratiquants peu la langue française, il nous arrive parfois de faire des écarts. Plus sérieusement, je pense également qu’il faudrait sans doute reprendre tout cela depuis le départ.

Tout d’abord, sur un banc test, hors le plus possible de toute interférence. Puis se rapprocher petit à petit des conditions réelles d’utilisation pour  identifier la cause des problèmes.

Je ne suis pas persuadé que de dessouder émetteur et/ou récepteur soit très judicieux. Pourquoi ne pas utiliser les produits qui correspondent exactement à l’utilisation que tu souhaites en faire ? Encore une fois, je ne peux parler que de ce que je connais et ce que je te suggère est une solution que j’ai adoptée et qui fonctionne.

En image ci-dessous les capteurs que j'utilise.

L’ensemble fonctionne à une fréquence de 38KHz qui est généré sur l’Arduino par la bibliothèque IRremote. Je précise une nouvelle fois que je n’ai obtenu des résultats satisfaisants qu’une fois que j’ai alimenté la LED émettrice en 1,1 – 1,2 Volts. Sinon, sur des distances aussi faibles, la réception manquait de sensibilité.

A toutes fins utiles, je te donne également mon code pour l’Arduino qui tourne sur Mega mais l'adaptation à un autre Arduino est simple. Les lectures sont envoyées par Ethernet. Il y a bien sûr un debonce entre chaque lecture mais aussi un délai entre chaque envoi de message (10 secondes). On peut en effet considérer que deux lectures valides à moins de 10 secondes d’intervalle concernent le même train.

Ce n’est pas la seule solution possible. Dominique à déjà présenté ici un montage qui fonctionne bien également http://www.locoduino.org/spip.php?article40

Voilà, y a plus qu’à !!!

Code: [Sélectionner]

// barriere_IR_5

#include <IRremote.h>
#include <SPI.h>
#include <Ethernet.h>

#define PIN_IR            9 // l'émetteur IR sur la pin 9 pour Mega (3 pour Uno)
#define NB_CAPTEURS       4 // 4 capteurs sont utilisés ici
#define START_PIN         22 // La première pin pour les récepteurs
#define ADDRESS_MAC       0x90, 0xA2, 0xDA, 0x0D, 0xAA, 0xF2
#define IP_CLIENT         10, 0, 1, 219
#define IP_SERVER         10, 0, 1, 15


int tab_inPin[NB_CAPTEURS];
int tab_capteurState[NB_CAPTEURS];
int tab_lastCapteurState[NB_CAPTEURS];
int tab_reading[NB_CAPTEURS];
unsigned long tab_lastDebounceTime[NB_CAPTEURS];
unsigned long tab_lastSendMsgTime[NB_CAPTEURS];
const long debounceDelay = 5; // Laps de temps entre deux mesures
const long sendMsgDelay = 10000; // Delai entre l'envoi de message pour un même capteur

///////////////////////// IMPORTANT /////////////////////////////////////////

//  Distance émetteur/récepteur testée à 10 et à 15 cm.
//  1,1 V  pour alimenter les diodes émettrices, Si plus, le dispositif manque de sensibilité.
//  5 V pour alimenter les diodes réceptrices.

///////////////////// CREATION DE L'OBJET irsend ////////////////////////////

IRsend irsend;

/////// ETHERNET ////////////////

byte mac[] = { ADDRESS_MAC };
IPAddress ip(IP_CLIENT);
EthernetClient client;
IPAddress serveur(IP_SERVER);

String methode = "IR_capteurs"; // Méthode appelée sur le serveur


//////////////////////////// SETUP ////////////////////////////////////////////

void setup() {

  pinMode(PIN_IR, OUTPUT);

  ////// CAPTEURS IR  //////////////
  for (int numCapteur = 0; numCapteur < NB_CAPTEURS; numCapteur++) {
    tab_inPin[numCapteur] = START_PIN + numCapteur;
    pinMode(tab_inPin[numCapteur], INPUT);
    tab_capteurState[numCapteur] = HIGH;
    tab_lastCapteurState[numCapteur] = LOW;
    tab_lastDebounceTime[numCapteur] = 0;
    tab_lastSendMsgTime[numCapteur] = 0;
  }
  irsend.enableIROut(38); // créer une sortie modulée à 38 Khz


  /////// SERIAL ////////////////
  Serial.begin(19200);
  Serial.println("Init...");
  delay(1000);
  Serial.println("Pret !");

  /////// ETHERNET ////////////////
  Ethernet.begin(mac, ip);
  Serial.print("server IP : ");
  Serial.println(Ethernet.localIP());

}

//////////////////////////// LOOP ////////////////////////////////////////////

void loop() {
  for (int numCapteur = 0; numCapteur < NB_CAPTEURS; numCapteur++) {
    irsend.mark(0); // envoi signal modulé de façon continue
    delay(1);
    lireCapteur(numCapteur);
    irsend.space(0); // arret signal modulé
  }
}

//////////////////////////// FONCTION lireCapteur ////////////////////////////////////////////

void lireCapteur (int numCapteur) {
  tab_reading[numCapteur] = digitalRead(tab_inPin[numCapteur]);
  if (tab_reading[numCapteur] != tab_lastCapteurState[numCapteur]) {
    tab_lastDebounceTime[numCapteur] = millis();
  }

  if ((millis() - tab_lastDebounceTime[numCapteur]) > debounceDelay) {
    if (tab_reading[numCapteur] != tab_capteurState[numCapteur]) {
      tab_capteurState[numCapteur] = tab_reading[numCapteur];
      if (tab_capteurState[numCapteur] == LOW) {
        if ((millis() - tab_lastSendMsgTime[numCapteur]) > sendMsgDelay) {
          tab_lastSendMsgTime[numCapteur] = millis();
          requete(numCapteur);
        }
      }
    }
  }
  tab_lastCapteurState[numCapteur] = tab_reading[numCapteur];
}

//////// REQUETE /////////////////////////////////////////////////////

void requete(int numCapteur) {
  char erreur = client.connect(serveur, 80);
  if (erreur == 1) {
    String data = "";
    data += "IR="; data += numCapteur + 1;
    Serial.println(data);
    client.print("GET /4DACTION/");
    client.print(methode);
    client.print("/?");
    client.print(data);
    client.print(" HTTP/1.1\r\n");
    client.print("Accept: text/html\r\n");
    client.print("Content-type: application/x-www-form-urlencoded; charset=UTF-8\r\n");
    client.print("Host: ");
    client.print(ip);
    client.print("\r\n");
    client.print("Content-Length: ");
    client.println(data.length());
    client.print("User-Agent: arduino-ethernet\r\n");
    client.print("Connection: close\r\n");
    client.println();
    client.stop();
    Serial.println(data);
  }

  else {
    client.stop();
    Serial.println("Echec de la connexion");
    //    switch (erreur) {
    //      case (-1):
    //        Serial.println("Time out");
    //        break;
    //      case (-2):
    //        Serial.println("Serveur invalide");
    //        break;
    //      case (-3):
    //        Serial.println("Tronque");
    //        break;
    //      case (-4):
    //        Serial.println("Reponse invalide");
    //        break;
    //    }
  }
}


[msport]

oui effectivement je dessoude les leds IR du module pour les utilisées en barriere de part et d'autre de la voie

sauf erreur, ces modules fonctionnent par réflexion infra rouge, leur utilisation en barrière peut expliquer les problèmes.
voir le descriptif :
http://www.ebay.fr/itm/IR-Infrared-Obstacle-Vermeidung-Sensor-Module-3-wire-fur-Arduino-Smart-Car-/231387396461?hash=item35dfc3796d:g:BQgAAOSwRLZUGAA0
Noter aussi que les fluo compactes génèrent pas mal d'infra rouges.

[PhB22]

Bonsoir,
J'utilise le principe de détection par IR pour un va et vient sur voie unique.
Il faut absolument placer les phototransistors IR hors de toute source lumineuse de quelque nature que se soit.
Deux photos pour montrer comment je les ai protégés

[bobyAndCo]

Bonjour,
Je trouve plutôt sympathique la façon dont tu as résolu le problème. J’aimerais que tu me dises si tu utilises ou non une modulation de fréquence (comme je l’ai fait par exemple avec IRremote) ?

Je te pose cette question pour car j’ai moi aussi prévu de placer ces composants peu esthétiques dans des tunnels par exemple. Mais les tunnels ne sont toujours pas construits, les capteurs reçoivent un max de lumière et ne sont absolument pas perturbés. Bien évidemment, je pense que la modulation de fréquence y est pour quelque chose mais j’aimerais avoir des retours d’autres utilisateurs.

Merci pour ta réponse.
Christophe

[deneb2119]

bonjour.

Pour répondre à Msport... au départ j'avais installé les IR en réflexion et par la suite j'ai changé pour les mettre en barriere, ce qui n'a rien changé aux problemes ... d'ailleurs avant les IR, j'avais des ILS et bien sûr idem.......

[Dominique]

Dans mon réseau précédant, j'avais des barrières IR gérées par un Mega, lequel était relié au gestionnaire par une liaison I2C.

Les barrières IR sont décrites sur Locoduino, sans modulation. Les récepteurs étaient reliés à des entrées analogiques de l'Arduino pour faciliter les réglages d'alignement (c'est très sensible).

Je n'ai jamais eu de problème de parasites, ni de lumière parasite même en expo avec des projecteurs lumineux.

Quel est donc le problème ?

[deneb2119]

eh bien toujours le meme......  au bout de quelques secondes un ou deux cantons passent au rouge  ( alors qu'il n'y a eu aucun train )
et un peu plus tard (30s environ) l'ardiuno se bloque ......je doit lui faire un reset pour redemarrer

[Dominique]

Bon,
 
On a passé en revue les alimentations et les capteurs infra-rouges. Un petit oscillo est même en commande. Et toujours aucun résultat 

On ne sait pas quels remèdes tu as éventuellement appliqués, quels tests tu as faits pour y voir plus clair.

Donc maintenant il faut rechercher autrement qu'en déclarant qu'il y a un problème.

Je te suggère d'ajouter dans ton programme des lignes supplémentaires contenant Serial.println("1"); avec "1" puis "2", "3", .. etc qui correspondent à des cas particuliers que tu pourras tracer de cette façon sur le terminal de l'IDE Arduino. Les messages "1", "2", etc.. peuvent être plus explicites comme "IR1", "IR2", ..

Par exemple Serial.println("1"); à chaque détection IR dans la gare qui pose problème. Serial.println("2"); pour la détection IR dans la gare qui ne pose pas de problème. Serial.println("3"); juste avant ou après une commande d'aiguille ou de relai de traction.

Comme le programme se plante d'après ce que tu nous écris, tu verras le programme se dérouler sur l'écran du terminal au fur et à mesure des affichages, jusqu'au moment où ça s'arrête. Cela te donnera un piste pour explorer ce qui se passe juste avant.

Tu verras aussi probablement les effets des parasites (électriques cette fois !), par exemple plusieurs fois de suite le même messages "1" signifierait des rebonds à éliminer.

Si les Serial.println() que tu auras ajouté ne t'éclairent pas suffisamment, il faudra en ajouter d'autres.

C'est laborieux, mais ça marche très souvent.

Un plantage du programme me fait penser aussi à un manque de mémoire : quelle est la taille de mémoire disponible, affichée dans la fenêtre de l'IDE après une vérification ? En cas de doute la mémoire disponible pendant que le programme tourne peut être affichée à l'aide d'une routine comme :

Code: [Sélectionner]

int freeRam () { int v; // calcul de la memoire libre
  extern int __heap_start, *__brkval;   
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

Maintenant tu connais le principe et nous espérons te lire prochainement avec une belle explication des causes et des remèdes (que j'espère au singulier) qui pourraient servir la communauté Locoduino, bien entendu.

Bonne chance