Capteur fourche pour actionner un électroaimant

bonjour la communauté
je suis tout nouveau et j'ai un projet sur lequel je ne trouve pas d'information; bien que je soit certain qu'il est déjà était traité.
je ne possède pas le vocabulaire pour pouvoir faire cette recherche et j'ai beau tourner des pages et des pages, je ne trouve pas chaussure a mon pied; alors si une âme charitable pouvais m'aider dans ma recherche , elle serai la bienvenu.
j'expose mon projet:
en utilisant 2 capteurs fourche, je voudrais actionner un électroaimant.
c'est a dire le premier capteur envoie un signal pour alimenter l'électroaimant, et le deuxième capteur envoie un signal pour stopper l'alimentation de l'électroaimant.
c'est surement très simple pour la grande majorité d'entre vous et je suis sure que quelqu'un a déjà fais un montage et une programmation comme celle la . mais un novice comme moi a besoin d'aide et d'explication
merci d'avance pour vos réponse

déplacé dans le bon forum (on parle anglais dans les autres)

merci jackson
et désolé de l'erreur

Salut, je ne comprends pas ce qu'est un capteur de fourche, pourriez-vous mettre une photo ou un lien?
Les salutations

hello
@gonpezzi
il doit s'agir de ce genre de capteur

bon
soir gonpezzi
une capteur fourche c'est ca;

dfgh, c'est exactement ca

Salut:
Considérations:

  • Ce type de capteur est conçu pour être utilisé pendant des interruptions, pour l'utiliser d'une autre manière ou cela compliquerait le code ou il ne serait sûrement pas détecté correctement, alors je vais les utiliser.
  • Le code est conçu pour utiliser un module relais similaire à celui-ci: RELAY avec un autre type entraînerait éventuellement des modifications du matériel ou du code.

Connectez les trois positifs (celui des deux capteurs et celui du relais), à la broche 5V de l'arduino. Les trois points négatifs de l'arduino GND. La broche de signal du relais à la broche 5. La broche de sortie du capteur qui allume le relais à la broche 2 de l'arduino et enfin la broche de sortie du capteur qui désactive la broche 3 de l'arduino.
Et ici vous avez le code:

// Il contrôlera le relais est booléen car il ne contient que deux valeurs HIGH = relais on LOW = off
// être volatile car il sera utilisé avec des interruptions. 
volatile bool capteur = LOW;

// Broche de relais par exemple 5 
int relais = 5;

void setup() {
  // Nous initialisons la broche du relais comme sortie et désactivée 

  pinMode(relais , OUTPUT);
  digitalWrite(relais , LOW);

  // On configure les broches d'interruption pour que
  // détecte un changement de bas en haut des deux capteurs 
  attachInterrupt(digitalPinToInterrupt(2), Allumez_relais , RISING);
  attachInterrupt(digitalPinToInterrupt(3), Eteignez_relais , RISING);

}

void loop() {
  // active ou désactive le relais 
  digitalWrite(relais , capteur);
}

/// Routine d'interruption qui sera exécutée lors de la mise sous tension du capteur 1
// Si le relais est allumé il ne fait rien s'il est éteint il l'active 
void Allumez_relais() {
  if (capteur = LOW) {capteur = !capteur;}
}

// Routine d'interruption qui sera exécutée lorsque j'allume le capteur 2
// Si le relais est éteint, il ne fait rien, s'il est activé, il l'éteint 
void Eteignez_relais() {
  if (capteur = HIGH) {capteur = !capteur;}
}

Je pense que j'en ai beaucoup commenté, si vous ne comprenez pas quelque chose, demandez-moi.
Salutations.

Pas du tout d'accord, J'en ai utilisé, mais jamais encore sous interruption. Mais cela va venir.
Pour l'utiliser comme un interrupteur marche arrêt, il n'y a aucun intérêt à utiliser les interruptions.
Par contre si il s'agit de mesurer le temps d'une rotation de moteur, cela peut se justifier.


Les capteurs à fourche que j'ai ont deux broches pour la led et deux pour le phototransistor. Il faut donc une résistance de pullup externe au photocoupleur. On peut en mettre une. On peut aussi prendre celle qui est interne à la pin si on y met un

pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP);

Éteindre un relais qui est éteint ne fait rien de plus, ce n'est pas utile de le vérifier. Du coup on peut faire (en passant par les interruptions):

void loop() {}  // n'a rien à faire, tout se fait par interruptions

/// Routine d'interruption qui sera exécutée lors de la mise sous tension du capteur 1
void Allumez_relais() {
  digitalWrite(relais , HIGH);
}

// Routine d'interruption qui sera exécutée lorsque j'allume le capteur 2
void Eteignez_relais() {
  digitalWrite(relais , LOW);
}

Attention, dans le code

void Allumez_relais() {
  if (capteur = LOW) {!capteur;}
}

l'instruction
!capteur;
doit calculer le contraire de capteur, puis doit le ranger nulle part. Comme le compilateur est intelligent, il ignorera cette instruction.
Il faudrait mettre capteur=HIGH
Si on est certain que la valeur numérique de HIGH est 1 et 0 pour LOW on pourrait utiliser à la rigueur capteur=!capteur


Sinon sans passer par les interruptions, on peut faire (non testé, à vérifier):

 // Broche de relais par exemple 5 
const uint8_t relais = 5;

void setup() {
  // Nous initialisons la broche du relais comme sortie et désactivée 

  pinMode(relais , OUTPUT);
  digitalWrite(relais , LOW);

  // On configure les broches 2 et 3 avec la résistance
  pinMode (2, INPUT_PULLUP); 
  pinMode (3, INPUT_PULLUP); 
}

void loop() {
  while (digitalRead(2) == HIGH); // on attend l'ordre d'allumer le relais
  digitalWrite(relais , HIGH);
  while (digitalRead(3) == HIGH); // on attend l'ordre d'éteindre le relais
  digitalWrite(relais , LOW);
}

Je suis tout à fait d'accord, à quoi penserais-je ...?
Je corrige le code.

D'accord mais il a ce module:
Broches de connexion du module de vitesse (codeur FC-03):
VCC: alimentation du module 3.3V à 12V.
GND: Terre.
D0: Signal digital des impulsions de sortie.
A0: Signal analogique des impulsions de sortie. Signal de sortie en temps réel. (pas normalement utilisé).

Je le fais sur l'ISR pour éviter de rebondir sur la rampe montante.

Et quant à votre code, eh bien ça marche, mais je ne sais pas pour quels cas il le fera bien ou mal, en cela je ne sais pas. c'est pourquoi j'insiste sur l'utilisation des interruptions, c'est un capteur un peu délicat à utiliser. lisez cet article pour mieux le connaître.
link
Les salutations

Non. Cela ne fait rien non plus. Récapitulatif Je prends quelques suggestions de @vileroi et refaire le code.

// Broche de relais par exemple 5 
int relais = 5;

void setup() {
  // Nous initialisons la broche du relais comme sortie et désactivée 
  pinMode(relais , OUTPUT);
  digitalWrite(relais , LOW);
  // On configure les broches d'interruption pour que
  // détecte un changement de bas en haut des deux capteurs 
  attachInterrupt(digitalPinToInterrupt(2), Allumez_relais , CHANGE);
  attachInterrupt(digitalPinToInterrupt(3), Eteignez_relais , CHANGE);
}

void loop() {
 // mettez ici tout ce que vous voulez faire sans vous soucier du relais 
}

/// Routine d'interruption qui sera exécutée lors de la mise sous tension du capteur 1
// Si le relais est allumé il ne fait rien s'il est éteint il l'active 
void Allumez_relais() {
  digitalWrite(relais , HIGH);
}

// Routine d'interruption qui sera exécutée lorsque j'allume le capteur 2
// Si le relais est éteint, il ne fait rien, s'il est activé, il l'éteint 
void Eteignez_relais() {
  digitalWrite(relais , LOW);
}

Les salutations

Où avais-je la tête? Effectivement avec le module , les états hauts et bas sont définis, les pinMode (x, INPUT_PULLUP); sont parfaitement inutiles.

Si il y a des problèmes de rebonds, que ce soit sous ISR ou pas, cela ne changerait rien. Dans le cas de noter ami @alfagtv916, il peut y avoir autant de rebonds que l'on veut, cela n'a strictement aucune importance. Que l'on donne l'ordre une fois ou 10 fois, si on dit de s'arrêter, il s'arrêtera sur le premier ordre. Ce n'est pas du tout comme l'article link qui veulent compter le nombre d'impulsions. Les rebonds leurs font compter 4 fois plus d'impulsions que ce qu'il y en a.
Mais dans leur article, il y a quand même un gros problème si on voit leur chronogramme:
https://1.bp.blogspot.com/-0iVRkfzqTNQ/V5ki0PCmwZI/AAAAAAAABjc/aGE1nM57EMItEQWUPOrhNdUOmSUsrP-LQCKgB/s320/70-Arduino_debounce.jpg
Leur "rebond" est parfaitement périodique, ce qui montre que ce n'est pas du rebond, mais un signal parasité par une autre source. Ils auraient du soigner leur alimentation et séparer la puissance (courants forts) de la commande (courants faibles).


Je n'aime pas trop ce CHANGE, car l'information importante est quand le capteur est actif qu'il faut faire quelque chose, pas quand il est "relâché". Il vaut mieux mettre un RISING. Cela correspond d'ailleurs à // détecte un changement de bas en haut des deux capteurs

Je ne saîds pas si c’est vrai ou non, cela dépendait de la vitesse à laquelle ce que nous voulons détecter. Je pense sur ce point que nous avons deux codes parfaitement valables mais avec des critères de programmation différents et qu’il faut plus d’informations sur le projet pour suivre une ligne ou une autre.
Mon pote @alfagtv916 pourriez-vous nous donner plus de détails ?.
Salutations.

déjà merci a vous pour vos réponse qui me donne quelques directive et piste même si pour le moment je ne comprend pas tout. il faut que je relise tout à tète reposé, pas quand je rentre du taf...
mon projet est une piste de slot avec multiple aiguillage, gérer par des capteurs pour définir des zones d'anticollision, des zone de dépassement et des zones drapeau bleu (laissez passer la voiture plus rapide)
un schéma valant mieux qu'un grand discourt je vous joint une capture d'ecran du projet et quelques photos

sur cette photo on voit que si l'aiguille reste ainsi la voiture orange va percuter la voiture rouge, il faut donc animer l'aiguille pour éviter la collision


et c'est la même chose pour la voiture jaune et verte

je vous retranscris ce que j'ai préparé mais que je ne sais pas traduire en langage Arduino
(best line, la meilleur trajectoire, est la trajectoire par defaut, quand on roule seul ou quand les concourants sont loin derriere.)

best line aiguille 1
1 seul voiture
capteur 3 change la polarité de l'aiguille A1.1

anticolision aiguille 1
2 voitures cote a cote

capteur 1 ferme l'aiguille 1
capteur 2 ouvre l'aiguille 1
capteur 1 change la polarité de l'aiguille A1.1

best line aiguille 2
1 seul voiture
capteur 9 change la polarité de l'aiguille A2.2

anticolision aiguille 2
2 voitures cote a cote

capteur 5 ferme l'aiguille 2
capteur 6 ouvre l'aiguille 2
capteur 5 change la polarité de l'aiguille A2.2

best line aiguille 3
1 seul voiture
capteur 11 change la polarité de l'aiguille A3.3

anticolision aiguille 3
2 voitures cote a cote

capteur 7 ferme l'aiguille 3
capteur 8 ouvre l'aiguille 3
capteur 7 change la polarité de l'aiguille A2.2

Le choix de la solution dépend en grande partie du projet. Dans le projet présent, il y a non pas un seul électroaimant, mais plusieurs. Il faut donc réfléchir à la solution qui est la meilleure pour l'ensemble du projet, qui n'est pas forcément la même que si il n'y avait qu'un seul aiguillage en tout.

Sur un aiguillage, comment fonctionne-t-il? D'après ce que je comprends, à voir si c'est bien cela, les aiguillages ont une position de repos qui donne la direction prioritaire à prendre lorsque l’électroaimant est non alimenté, cela doit alors représenter la plupart du temps. De temps en temps pour éviter une collision on alimente un électroaimant.
image
L'aiguillage est en position verte par défaut, le capteur 1 alimente l'aiguillage comme dessiné en pointillé, le capteur 2 le remet à sa place.

Si c'est bien cela, on garanti que l'aiguille ne reste alimentée que quand c'est nécessaire

Merci de confirmer. Ou est-ce plus compliqué

Parce que dedans je vois 3 capteurs 1, 2 et 3 :thinking:


Comment comptes-tu faire la gestion de plusieurs aiguillages?

  • pour chaque aiguillage une carte, deux capteurs, un relais?
  • par paquets de quelques aiguillages, une carte, 2N capteurs, N relais

  • éventuellement carte uno pour faire les essais, carte nano pour la réalisation finale?
  • carte méga pour plus d'entrées?

Pour un seul aiguillage si il y a deux capteur, c'est un simple problème combinatoire, il suffit d'une bascule RS (un circuit 4013 en contient 2), ce qui pourrait faire pour 2 aiguillages une 4013, quatre capteurs, deux relais.
Souvent, je conseille la nano pour une réalisation finale, mais ici une solution combinatoire est intéressante (pas sûr que ce soit mieux pour le câblage).
J'adore les interruptions, mais curieusement ici je ne les défend pas.

En effet, ce n'est pas un projet d'utiliser des interruptions.

bonjour vileroi et merci de ton aide.
alors pour commencer il y a sur ma piste 12 aiguilles mobile et 12 aiguilles fixe a gérer chaque aiguille mobile est Indépendante des autres aiguille mobile mais chaque aiguille mobile est en relation avec l'aiguille fixe qui la suit. Chaque aiguille est animer par 4 a a 6 capteurs
exemple sur l'aiguille 1 qui a besoin de 5 capteurs

il y a 2 zone de détection chaque zone a un capteur d'entré et un capteur de sortie
première zone entre C1 et C2 (zone anticollision)
deuxième zone entre C100 et C101 ( zone de dépassement)
le 5e capteur et le C3 qui change la polarité de l'aiguille fixe A1.1
attention le capteur C3 est aussi un capteur d'entrée de zone pour l'aiguille 2
come tu l'as deviné l'aiguille a une position de repos, qui donne la trajectoire idéale, et une position active qui change la direction des voitures. donc oui animation seulement quand cela est nécessaire

pour la gestion des aiguillages je voudrais les faire par lot
1er lot aiguilles 1,2 et 3
2eme lot aiguilles 4 et 5
3 eme lot aiguilles 6 et 7
4eme lot aiguilles 8,9,10,11 et 12
chaque lot correspond a des aiguillages très proche et a la suite les un des autres
mais je ne sais pas si c'est possible.
je ne sais pas non plus si un même capteur peut envoyer un signal qui aboutira a 2 fonctions exemple du capteur C3
et dans tout ca il faut aussi prendre en compte les sorties de piste, c'est pourquoi je me demande si il faut pas dans la programmation prévoir un "si"
exemple
capteur 1 ferme l'aiguille 1
capteur 2 ouvre l'aiguille 1
si capteur 2 n'a rien détecté après X temps, ouverture de l'aiguille 1
voila j'espère avoir répondu a tes questions
et merci encore de ton aide précieuse

Au vu de tout cela, c'est un problème que je qualifierai de simple pour la programmation. A partir du moment on on peut exprimer le problème sous forme non ambigu, on a déjà fait les trois quart du problème. Notes:

  • un même capteur peut servir à autant d'aiguilles que l'on veut, y compris si on met 4 cartes différentes, pas d'inquétudes
  • pour la plupart des capteurs, c'est le front montant qui nous intéresse, ce qui aurait été simple avec les interruptions, mais dans ce cas c'est trop compliqué de les utiliser et cela ne donne rien de plus.
  • si une aiguille est activer, on peut l'activer une deuxième fois cela ne change strictement rien. Pareil si on désactive une aiguille déjà désactivée.
  • la conséquence du point précédent est que l'on peut remplacer "quand un capteur vient de détecte un véhicule" par "tant que le véhicule est sur le capteur. Cela fait calculer plus d'ordres, mais je pense que cela passe.

Je vois le programme ainsi:
setup définit les pins utilisées, surtout pour les sorties.
loop peut ressembler à:

void loop() {

  // ****** best line aiguille 1 *********
  //1 seule voiture: capteur 3 change la polarité de l'aiguille A1.1
  if (digitalRead(capteur3) == LOW) digitalWrite(aiguilleA1_1, HIGH);

  // ****** dépassement aiguille 1 ******
  // capteur 100 a détecté...
  if (digitalRead(capteur100) == LOW) tempsCapteur100 = millis(); // départ du chronomètre pour attendre que la première soit passée pour dire qu'il y en a une autre
  if (digitalRead(capteur101) == LOW) tempsCapteur2 = 0xFFFFFFFF;  // fin mémorisation
  il (digitalRead(capteur100) == LOW && millis() - tempsCapteur2 > temps) digitalWrite(aiguilleA1, HIGH); // si le capteur est encore activé avant temps, c'est encore la même voiture, on ne fait rien, sinon c'est une deuxième voiture
...
}

se traduit par

  if (digitalRead(capteur2) == LOW) tempsCapteur2 = millis(); // départ du chronomètre
  if (digitalRead(capteur2) == HIGH) tempsCapteur2 = 0xFFFFFFFF; // arrêt du chronomètre
  if (millis() - tempsCapteur2 > tempsX) {
     digitalWrite(aiguilleA1, LOW); // ouverture de l`aiguille au bout d'un temps X
     tempsCapteur2 = 0xFFFFFFFF; // arrêt du chronomètre
  }

Il faut que le temps total de loop dure moins que le temps de passage d'une voiture sur le capteur.

Pour un seul capteur à fourche, un capteur tel que celui montré est parfait. Pour 12 aiguilles avec 4 à 6 capteurs, cela va faire dans les 50 capteurs. à ce tarif, il vaut peut être prendre des capteurs nus:
image
qui sont surtout plus facile à placer. Possibilité d'alimenter les leds de plusieurs capteurs en série. Pour chaque récepteur, il y a deux fil, un va à la masse, l'autre sur une entrée avec pullup. Si le temps de passage sur un capteur est trop court, possibilité de mettre en parallèle un condensateur qui va rallonger le temps.

Cher @ alfagtv916 FENCE LIO. Quel âge a cette piste? Dans les années 70, ils m'en ont donné un et il était déjà en plastique.
Mais commençons par le début et nous ajouterons de petites choses si possible. En principe, je pense qu'analyser le problème en s'en tenant à un seul secteur, (deuxième circuit), serait plus compliqué que si on commençait par donner une solution au circuit total et on ajouterait des choses. Je commence donc par essayer de résoudre en premier lieu toute la courbe en général, (premier circuit) et ensuite ajouter des solutions spécifiques pour les situations et les sections. Pour cela, j'ai fait les hypothèses suivantes:

  • toutes les aiguilles sont éteintes dans cette situation chaque voiture circulera sur sa piste soit à l'intérieur soit à l'extérieur,
  • S'ils arrivent ensemble ---> chacun pour sa propre piste soit à l'intérieur soit à l'extérieur
  • Si l'intérieur arrive 1 seconde avant, (pour mettre un temps à tester), ses aiguilles sont placées pour sa manœuvre et l'autre continue à l'extérieur.
  • Si l'intérieur arrive plus tôt, le même que dans le cas précédent.

Comme vous pouvez le voir dans le code que je vous attache, je n'ai pas utilisé tous les capteurs, cela dépend de vous de poser de nouvelles situations pour les utiliser ou non. Un détail dans la section qui va entre les aiguilles A2 et A2.2 il y a un conflit entre les contrôles. vous devriez le réparer si vous ne l'avez pas déjà fait.

void loop() {
  // Supposons que pour qu'il n'y ait pas
  // suivre le changement et les voitures continuent
  // ses aiguilles de course extérieures ou intérieures
  // ils sont inactifs et leur statut est LOW 

 //***********************************+****
  // La voiture de piste intérieure passe en premier
  // On attend 1sec pour voir si l'autre arrive
  // Si c'est le cas, la variable carEX sera mise à 1
  // pour voir plus tard ce que nous faisons 

 if (digitalRead (C1) == LOW) {
   sensorc1 = 1;
   anmillis = millis();
   tiempo = 0;
   while (tiempo < 1000) {
     tiempo = millis() - anmillis;
     if (digitalRead (C100 == 0)) {
       cocheEX = 1;
     }
   }
 }
 //***********************************+****
  // La voiture sur la piste extérieure passe la première
  // On attend 1sec pour voir si l'autre arrive
  // Si c'est le cas, la variable car1 sera mise à 1
  // pour voir plus tard ce que nous faisons 
 if (digitalRead (C100) == LOW) {
   sensorc100 = 1;
   anmillis = millis();
   tiempo = 0;
   while (tiempo < 1000) {
     tiempo = millis() - anmillis;
     if (digitalRead (C1 == LOW)) {
       cocheIN = 1;
     }
   }
 }
 //**********************************************
 /// Analyse de ce qui s'est passé en fonction des valeurs des capteurs et de la voiture
 // Toutes les possibilités 
 if (sensorc1 == 0 && cocheEX == 0) {} //Je ne fais rien, les voitures ne sont pas arrivées
 if (sensorc1 == 0 && cocheEX == 1) {} //Cette situation ne peut pas être donnée 
 if (sensorc1 == 1 && cocheEX == 0) { //Une voiture passée à l'intérieur de l'autre, préférence pour l'intérieur 
   digitalWrite (aiguille2, HIGH);
   digitalWrite (aiguille22, HIGH);    
   digitalWrite (aiguille3, HIGH);
   digitalWrite (aiguille33, HIGH);   
   while (digitalRead (C12) == HIGH){}//On s'attend à ce qu'il termine la manœuvre et tout revient à sa place 
   digitalWrite (aiguille2, LOW);
   digitalWrite (aiguille22, LOW);    
   digitalWrite (aiguille3, LOW);
   digitalWrite (aiguille33, LOW);
 }
 if (sensorc1 == 1 && cocheEX == 1) {} //danger de collision je ne fais rien 
 if (sensorc100 == 0 && cocheIN == 0) {} //Je ne fais rien, les voitures ne sont pas arrivées 
 if (sensorc100 == 0 && cocheIN == 1) {} //Cette situation ne peut pas être donnée 
 if (sensorc100 == 1 && cocheIN == 0) { //Une voiture passée à l'extérieur de l'autre, préférence pour l'extérieur 
   digitalWrite (aiguille1, HIGH);
   digitalWrite (aiguille11, HIGH);    
   digitalWrite (aiguille2, HIGH);
   digitalWrite (aiguille22, HIGH);    
   while (digitalRead (C10) == HIGH){}//On s'attend à ce qu'il termine la manœuvre et tout revient à sa place 
   digitalWrite (aiguille1, LOW);
   digitalWrite (aiguille11, LOW);    
   digitalWrite (aiguille2, LOW);
   digitalWrite (aiguille22, LOW);
 }
 if (sensorc100 == 1 && cocheIN == 1) {} // danger de collision je ne fais rien 
 //**************************************************
// les voitures sont passées je restaure tout 
 sensorc1 = 0;
 sensorc100 = 0;
 cocheEX = 0;
 cocheEX = 0;
}

Les salutations