Electroaimant et bouton poussoir

Hello,
J'ai un module electroaimant KEYESTUDIO.
Je souhaite le piloter avec un bouton poussoir de manière à "libérer" la bille qui est aimantée.
De base, je souhaite donc que mon electroaimant soit en marche, et lorsque j'appuie sur le bouton poussoir qu'il libère la bille. J'ai essayé avec ce code mais cela ne fonctionne pas.
Une idée d'où le problème peut venir?
Merci!
Antoine

int Solenoid = 3;    
const int buttonPin = 6;    
int buttonState = 0; 
//
void setup()  
 {        
  pinMode(Solenoid, OUTPUT);  //set Solenoid as OUTPUT
}
 void loop()                     
{
  
  digitalWrite(Solenoid, HIGH);// Solenoid is effective
  buttonState = digitalRead(buttonPin); // Lecture de l'état du bouton
  if (buttonState == LOW) // Si le bouton est appuyé
  {
  digitalWrite(Solenoid, LOW);// Solenoid is non-effective
  }     
}

Pour libérer la bille ne réalimenter l'électroaimant immédiatement après l'avoir coupé . Attendre un peu avant de boucler.
Dans l'état actuel du programme il n'y a pas de réelle coupure de l'attraction. Le courant dans l'electroaimant (inductance) n'a pas le temps de décroître.

Est-ce qu'on pourrait avoir une idée du schéma électrique utilisé ?

Questions absurdes, mais sait-on jamais :

  • la bobine de l'électro aimant n'est pas alimentée directement par la sortie du micro ?
  • il y a bien une diode, câblée en inverse, en parallèle sur le bobinage ?

il est question de Keyestudio, donc on a peut être affaire à un module sur lequel l'électroaimant , doté d'une diode de roue libre, est piloté par un transistor

Si @iToine se conformait aux règles du Forum et fournissait d'office le lien vers le produit on serait fixés dès le message initial !!

c'est quand même assez précis puisqu'on a la marque, il ne manquait que le lien et la photo :slight_smile:

il est protégé comme il faut donc

votre souci c'est que vous alternez entre HIGH et LOW très rapidement même quand vous tenez le bouton appuyé puisque vous alimentez l'électroaimant en debut de chaque loop... donc pas le temps de relâcher...

si vous mettez HIGH dans le setup() ce ne sera fait une seule fois et l'appui sur le bouton relâchera alors la bille.

const byte solenoidPin = 3;    
const byte buttonPin = 6;  // en INPUT par défaut. Pull-Down externe nécessaire

void setup()  {        
  pinMode(solenoidPin, OUTPUT);  //set Solenoid as OUTPUT
  digitalWrite(solenoidPin, HIGH);// Solenoid is effective
}
 void loop() { 
  if (digitalRead(buttonPin) == LOW) // Si le bouton est appuyé
    digitalWrite(solenoidPin, LOW);// Solenoid is non-effective
}

ce code suppose un pull down externe sur le bouton

il faudra rebooter pour réactiver l'aimantation

Ahhh d’accord! J’avais pas pensé au temps de relachement…
Le pull-down c’est quoi exactement?

Une “poule daoune” c’est une résistance qui est placé entre le point du circuit qui va bien, ici c’est la sortie du bouton poussoir et :
si c’est “daoune” : l’autre point est la masse.
si c’est “œupe” l’autre point c’est Vcc.

<fin de mon moment on parle français en France> :smiling_imp:

pull-up = résistance entre l’entrée et Vcc → elle va vers le haut
pull-down = résistance entre l’entrée et la masse. → elle va vers le bas
Leur rôle est d’assurer un potentiel fixe.
Si tu mets un poussoir sans résistance en série quand le contact sera ouvert l’entrée du micro sera en l’air et elle risque de prendre n’importe quel potentiel, c’est pour cela qu’il faut qu’un potentiel soit imposé quand le contact est ouvert.

Les microcontrôleurs Atmel avr ne sont équipés en interne que de “pull-up”, cela va bien quand le bouton est connecté entre la masse et une entrée.
Ils n’ont pas de pull-down contrairement à d’autre microcontrôleur donc si tu veux mettre le poussoir entre Vcc et l’entrée du micro il faut mettre une résistance externe entre l’entrée du micro et la masse, 10k à 100k est une bonne valeur.

Pour mettre en service les pull-up il faut regarder sur le site arduino la documentation sur la fonction pinMode().

J-M-L:
c'est quand même assez précis puisqu'on a la marque, il ne manquait que le lien et la photo :slight_smile:

il est protégé comme il faut donc

votre souci c'est que vous alternez entre HIGH et LOW très rapidement même quand vous tenez le bouton appuyé puisque vous alimentez l'électroaimant en debut de chaque loop... donc pas le temps de relâcher...

si vous mettez HIGH dans le setup() ce ne sera fait une seule fois et l'appui sur le bouton relâchera alors la bille.

const byte solenoidPin = 3;    

const byte buttonPin = 6;  // en INPUT par défaut. Pull-Down externe nécessaire

void setup()  {        
 pinMode(solenoidPin, OUTPUT);  //set Solenoid as OUTPUT
 digitalWrite(solenoidPin, HIGH);// Solenoid is effective
}
void loop() {
 if (digitalRead(buttonPin) == LOW) // Si le bouton est appuyé
   digitalWrite(solenoidPin, LOW);// Solenoid is non-effective
}




ce code suppose un pull down externe sur le bouton

il faudra rebooter pour réactiver l'aimantation

J'ai effectivement une résistance de pull up avec mon bouton poussoir.
J'ai mis le code que vous m'avez donné mais cela ne fonctionne pas.
Je n'ai pas d'aimantation, et le bouton poussoir ne change rien à cela.

pas la peine de recopier tout mon texte, il est déjà dans la discussion...

faites un schéma de votre câblage (à la main - tel que c'est câblé), prenez une photo et postez le ici. + décrivez l'alimentation (l'aimant tire 400 mA sans doute au travail)

ça devrait ressembler à cela:

Bonjour,
Voici un schéma du montage (la résistance est une 4,7 K).

Apparemment les règles pour tirer des traits droits ont disparues des rayons des grandes surfaces.

Toutes mes excuses, j'ai fait ça entre deux, j'ai pas eu le temps de sortir tinkercad.
Voilà mon erreur corrigée!
N'ayant pas trouvé le module keyestudio dans tinkercad, j'ai mis un composant avec trois broches, le fil jaune correspond au SIG.

moi je préfère le truc à main levée, il y a plus de chances que ce soit proche de la réalité (mais oui des traits droits c'est mieux)

Pour le bouton, confirmez qu'il est bien à cheval au milieu de la breadboard et le mieux c'est de connecter en diagonal au travers du bouton car on ne sait jamais (à moins de tester) quelle sont les 2 pins qui sont identiques (elles sont connectées 2 à 2)... ==> si ça se trouve c'est le bouton qui est mal câblé

(et autant virer la résistance externe et mettre la pin en INPUT_PULLUP et adopter la logique : appui = LOW)

J’ai essayé pour le bouton, ça ne change rien!
J’ai pas trop compris cette histoire de mettre la pin en input_pullup.

Bonjour,
et si tu essayais avec la pin13, tu verrais l'état de ton solénoïde (ou l'inverse) de façon visuelle.

pour votre bouton, câblez comme cela:

PIN D6 --- bouton --- (sortie opposée en diagonal) --- GND

Essayez avec ce code:

const byte solenoidPin = LED_BUILTIN;    
const byte buttonPin = 6; 

void setup()  {        
  pinMode(solenoidPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  digitalWrite(solenoidPin, HIGH);
  delay(100);
}
 void loop() { 
  if (digitalRead(buttonPin) == LOW) // Si le bouton est appuyé
    digitalWrite(solenoidPin, LOW);// Solenoid is non-effective
}

lorsque vous lancez le code la LED de la carte ARDUINO doit être allumée.
si vous appuyez sur le bouton elle doit s'éteindre

si ça fonctionne, remplacez LED_BUILTIN par 3 pour piloter le Magnet

moi je préfère le truc à main levée, il y a plus de chances que ce soit proche de la réalité (mais oui des traits droits c’est mieux)

Je n’ai rien contre un dessin fait à la main et je suis d’accord sur le côté proche de la réalité surtout pour avoir du Fritzing à la place qui est tout sauf un schéma électrique.
Mais je ne supporte pas les traits à main levée, qu’est-ce que cela coûte de prendre une règle ?
La notion de respect est très évolutive d’un individu à un autre et moi c’est d’avoir des schémas propres et facilement lisibles.
Des machins avec des fils des nouilles dans tous les sens je ne regarde pas.

Faire un schéma électrique proprement et non pas à la va-vite permet de prendre le temps de réfléchir en même temps que l’on dessine et c’est un anti-connerie super efficace.
Accessoirement cela permet de faire des schémas plus concis qui tiennent sur une page écran, un schéma est fait pour être lu autant faciliter sa lecture.

Je rappelle les conventions généralement utilisées et qui facilitent la lecture pour les gens qui découvrent le schéma (ici on ne fait pas un schéma pour soi mais pour les autres) :
Ligne horizontale supérieure pour l’alimentation Vcc
Composants avec dans la mesure du possible entrées à gauche, sorties à droite (bon ce n’est pas toujours possible mais c’est mieux quand on peut le faire)
Ligne inférieure pour la masse : 0V ou gnd

Il est aussi possible de faire des renvois Vcc et Gnd ce qui permet de tirer moins de filasse si cela clarifie la lecture du schéma.
Fin de la période vieux ronchon.

oui - c'était plus entre frizzing et la main levée, je préfère la main levée.. et même sans règle ce n'est pas si dur de tracer un peu droit :slight_smile:

ensuite peu de jeunes ont des notions correctes de schéma électrique. vous avez une vie d'expérience de ce côté là !

Avec le bouton poussoir uniquement, pas de soucis. Appui éteint la led.
Quand je branche l'électroaimant, je n'ai aucune aimantation (ni avant appui, ni après appui).
avec le code suivant

//const byte solenoidPin = LED_BUILTIN;    
const byte solenoidPin = 3; 
const byte buttonPin = 6; 

void setup()  {  
  Serial.begin(115200);      
  pinMode(solenoidPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  digitalWrite(solenoidPin, HIGH);
  delay(100);
}
 void loop() { 
  if (digitalRead(buttonPin) == LOW) // Si le bouton est appuyé
    digitalWrite(solenoidPin, LOW);// Solenoid is non-effective
    Serial.println("Bouton appuyé");
}

Sans arduino: Mettez 5V sur la pin 5v et Signal de l’aimant et GND sur GND

Est-ce que l’aimant fonctionne ?