Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 22 mai 2021, 19:03
par Papy2568
Mais bon, je ne vois pas d'autres solutions pour brancher des fils dans une carte électronique avec picot. Sur ma cnc les branchements sont faits avec des connecteurs Dupont dont je serti moi-même avec une pince.
Re: Automatisation d'un ascenseur a trains avec un Arduino
A droite c'est Obelix, mais a gauche ? C'est la caricature de qui ? Le savez vous ?
Caius Saugrenus, caricature des Énarques, sous les traits de Jacques Chirac.
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 09 oct. 2021, 14:56
par likiki
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 16 oct. 2021, 08:51
par Georges de Villette
On y arrive , on y arrive !!!!!
Perso , je trouve le déplacement un peu rapide .
Il faudrait faire une moyenne entre le tiens et celui d'Hervé !!!
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 16 oct. 2021, 09:15
par likiki
Bonjour George, content de te revoir parmis nous.
Oui et non.
En fait, la vitesse est liée ... au bruit.
Trop lentement ça grogne, trop vite ça vibre.
Il faut trouver le bon compromis. Pour moi 105 pas est apparement le bon compromis entre bruit et vitesse. Hervé est sur une vis sans fin et moi par courroie. Deux techniques différentes pour un même résultat.
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 10 nov. 2021, 08:55
par likiki
Petit avancement du projet.
- Remplacement des 8 boutons poussoirs et d'un interrupteur par un encodeur rotatif.
- Sauvegarde des altitudes des niveaux sur une micro carte SD
- Mise en place d'un relais pour couper l'alimentation du moteur au repos (très bonne idée piqué a Hervé)
La mise en oeuvre vas en être grandement simplifiée et surtout plus économique puisque passage d'une carte MEGA a une carte UNO.
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 10 nov. 2021, 09:36
par herwat
likiki a écrit : ↑10 nov. 2021, 08:55
Petit avancement du projet.
- Remplacement des 8 boutons poussoirs et d'un interrupteur par un encodeur rotatif.
ça m'intéresse au plus haut point !
Je n'ai pas réussi à faire fonctionner correctement un encodeur rotatif . . . . Alors je me suis rabattu sur un inter mOm , tout penaud
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 10 nov. 2021, 13:16
par Georges de Villette
herwat a écrit : ↑10 nov. 2021, 09:36
......... Je n'ai pas réussi à faire fonctionner correctement un encodeur rotatif . . . .
Et bien tu vas avoir la solution dans peu de temps !!!
Ca sert un peu à ça un forum !!!
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 10 nov. 2021, 18:33
par likiki
Oui Georges, je vais d'ailleurs créer un sujet sur cet élément (l'encodeur rotatif) qui est assez simple dans la mise en oeuvre comme dans la programmation.
Re: Automatisation d'un ascenseur a trains avec un Arduino
Posté : 11 nov. 2021, 18:30
par likiki
Le programme, qui n'est pas encore totalement terminé.
Reste encore la gestion d'un fin de course a inclure.
/*
***************************************************
****** Ascenseur avec un moteur pas à pas *******
****** *******
****** Programme V 1.7 *******
****** Du 08/11/2021 *******
****** Par C.ARFEL *******
****** *******
****** Carte MEGA 2560 *******
****** *******
****** Version 1.7 *******
****** Mise a quai manuelle *******
****** Afficheur lcd 16 x 2 I2C *******
****** RC + 5 sous sol *******
****** Servo pour le taquet *******
****** LED rouge / verte *******
****** Sauvegarde des niveaux sur Micro SD *******
****** Menu par encodeur *******
****** *******
****** *******
****** Liste des bornes utilisées *******
****** *******
****** D0 *******
****** D1 *******
****** D2,D3,D4,D5 Moteur pas a pasNema17 *******
****** D6 Servo moteur taquet *******
****** D7 Encodeur rotatif borne SW *******
****** D8 Fin de course haut *******
****** D9 Commande relais *******
****** D10 Reservé carte SD avec UNO *******
****** D11 *******
****** D12 *******
****** D13 *******
****** *******
****** *******
****** A2 Borne DT encodeur rotatif *******
****** A3 Borne CLK encodeur rotatif *******
****** A4 LED Verte *******
****** A5 LED Rouge *******
****** A7 *******
****** A8 *******
****** *******
****** Le croquis utilise 27656 octets (10%)*******
****** de l'espace de stockage de *******
****** programmes. Le maximum est de *******
****** 253952 octets. *******
****** *******
****** Les variables globales utilisent *******
****** 1829 octets (22%) de mémoire *******
****** dynamique, ce qui laisse 6363 *******
****** octets pour les variables locales. *******
****** Le maximum est de 8192 octets. *******
****** *******
****** *******
****** *******
****** *******
****** *******
****** D53 Reservé carte SD avec MEGA *******
***************************************************
*/
#include <Stepper.h> // appel de la bibliothèque pour le moteur pas à pas
#include <LiquidCrystal_I2C.h> // appel de la librairie pour l'afficheur lcd
#include <Servo.h> // appel de la bibliotheque pour le servo moteur
#include <SPI.h> // Appel de la bibliothéque pour la carte SD
#include <SD.h> // Appel de la bibliothéque pour la carte SD
#define STEPS 200 // nombre pas moteur par tour
#define nomDuFichier "PosPlat.txt" // Format 8.3 (8 lettres maximum, et 3 pour l'extension) du fichier sur la carte SD
#define sdCardCsPin 53 // Borne du CS de la carte SD (53 sur MEGA ou 10 sur UNO)
#define STEPSS 1 // Nombre par pas d'encodeur
#define POSMIN -5 // Position MINI de l'encodeur
#define POSMAX 4 // Position MAX de l'encodeur
#define BPE 7 // Borne SW encodeur (bouton)
#include "RotaryEncoder.h" // Appel de la bibliothéque pour encodeur
RotaryEncoder encoder(A2, A3); // Borne de l'encodeur (DT, CLK)
Servo monServomoteur; // création de l'objet servo
LiquidCrystal_I2C lcd(0x27, 16, 2); // déclaration adresse du lcd
Stepper stepper(STEPS, 2, 3, 4, 5); // création de l'objet moteur
const int nombre_pas = 200; // nombre de pas du moteur
const int buttonPin8 = 8; // borne du FCH
const int buttonPin37 = 37; // FC Taquet O
const int relais = 9; // Relais
int Deplace = 0; // variable de déplacement
int plateau = 0; // variable pour la position du plateau
int Etage = 0; // variable contenant l'étage du plateau
int sens = 1; // sens de rotation moteur par défaut 1 = Monté 0 = descente
int FCH = 0; // variable Fin de Course Haut
int SS0 = 0; // variable RC
int SS1 = 0; // variable 1er sous sol
int SS2 = 0; // variable 2ème sous sol
int SS3 = 0; // variable 3ème sous sol
int SS4 = 0; // variable 4ème sous sol
int SS5 = 0; // variable 5ème sous sol
int BPMO = 0; // variable bouton monté
int BPDE = 0; // variable bouton descente
int Inter = 0; // variable bouton auto / manuel
int Pinter = 0; // variable position de l'inter
int Pos0SS = 10; // Crans moteur pour la position plateau niveau reseau.
int Pos1SS = -100; // Crans moteur pour la position plateau 1er sous sol
int Pos2SS = -200; // Crans moteur pour la position plateau 2ème sous sol
int Pos3SS = -300; // Crans moteur pour la position plateau 3ème sous sol
int Pos4SS = -400; // Crans moteur pour la position plateau 4ème sous sol
int Pos5SS = -500; // Crans moteur pour la position plateau 5ème sous sol
int Ptaquet = 0; // Variable Servo
int Ptaqueto = 0; // variable position taquet (ouvert = 1) (fermé = 0)
int Test = 0; // Variable calcul 1
int Position = 0; // Variable Position du plateau
int Pointeur = 0; // variable pour pointer SD
int x; // variqble pour pointer SD
int nouveauChiffre;
int Xsd; // Variable pour le transfére des données char ==> int
int Top = 0; // Variable pour lecture de la SD
int Init = 0; // Variable pour l'initialisation
int lastPos, newPos; // Variable encodeur
int Ebpe = 10; // Variable bouton encodeur
int Monte = 0; // Variable mise a quai Montée
int Descente = 0; // Variable mise a quai Descente
int Tak; // Variable pour le sou smenu
String logFileName = ""; // Nom du fichier d'enregistrement (Texte)
char logSdFileName[12]; // "" (char)
char fileChar; // Variable lecture carte SD
File monFichier; // Nom du fchier sur la carte SD
File fichierSD;
File dataFile = SD.open((String)logSdFileName, FILE_READ);
void setup() // Debut du SETUP
{
Serial.begin(9600); // Vitessse de com série
lcd.init(); // Initialisation de l'afficheur
lcd.backlight(); // Allume l'ecran
monServomoteur.attach(6); // Affectation de la borne 12 pour le servo
encoder.setPosition(10 / STEPSS); // Position initiale encodeur
delay(200);
/*
***************************************
* Mise en place des entrées / sorties *
***************************************
*/
pinMode(buttonPin8, INPUT); // initialisation de la borne du FCH en entrée
pinMode(buttonPin37, INPUT); // initialisation du FC taquet Ouvert
pinMode(BPE, INPUT); // Initialisation du clic encodeur rotatif
pinMode(A4, OUTPUT); // Initialisation de la pin 10 en sortie
pinMode(A5, OUTPUT); // Initialisation de la pin 11 en sortie
pinMode(9, OUTPUT); // Initialisation de la pin 7 en sortie
stepper.setSpeed(150); // vitesse du moteur en tours par minute
digitalWrite(9, HIGH); // decolle le relais
} // fin du setup
/*
************************
* Fin de la zone SETUP *
************************
*/
/*
**************************************
* Lecture des données de la Carte SD *
**************************************
*/
void LectureSD(){
Top = 1; // Variable de passage
lcd.clear(); // Efface l'ecran
lcd.setCursor (0,0); // place le curseur sur la ligne 0 a gauche
lcd.print ("*Initialisation*"); // Affichage sur le lcd
lcd.setCursor (0,1); // passe a la ligne suivante
lcd.print ("* Carte SD *"); // affichage sur le lcd
delay(1000); // Tempo 1s pour lire le texte sur l'écran
if (!SD.begin(sdCardCsPin)) // Si la carte SD ne repond pas
{
lcd.clear(); // Efface l'ecran
lcd.setCursor (0,0); // place le curseur sur la ligne 0 a gauche
lcd.print ("* Carte SD *"); // Affichage sur le lcd
lcd.setCursor (0,1); // passe a la ligne suivante
lcd.print (" Out ou absente "); // affichage sur le lcd
while(1); // Boucle sans fin si probléme de carte SD
}
lcd.clear(); // Efface l'ecran
lcd.setCursor (0,0); // place le curseur sur la ligne 0 a gauche
lcd.print ("* Carte SD *"); // Affichage sur le lcd
lcd.setCursor (0,1); // passe a la ligne suivante
lcd.print (" OK *"); // affichage sur le lcd
delay(1000); // Tempo 1s pour lire le texte sur l'écran
logFileName = "PosPlat.txt"; // longueur max 8+3 caractères noms de fichier
logFileName.toCharArray(logSdFileName, 12);
Xsd = dataFileGetIndexValue(1); // Rechercher la valeur à la ligne 1
Pos0SS = Xsd;
Xsd = dataFileGetIndexValue(2); // Rechercher la valeur à la ligne 2
Pos1SS = Xsd;
Xsd = dataFileGetIndexValue(3); // Rechercher la valeur à la ligne 3
Pos2SS = Xsd;
Xsd = dataFileGetIndexValue(4); // Rechercher la valeur à la ligne 4
Pos3SS = Xsd;
Xsd = dataFileGetIndexValue(5); // Rechercher la valeur à la ligne 5
Pos4SS = Xsd;
Xsd = dataFileGetIndexValue(6); // Rechercher la valeur à la ligne 6
Pos5SS = Xsd;
}
// ___________________________________ Pour tout mettre dans l'ordre avant mise en variable utilisable ____________________________________
float dataFileGetIndexValue(int lineIndex)
{
String lineFromSd;
float returnValue = -1;
int valueIndex = 1;
File dataFile = SD.open((String)logSdFileName, FILE_READ);
if (dataFile)
{
while (dataFile.available()) // Boucle de lecture
{
lineFromSd = dataFile.readStringUntil('\n');
String varName = lineFromSd.substring(0, lineFromSd.indexOf(":")); // On prends la partie gauche pour extraire le nom de la variable
varName.toUpperCase(); // Le nom de la variable, mise en majuscule
varName.trim(); // Enlever les espaces inutiles
String varValue = (lineFromSd.substring(lineFromSd.indexOf(":") +1)); // On prends la partie droite comme valeur
if (valueIndex == lineIndex) // Si arrivé à la ligne désirée
{
returnValue = varValue.toFloat(); // Que l'on transforme en valeur float
}
valueIndex ++; // Pour la ligne suivante
}
}
else
{
lcd.clear(); // Efface l'ecran
lcd.setCursor (0,0); // place le curseur sur la ligne 0 a gauche
lcd.print ("* Erreur * "); // Affichage sur le lcd
lcd.setCursor (0,1); // passe a la ligne suivante
lcd.print (String(logSdFileName)); // affichage sur le lcd
}
dataFile.clearWriteError();
dataFile.close(); // Ferme le fichier de la carte SD
return returnValue; // Retourne a la boucle si besoin
}
/*
****************************
* Séquence initialisation *
****************************
*/
void Initialisation() { // Module initialisation du plateau Recherche du FC
lcd.setCursor (0,0); // place le curseur sur la ligne 0 a gauche
lcd.print ("* Deplacement * "); // Affichage sur le lcd
lcd.setCursor (0,1); // passe a la ligne suivante
lcd.print ("*Initialisation*"); // affichage sur le lcd
if (Ptaqueto < 1) {
Otaquet(); // Ouverture du taquet par sécuritée
}
if (sens >=1) {
if (FCH == LOW) { // Contrôle la position du fin de course haut
sens = 1; // Attribue le sens monté si le fc n'est pas actionné
}
else {
sens = 0; // Attribue le sens Descente si le fin de course est actionné
lcd.clear (); // Efface l'ecran
delay (100);
lcd.setCursor (0,0);
lcd.print (" Niveau reseau. ");
delay(10);
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("** En attente **");
delay (200);
Ftaquet(); // Fermeture taquet
Init = 1; // Informe que l'initialisation a été faite pour ne pas y revenir
}
{
stepper.setSpeed(150); // Vitesse du moteur
stepper.step(sens); // Sens de rotation du moteur
}
}
}
/*
*********************************
* Séquence Ouverture du taquet *
*********************************
*/
void Otaquet(){
digitalWrite(A4, LOW); // Eteind la LED verte
digitalWrite(A5, HIGH); // Allume la LED rouge
digitalWrite(9, LOW); // Commande le relais
delay(1000);
for (unsigned long position = 2150; position >= 800; position -= 10) { // Commande le mouvement du servomoteur
monServomoteur.writeMicroseconds(position);
delay(5);
}
delay(1000); // Tempo d'attente
Ptaqueto = 1; // Signal taquet Ouvert
}
/*
*********************************
* Séquence fermeture du taquet *
*********************************
*/
void Ftaquet(){
for (unsigned long position = 800; position <= 2150; position += 10) { // Commande le mouvement du servomoteur
monServomoteur.writeMicroseconds(position);
delay(5);
}
delay(1000); // Tempo d'attente
digitalWrite(A4, HIGH); // Allume la LED verte
digitalWrite(A5, LOW); // Eteind la LED rouge
digitalWrite(9, HIGH); // Commande le relais
delay(1000); // Tempo d'attente
Ptaqueto = 0; // Signal taquet Fermé
}
/*
*********************************
* Séquence commande du moteurn *
*********************************
*/
void Bouge(){ // Module commande moteur
Otaquet(); // Demande l'ouverture du taquet
lcd.clear (); // Efface l'ecran
lcd.setCursor (0,0);
lcd.print ("** Plateforme **");
delay(10);
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("* En mouvement *");
delay (10);
stepper.setSpeed(150); // Passage en vitesse Maximum
stepper.step(Deplace); // Nombre de cran de déplacement du moteur
Ftaquet(); // Fermeture du taquet
lcd.clear (); // Efface l'ecran
lcd.setCursor (0,0);
lcd.print ("** etage ");
lcd.println (Etage); // Affiche l'étage où se trouve le plateau.
lcd.println (" **");
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("** En attente **");
delay (1000); // Tempo d'attente
}
/*
**********************************
* Séquence mise a quai descente *
**********************************
*/
void Maqd(){
if (Descente == 1){ // Controle l'appuye sur le bouton Descente
delay(500); // Tempo pour éviter l'enregistrement de plusieur crans
stepper.setSpeed(10); // Vitesse réduite
stepper.step(-1); // Déplacement d' 1 cran
plateau = plateau -1; // Décompte d'un cran
lcd.clear();
lcd.setCursor (0,0); // Affichage des informations
lcd.print ("Position "); lcd.print (plateau);
delay(10);
Descente = 0;
}
}
/*
*******************************
* Séquence mise a quai monté *
*******************************
*/
void Maqm(){
if (Monte == 1){ // Controle l'appuye sur le bouton Montée
delay(500); // Tempo pour éviter l'enregistrement de plusieur crans
stepper.setSpeed(10); // Vitesse réduite
stepper.step(1); // Déplacement d' 1 cran
plateau = plateau + 1; // Compte d'un cran
lcd.clear();
lcd.setCursor (0,0); // Affichage des informations
lcd.print ("Position "); lcd.print (plateau);
delay(10);
Monte = 0;
}
}
/*
********************************
* Séquence mise a quai manuel *
********************************
*/
void MiseAquai(){ // Module de mise a quai manuel
if (Inter > 0) { // Action si inter actionné
if (Ptaqueto < 1){ // Action si taquet fermé
Otaquet();
Ptaqueto = 2; // Signale taquet Ouvert
}
lcd.clear();
lcd.setCursor (0,0); // Affichage des informations
lcd.print ("Position "); lcd.print (plateau);
delay(10);
// ____________ Zone lecture encodeur rotatif _______________
while (Inter == 1){
encoder.tick();
newPos = encoder.getPosition() * STEPSS;
if (newPos < POSMIN) {
encoder.setPosition(POSMIN / STEPSS);
newPos = POSMIN;
}
else if (newPos > POSMAX) {
encoder.setPosition(POSMAX / STEPSS);
newPos = POSMAX;
}
if (lastPos != newPos) {
if (newPos == 2){
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print (" ");
lcd.setCursor(0,1);
lcd.print ("Descente");
delay (10);
lastPos = newPos;
}
if (newPos == 3){
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print (" ");
lcd.setCursor(0,1);
lcd.print ("Monte");
delay (10);
lastPos = newPos;
}
if (newPos == 4){
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print (" ");
lcd.setCursor(0,1);
lcd.print ("Valider");
delay (10);
lastPos = newPos;
}
}
if (digitalRead(BPE) == LOW) { // Control si Bouton encodeur actionné
Tak = 1;
delay(100);
Serial.print (Tak); Serial.print(" / "); Serial.print (Inter); Serial.print(" / "); Serial.println (newPos);
if (Inter == 1 && Tak == 1 && lastPos == 2){
Descente = 1;
delay (10);
Serial.println("je clic pour descendre");
Maqd();
Tak = 0;
}
if (Inter == 1 && Tak == 1 && lastPos == 3){
Monte = 1;
delay (10);
Serial.println("je clic pour monter");
Maqm();
Tak = 0 ;
}
if (Inter == 1 && Tak == 1 && lastPos == 4){
delay (10);
Serial.println("je clic pour valider");
Inter = 0;
Tak = 0 ;
}
}
}
}
} // Fin lise a quai.
/*
****************************
* Séquence sortie réglage *
****************************
*/
void Vinter(){
if (Inter == 0 && Pinter > 0){ // Action si inter coupé et signalé ouvert avant
Pinter = 0; // Signal inter fermé
Ftaquet(); // Fermeture du taquet
Ptaqueto = 0; // Signale taquet fermé
/*
********************************************************
* Séquence enregistrement des données sur la carte SD *
********************************************************
*/
if (Position == 0) {
Pos0SS = 0;
}
if (Position == 1) {
Pos1SS = plateau;
}
if (Position == 2) {
Pos2SS = plateau;
}
if (Position == 3) {
Pos3SS = plateau;
}
if (Position == 4) {
Pos4SS = plateau;
}
if (Position == 5) {
Pos5SS = plateau;
}
if (!SD.exists(nomDuFichier)) {
}
else {
// Suppression du fichier déjà existant
if(!SD.remove(nomDuFichier)) {
lcd.clear();
lcd.print ("Échec carte SD !");
while (1); // Boucle infinie (arrêt du programme)
}
else {
}
}
lcd.clear (); // Efface l'ecran
lcd.setCursor (0,0);
lcd.print ("Ecriture sur la ");
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("carte SD en cour");
delay(1000);
monFichier = SD.open(nomDuFichier, FILE_WRITE);
monFichier.println(Pos0SS); // Écriture dans le fichier
monFichier.println(Pos1SS); // Écriture dans le fichier
monFichier.println(Pos2SS); // Écriture dans le fichier
monFichier.println(Pos3SS); // Écriture dans le fichier
monFichier.println(Pos4SS); // Écriture dans le fichier
monFichier.println(Pos5SS); // Écriture dans le fichier
monFichier.close(); // Fermeture du fichier
delay(2000);
lcd.clear (); // Efface l'ecran
lcd.setCursor (0,0);
lcd.print ("** etage ");
lcd.println (Etage); // Affiche l'étage où se trouve le plateau.
lcd.println (" **");
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("** En attente **");
delay (1000);
}
}
/*
*****************************************************************************
* boucle principale ********************************************************
*****************************************************************************
*/
void loop()
{
FCH = digitalRead(buttonPin8); // lecture de la valeur du FCH
Ptaquet = digitalRead(buttonPin37); // lecture de la valeur du FC taquet Ouvert
if (Top < 1) { // Si 1er passage aller lecture SD
LectureSD();
}
if (Init <1) { // Si 1er passage aller faire l'initialisation
Initialisation(); // Vas chercher le fin de course haut si le plateau est a un étage intermédiaire.
}
if (Init > 0 && Inter == HIGH) { // Si mode réglage choisi alors direction Mise a quai manuel
Pinter = 1; // Signal l'inter en position on
MiseAquai(); // Vers le module mise a quai
}
Vinter(); // Direction sauvegarde sur SD
/*
********************************
* Début de la zone des appels *
********************************
*/
/*
****************************************
* Menu selection par encodeur rotatif *
****************************************
*/
// ________________ Zone lecture encodeur rotatif _______________
encoder.tick();
newPos = encoder.getPosition() * STEPSS;
if (newPos < POSMIN) {
encoder.setPosition(POSMIN / STEPSS);
newPos = POSMIN;
}
else if (newPos > POSMAX) {
encoder.setPosition(POSMAX / STEPSS);
newPos = POSMAX;
}
if (lastPos != newPos) {
if (newPos <= 0){ // valable de -5 a 0
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("Choix => ");lcd.print(newPos);lcd.print(" ");
delay (10);
lastPos = newPos;
}
if (newPos >= 1){ // Valable si 1
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("Choix => ");lcd.print("Reglage");
delay (10);
lastPos = newPos;
}
}
if (digitalRead(BPE) == LOW) { // Control si Bouton encodeur actionné
Ebpe = newPos;
delay(500); // Tempo de pause pour éviter la redondance du clic
}
/*
*****************************
* Appel au rez de chaussée *
*****************************
*/
if (Ebpe == 0 && plateau < Pos0SS && Inter == LOW && FCH == LOW) { // Action si choix 0 RC
FCH = 0;
Deplace = (-(plateau)) + Pos0SS;
Etage = (0);
Position = 0;
plateau = plateau + Deplace;
lcd.clear (); // Efface l'ecran
delay (100);
lcd.setCursor (0,0);
lcd.print ("** Plateforme **");
delay(10);
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("* En mouvement *");
delay (10);
Otaquet(); // Ouverture du taquet
stepper.setSpeed(150); // Passage en vitesse Maximum
stepper.step(Deplace - 15); // Me reserve des crans pour la PV en recherche du FCH
while (FCH == LOW) { // Recherche du fin de course haut
stepper.setSpeed(1); // Moteur a la vitesse 1
stepper.step(1); // Avance de 1 cran
FCH = digitalRead(8); // Lecture du FCH
}
Ebpe = 10;
Ftaquet(); // Fermeture du taquet
lcd.clear (); // Efface l'ecran
delay (100);
lcd.setCursor (0,0);
lcd.print (" Niveau reseau. ");
delay(10);
lcd.setCursor(0,1); // place le curseur ligne suivante
lcd.print ("** En attente **");
delay (1000);
}
/*
**************************
* Appel au 1er sous sol *
**************************
*/
if (Ebpe == -1 && plateau < Pos1SS && Inter == LOW) { // Action si choix -1
Deplace = (-(plateau)) + Pos1SS;
Etage = (-1);
Position = 1;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
if (Ebpe == -1 && plateau > Pos1SS && Inter == LOW) {
Deplace = (-(plateau)) - (-(Pos1SS));
Etage = (-1);
Position = 1;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
/*
***************************
* Appel au 2ème sous sol *
***************************
*/
if (Ebpe == -2 && plateau < Pos2SS && Inter == LOW) {
Deplace = (-(plateau)) + Pos2SS;
Etage = (-2);
Bouge();
Position = 2;
plateau = plateau + Deplace;
Ebpe = 10;
}
if (Ebpe == -2 && plateau > Pos2SS && Inter == LOW) {
Deplace = (-(plateau)) - (-(Pos2SS));
Etage = (-2);
Position = 2;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
/*
***************************
* Appel au 3ème sous sol *
***************************
*/
if (Ebpe == -3 && plateau < Pos3SS && Inter == LOW) {
Deplace = (-(plateau)) + Pos3SS;
Etage = (-3);
Position = 3;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
if (Ebpe == -3 && plateau > Pos3SS && Inter == LOW) {
Deplace = (-(plateau)) - (-(Pos3SS));
Etage = (-3);
Position = 3;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
/*
***************************
* Appel au 4ème sous sol *
***************************
*/
if (Ebpe == -4 && plateau < Pos4SS && Inter == LOW) {
Deplace = (-(plateau)) + Pos4SS;
Etage = (-4);
Position = 4;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
if (Ebpe == -4 && plateau > Pos4SS && Inter == LOW) {
Deplace = (-(plateau)) - (-(Pos4SS));
Etage = (-4);
Position = 4;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
/*
***************************
* Appel au 5ème sous sol *
***************************
*/
if (Ebpe == -5 && plateau < Pos5SS && Inter == LOW) {
Deplace = (-(plateau)) + Pos5SS;
Etage = (-5);
Position = 5;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
if (Ebpe == -5 && plateau > Pos5SS && Inter == LOW) {
Deplace = (-(plateau)) - (-(Pos5SS));
Etage = (-5);
Position = 5;
Bouge();
plateau = plateau + Deplace;
Ebpe = 10;
}
/*
*********************************
* Appel sous menu mise a quais *
*********************************
*/
if (Ebpe == 1) {
Pinter = 1; // Signal l'inter en position on
Inter = 1;
MiseAquai(); // Vers le module mise a quai
Ebpe = 10;
}
if (Ebpe == 4) {
Pinter = 0; // Signal l'inter en position on
Inter = 0;
MiseAquai(); // Vers le module mise a quai
Ebpe = 10;
}
/*
******************************
* Fin de la zone des appels *
******************************
*/
} // Fin de la boucle loop
/*
********************************
* Fin de la boucle principale *
********************************
*/
/*
*********************
* Fin du programme *
*********************
*/
Re: Automatisation d'un ascenseur a trains avec un Arduino