Mon projet avance petit à petit 
j’ai reçu la carte motoshield, le moteur, j’ai pu tester son efficacité via un programme test et pour avoir toute la puissance nécessaire au moteur j’utilise les 2 canaux en parallèle sinon il tourne moitié moins vite de ce qu’il devrait.
Donc j’ai commencé à le programme sur tinkercad afin de le teste au fur et à mesure sans tout griller XD.
actuellement j’ai réussi à faire une 1ere partie, mais comme je débute je bloque un peu pour la suite.
Voici ce que fait le programme : si le bouton 1 et 3 est appuyé alors tu allume la led test ( en bleu) et tu met en route le moteur sens horaire, sinon si le bouton 2 et 4 est appuyé tu allume le moteur sens anti-horaire, et sinon tu eteint tout.
J’ai simulé le motoshield via les led :
Bleu : led test
Rouge : activer moteur
Blanc : signal PWM ( une fois le montage fais, je remplacerai le DigitalRead par AnalogRead avec une valeur de 0/255 a la place de low/high pour avoir mon signal PWM)
Vert : moteur en sens horaire
jaune : moteur sens anti-horaire
Voici le code qui pour le moment fonctionne
//les broches A1/B1 et A2/B2 sont soudé ensemble pour avoir plus de puissance,
//ne pas oublier d'envoyer du courant en même temps dans les broches A1/B1 et A2/B2
//pour avoir toute la puissance moteur
// définition des broche de la carte en tant que variable
const int LED = 2;
const int Bouton1 = 10;
const int Bouton2 = 11;
const int Bouton3 = 12;
const int Bouton4 = 3;
const int MOTEUR_A1 = 7;
const int MOTEUR_B1 = 8;
const int MOTEUR_A2 = 4;
const int MOTEUR_B2 = 9;
const int PWM_MOTEUR_1 = 5;
const int PWM_MOTEUR_2 = 6;
const int EN_PIN_1 = A0;
const int EN_PIN_2 = A1;
// fonction d'initialisation de la carte
void setup()
{
pinMode(Bouton1, INPUT);// initialisation de Bouton1 comme étant une entrée
pinMode(Bouton2, INPUT);// initialisation de Bouton2 comme étant une entrée
pinMode(Bouton3, INPUT);// initialisation de Bouton3 comme étant une entrée
pinMode(Bouton4, INPUT);// initialisation de Bouton4 comme étant une entrée
pinMode(LED, OUTPUT);// initialisation de LED comme étant une sortie
pinMode(MOTEUR_A1, OUTPUT);// initialisation de MOTEUR_A1 comme étant une entrée
pinMode(MOTEUR_B1, OUTPUT);// initialisation de MOTEUR_B1 comme étant une entrée
pinMode(MOTEUR_A2, OUTPUT);// initialisation de MOTEUR_A2 comme étant une entrée
pinMode(MOTEUR_B2, OUTPUT);// initialisation de MOTEUR_A2 comme étant une entrée
pinMode(PWM_MOTEUR_1, OUTPUT);// initialisation de PWM_MOTEUR_1 comme étant une entrée
pinMode(PWM_MOTEUR_2, OUTPUT);// initialisation de PWM_MOTEUR_2 comme étant une entrée
pinMode(EN_PIN_1, OUTPUT);// initialisation de EN_PIN_1 comme étant une entrée
pinMode(EN_PIN_2, OUTPUT);// initialisation de EN_PIN_2 comme étant une entrée
digitalWrite(Bouton1, HIGH);// activation de la resistance de pullup
digitalWrite(Bouton2, HIGH);// activation de la resistance de pullup
digitalWrite(Bouton3, HIGH);// activation de la resistance de pullup
digitalWrite(Bouton4, HIGH);// activation de la resistance de pullup
}
// fonction principale, elle se répète (s’exécute) à l'infini
void loop()
{
int etatB1 = digitalRead(Bouton1); // lecture de l'état du bouton1 et stockage dans etatB1
int etatB2 = digitalRead(Bouton2); // lecture de l'état du bouton2 et stockage dans etatB2
int etatB3 = digitalRead(Bouton3); // lecture de l'état du bouton3 et stockage dans etatB3
int etatB4 = digitalRead(Bouton4); // lecture de l'état du bouton4 et stockage dans etatB4
// Si le bouton est "appuyé"
if((etatB1==LOW)&&(etatB3==LOW))
{
digitalWrite(LED, LOW); //la LED est allumée
//allume moteur sens horaire
digitalWrite(EN_PIN_1, LOW);
digitalWrite(EN_PIN_2, LOW);
digitalWrite(MOTEUR_A1, HIGH);
digitalWrite(MOTEUR_B1, HIGH);
digitalWrite(MOTEUR_A2, LOW);
digitalWrite(MOTEUR_B2, LOW);
digitalWrite(PWM_MOTEUR_1, LOW);
digitalWrite(PWM_MOTEUR_2, LOW);
}
else if((etatB2==LOW)&&(etatB4==LOW))
{
digitalWrite(LED, LOW); //la LED est allumée
//allume moteur sens anti horaire
digitalWrite(EN_PIN_1, LOW);
digitalWrite(EN_PIN_2, LOW);
digitalWrite(MOTEUR_A1, LOW);
digitalWrite(MOTEUR_B1, LOW);
digitalWrite(MOTEUR_A2, HIGH);
digitalWrite(MOTEUR_B2, HIGH);
digitalWrite(PWM_MOTEUR_1, LOW);
digitalWrite(PWM_MOTEUR_2, LOW);
}
else
{
digitalWrite(LED, HIGH); //la LED est éteinte
//Eteint le moteur
digitalWrite(EN_PIN_1, HIGH);
digitalWrite(EN_PIN_2, HIGH);
digitalWrite(MOTEUR_A1, HIGH);
digitalWrite(MOTEUR_B1, HIGH);
digitalWrite(MOTEUR_A2, HIGH);
digitalWrite(MOTEUR_B2, HIGH);
digitalWrite(PWM_MOTEUR_1, HIGH);
digitalWrite(PWM_MOTEUR_2, HIGH);
}
}
J’aimerai faire en sorte que quand le moteur tourne il s’arrete si un interrupteur ( 2 ou 4) est appuyé.
Concretement, si le bouton 1 et 3 est allumé, il allume le moteur en sens horaire tant que l’interrupteur 4 n’est pas appuyé.
idem pour l’autre cas de figure, si le bouton 2 et 4 est allumé, il allume le moteur en sens antihoraire tant que l’interrupteur 2 n’est pas appuyé.
je ne sais pas comment le retranscrire, je pense qu’il me faut une boucle, mais quelle type ? while ? do-while ? for ? à quel niveau je dois les inclure, et comment gérer les interrupteur/variable car les interrupteurs 2 et 4 sont utilisés plusieurs fois .
Je remet en PJ mon logigramme et une photo de mon montage test
cordialement
donc vaut mieux viser plus gros.
