L'ascenseur de Patrick ramasoft

[ramasoft]

C'est vraiment super!

Ma question va peut-être être stupide mais... qu'est-ce qui t’empêche de faire un tablier d'ascenseur en courbe?

C'est marrant, quelqu'un m'a posé la question sur YT ...
Je pense que ça doit être possible mais avec 3 moteurs et un bon parallélisme dans tous les plans sera plus difficile à obtenir, mais ça ne me paraît pas infaisable.

[Lherve54]

Bonjour

Voici un lien sur l'ascenseur que cette société vend :

https://proses.com/shop/helix-elevator- ... o-r32.html

Il ont plusieurs modèles .

Hervé

[ramasoft]

Effectivement Christian a mis plusieurs vidéos sur des ascenseurs et il y a celle de cette société.
Apparemment une société turque avec une agence en Angleterre.
Ils font du sur mesure.
Le prix est assez élevé mais pas prohibitif.

[ramasoft]

Bonjour à tous,

Les dernières avancées du projet: l'électronique est terminée, je n'ai pas utilisé le shield CNC qui n'était pas du tout adapté et posait plus de problèmes qu'il n'apportait de solutions.
Donc j'ai mis la carte des drivers fabrication maison dans l'ascenseur lui-même, le relais sert à mettre le 12V quand la carte est alimentée en 5V et une prise RJ45 assure la liaison avec le boitier de commande.
Le relais jaune servira à mettre ou non le DCC sur la voie du pont. Il est commandé par l'Arduino. Le DCC sera donc coupé quand le pont est en mouvement car je ne mets pas de petites barrières comme Hervé ... enfin pas pour le moment.

Les 3 fils rouge gris et blanc vont au capteur infrarouge
La prise RJ45 amène le 5V, les DIR/STEP/ENABLE des drivers, le capteur IR et le relais du DCC = 8 fils depuis le boitier de commande
J'ai laissé le bornier 5V qui servait pour les essais mais qui ne sert plus maintenant.
De même pour le 12V il y a l'entrée directe qui servait pour les essais et à droite l'entrée qui passe par le relais.

Dans le boitier de commande il y a l'Arduino. J'ai mis le UNO et j'ai juste assez de broches disponibles mais il a fallu faire des compromis.
Ainsi j'ai la broche 9 qui est partagée entre le click du bouton de commande et la touche de mémorisation: il faut donc une réaffectation selon le besoin. Toutes les broches sont prises ... ça a été du super juste mais comme le boitier a été fait pour le UNO je ne pouvais plus mettre le Mega sauf à refaire le boitier (11H d'impression + 1h30 pour le fond ...), donc on va faire avec.

L'écran est un 4 lignes de 20 caractères et j'ai mis une barrette de boutons qui est logée sous les prises RJ45. Elle sert pour bouger manuellement le pont et pour mémoriser les positions dans l'EPRPOM de l'Arduino.

Le 5V arrive sur deux barrettes en PLA recouvertes d'une bande de cuivre autocollante. L'interrupteur marche/arrêt fait aussi office d'arrêt d'urgence.

La prise RJ45 de droite va vers l'ascenseur (5V,drivers, capteur IR et relais du DCC) et celle de droite ira vers des 4 relais qui mettront ou non le DCC sur les voies de garage pour que seule la voie de sortie de l'étage sélectionné soit alimentée. J’ai quand même prévu une commande en parallèle pour pouvoir alimenter telle ou telle voie pour faire des manœuvres indépendamment de l'ascenseur.


Le boitier est incliné genre pupitre car il sera fixé sur un plan vertical et donc il fallait que le panneau de commande avec l'écran soit incliné.
Les prises RJ45 sortent en bas ainsi que la prise Jack d'alimentation du 5V
Le 5V est sur le boitier de commande et le 12 V est sur l'ascenseur, donc bien séparés pour éviter toute erreur de branchement. (je me connais ...)

Et la prise USB de l'Arduino est accessible sur le côté.

Pour les boutons de réglage, c'est une barrette de 8 boutons toute faite avec ses résistances de Pull-Up et des petits carrés imprimés en PLA viennent appuyer sur les boutons

Ils sont sous les prises RJ45 une fois tout monté

La face avant du boitier est imprimée sur ma plaque d'impression Elegoo qui est granitée et ça donne un aspect plus joli, à mes yeux, qu'une face lisse où on voit des stries. Là pas de stries, toute la surface est uniforme. (la plaque d'impression Elegoo peut se retourner et a une face lisse de l'autre côté)

Donc ça commence à prendre tournure et il reste à peaufiner le logiciel.
Après ça va être le gros travail de menuiserie pour faire la rampe d'accès, créer les niveaux des voies de garage, poser de la voie etc.
Ça va déjà moins rigoler...

[C2Vues-BricoTrain]

Bonjour Patrick,

Je suis toujours stupéfait de ce que tu réalises, et le résultat est toujours tellement "PRO" !



Amicalement.
Fernando

[bunny94]

Bonjour Patrick,

Je suis toujours stupéfait de ce que tu réalises, et le résultat est toujours tellement "PRO" !



Amicalement.
Fernando

+1 même si je n'y comprends pas grand chose

[ramasoft]

Merci à vous deux mais je suis sûr qu'Olivier va me dire que mon câblage est un foutoir sans nom ...

[likiki]

Alors là Patrick, je n'ai qu'un mot ..... félicitation.

[ramasoft]

[TrainDoly]

Merci à vous deux mais je suis sûr qu'Olivier va me dire que mon câblage est un foutoir sans nom ...

Olivier il te dis bravo et il admire ton super boulot!

[patrice_b]

Ben dis donc, c'est un très beau travail que tu nous a fait la. La classe Patrick.

[jeanjacques]

[ramasoft]

[garedalesia]

Impressionnante ta réalisation Patrick, quel énorme travail accompli, le boitier est très pro, je rejoins l'avis de tous

[ramasoft]

Voilà, cette fois c'est terminé.
J'ai collé des décalcomanies sur le boitier, elles sont fixées avec une couche de vernis mat mais je ne sais pas ce que ça va donner dans le temps car la surface du boitier n'est pas lisse mais granitée.
J'ai aussi ajouté un bouton reset, au cas où ça se planterait où pour réinitialiser le zéro de référence.
Le logiciel est aussi terminé, il sauvegarde les valeurs en Eprom. Je voulais ajouter une petite animation au démarrage mais l'écran a un temps de réponse trop élevé et je me suis contenté d'un petit texte qui se promène gentiment ... J'aurai dû prendre un écran Oled.
Mon entêtement à utiliser un Arduino Uno (alors que j'avais acheté un Mega pour ça ... ) m'a obligé à faire quelques compromis avec un partage de broches ... C'est la durée d'impression du boitier qui m'a bloqué mais je suis coincé si je veux ajouter d'autres fonctions et je serai certainement obligé tôt ou tard de refaire un boitier plus grand pour loger le Mega. En plus il me reste connexions libres sur les prises RJ45 + les deux masses qui ne sont pas utilisés.

Et une petite vidéo du fonctionnement. la plaquette des relais servira pour la connexion des voies de garage, le courant n'étant mis que sur la voie sélectionnée par l'ascenseur.

Essai1080p.mp4

(47.96 Mio) Téléchargé 6 fois

Pour le code, c'est du basique sans sophistication ni fioritures, je le mettrai en téléchargement sur mon Google Drive car ici, je pense que ça n'intéressera personne

En tout cas, ça m'a permis de me familiariser avec l’environnement Arduino que je ne connaissais pas du tout et ça m'a donné envie faire d'autres applications par la suite. Et ça m'a aussi permis de me documenter sur les moteurs pas à pas.
Donc une expérience positive, et encore merci à Hervé et à Christian pour leurs conseils et le partage de leur expérience.

[garedalesia]

Salut Patrick,
C'est vraiment génial !

[ramasoft]

Merci Marc

Et j'ai oublié de citer Olivier qui m'a aussi accompagné de ses bon conseils tout au long de cette réalisation
à toi aussi

[patrice_b]

Excellent travail Patrick, vraiment tu es doué, pour maitriser tout ça, à la vitesse ou tu l'as fais.

Bien sur que si le code intéressera du monde, moi le 1er, déjà pour apprendre et pour mon futur double ascenseur de stockage.


Merci de nous avoir montré tout ça.

Il y a vraiment des gars doués sur ce forum, c'est une vrai pépite, ou l'on apprend beaucoup . Je ne regrette pas de l'avoir découvert , et en plus, vous êtes tous très sympathiques et simples.

Vive "Passionement" .

[ramasoft]

Merci Patrice
Et donc je mets le code ici, il est en 3 parties

Code : Tout sélectionner

/* Commande Ascenseur Nema 17 avec TMC2209 et Arduino Uno
Les deux moteurs sont en parallèle sur les mêmes broches
********************************************************
          Version 1.10 © Ramasoft Juin 2025
********************************************************

 Brochage Prise RJ45-1  vers ascenseur
    1 -> +5V
    2 -> 0V Gnd
    3 -> Relais DCC pont
    4 -> Capteur IR
    5 -> Inutilisée
    6 -> DIR_PIN    (jaune)
    7 -> STEP_PIN   (rouge) 
    8 -> EN_PIN     (bleu)
    Masse -> non connectée


  Brochage Prise RJ45-2  vers carte relais DCC
    1 -> +5V
    2 -> 0V Gnd
    3 -> Relais DCC Voie Niveau - 1 
    4 -> Relais DCC Voie Niveau - 2
    5 -> Relais DCC Voie Niveau - 3
    6 -> Relais DCC Voie Niveau - 4
    7 -> Inutilisée
    8 -> Inutilisée
    Masse -> non connectée
************************************************************
Broches Utilisées sur l'Arduino
************************************************************
Broches de contrôle des Moteurs 
2 -> ENABLE  	-> RJ45-1 Broche 8 
3 -> STEP  	-> RJ45-1 Broche 7
4 -> DIR   		-> RJ45-1 Broche 6

Autres Broches utilisées 
5 -> IR_PIN 5    	-> RJ45-1 Broche 4   Capteur IR détection fin de course 
6 -> DCC_PIN 6   -> RJ45-1 Broche 3   Relais du DCC sur le pont   

Boutons de commande           
7  -> CLK_PIN     	Encodeur CLOCK
8  -> DT_PIN        	Encodeur DATA
9  -> SW_PIN		Encodeur Switch
10 -> BoutonHaut    	Bouton Haut
11 -> BoutonBas     	Bouton Bas
12 -> BoutonHaut_R  Bouton Haut Rapide
13 -> BoutonBas_R  	Bouton Bas Rapide
(9 -> BoutonMemo    Bouton Mémorisation -> partage broche avec SW_PIN)

Écran LCD LiquidCrystal I2C : A4 -> SDA  A5 -> SCL

Broches pour les relais qui mettent le DCC sur les voies de stockage
14 -> RJ45-2  broche 3  Relais DCC voie niveau -1  -> correspond à A0
15 -> RJ45-2  broche 4  Relais DCC voie niveau -2  -> correspond à A1
16 -> RJ45-2  broche 5  Relais DCC voie niveau -3  -> correspond à A2
17 -> RJ45-2  broche 6  Relais DCC voie niveau -4  -> correspond à A3
*/

//********************
// Déclarations

#include <AccelStepper.h>      // Bibliothéque Moteur pas a pas
#include <LiquidCrystal_I2C.h> // Bibliothèque pour l'écran LCD
#include <EEPROM.h>            // Bibliothèque pour accéder à l'EEPROM
 
// Broches de contrôle des Moteurs 
#define EN_PIN 2    //Bleu   Enable 
#define STEP_PIN 3  //Rouge  Step   
#define DIR_PIN 4   //Jaune  Dir    

// Autres Broches utilisées 
#define IR_PIN 5    //Capteur IR détection fin de course haut 
#define DCC_PIN 6   //Relais du DCC sur le pont   

// Boutons de commande           
#define CLK_PIN 7       // Encodeur CLOCK
#define DT_PIN 8        // Encodeur DATA
#define SW_PIN 9        // Encodeur SWITCH
#define BoutonHaut 10   // Bouton Haut
#define BoutonBas 11    // Bouton Bas
#define BoutonHaut_R 12 // Bouton Haut Rapide
#define BoutonBas_R 13  // Bouton Bas Rapide
//                      // Bouton Mémorisation -> partage la broche 9 avec SW_PIN


AccelStepper Moteur(AccelStepper:: DRIVER, STEP_PIN, DIR_PIN);  // création de l'objet Moteur 
LiquidCrystal_I2C lcd(0x27, 20, 4);                             		   // création de l'objet lcd

// Encodeur rotatif
const int pinCLK = 7;
const int pinDT  = 8;
const int pinSW  = 9;

bool lastCLK = HIGH;

// Menus
const int MAIN_MENU = 0;
const int Menu_Reglage = 2; 

int currentMenuLevel = MAIN_MENU;
int currentMenuIndex = 0;
int topMenuIndex = 0;

// Menu principal
const int mainMenuLength = 6;
String mainMenu[mainMenuLength] = {
  "Niveau 0   Choix ->",
  "1e Sous-Sol",
  "2e Sous-Sol",
  "3e Sous-Sol",
  "4e Sous-sol",
  "Memorisation"
};
String* activeMenu;
int activeMenuLength;


// Crans Moteur pour les différents niveaux par défaut
unsigned long tableauPositions [] = {0, 10000, 20000, 40000, 50000};

int8_t Niveau = -1;             // Niveau actuel: -1 = indéfini

// Autres paramètres
const float VMax = 4000;             	    // Vitesse maxi des moteurs
const float Acceleration = 500;      	    // Distance pour Accélération et Décelération
const float HOMING_SPEED = -2000;        // Vitesse pendant le homing -> négative pour monter
const float HOMING_MAXSPEED = 1200;  // Vitesse maxi pour Homing

int VitesseLente = 500;                // Paramètres de vitesse
int VitesseRapide = 2000;            // pour réglages
long DistanceDeplacement = 50;  // Déplacement relatif 

// Configuration pour EEPROM
const int EEPROM_MAGIC_ADDR = 0;              // Adresse pour le flag magique
const int EEPROM_DATA_ADDR  = 4;              // Adresse pour les données (juste après le flag)
const unsigned long MAGIC_FLAG = 0xDEADBEEF;  // le flag qui permet de s'assurer que les données existent bien dans l'EEPROM

// Fin des déclarations
//*********************


void setup() 
{
  lcd.init();
  lcd.backlight();

  afficherProgressivement(1, "  Le petit train   ");
  afficherProgressivement(2, "     du Berry      ");
  afficherProgressivement(3, " (c) RAMASOFT 2025 ");

  pinMode(pinCLK, INPUT_PULLUP); 	// Broche de l'encodeur rotatif CLK
  pinMode(pinDT, INPUT_PULLUP);   	// Broche de l'encodeur rotatif DATA
  pinMode(pinSW, INPUT_PULLUP);  	// Contact click de l'encodeur  SWITCH
  pinMode(IR_PIN,INPUT);          	// Le capteur IR passe à LOW quand l'index est devant

  for (int i = 10; i <= 13; i++) 	// 4 Broches pour les boutons de réglage
  {  
    pinMode(i, INPUT_PULLUP);
  }

  // Lecture des positions sauvegardées en EEPROM
  unsigned long flag;
  EEPROM.get(EEPROM_MAGIC_ADDR, flag);
  if (flag == MAGIC_FLAG) 
  {
    // Les données existent, on peut les lire 
    EEPROM.get(EEPROM_DATA_ADDR, tableauPositions);
  }

  
  // Broche Enable du driver (LOW = activé)
  pinMode(EN_PIN,OUTPUT);

  // Relais pour les voies de garage Activés en LOW et coupés en HIGH (inverse du relais DCC)
  for (int8_t i = 0; i<4; i++) 
  { 
       pinMode((i+14), OUTPUT);
      digitalWrite(i+14, HIGH);
  }
  // Relais pour le DCC sur le pont
  pinMode(DCC_PIN,OUTPUT);
  digitalWrite(DCC_PIN,LOW) ; // Relais coupé en LOW et Activé en HIGH = DCC sur le pont en HIGH


  // Homing = recherche du point zéro
   Homing();

  // Place le pont sur le niveau 0 = voie d'entrée
    Niveau = 0;  // mémorise le niveau actuel
    Deplace(tableauPositions[0]);

  // Démarre sur menu principal
  activeMenu = mainMenu;
  activeMenuLength = mainMenuLength;
  currentMenuLevel=MAIN_MENU;
  updateMenu();
}     


void loop() 
{
  readEncoder();
    
  if (digitalRead(SW_PIN)==LOW) {   // Bouton SW ou bouton Orange utilisé
      if (currentMenuIndex == 5) {    // Si menu Mémorise affiché -> sauvegarde en EEPROM
          Memorise();
      } else {
          for (int8_t i = 0; i<4; i++) { // coupe les relais des voies de garage
            digitalWrite(i+14, HIGH);
          }
          Niveau = currentMenuIndex;  // mémorise le niveau actuel
          Deplace(tableauPositions[currentMenuIndex]);
          updateMenu(); 
      }
   
  } else {                      // Boutons de réglages utilisés
        if (digitalRead(BoutonHaut)== LOW) { 
            DeplacementReglages(DistanceDeplacement,- VitesseLente);
        } else if (digitalRead(BoutonBas)== LOW) {
            DeplacementReglages(DistanceDeplacement,VitesseLente);
        }
        if (digitalRead(BoutonHaut_R)== LOW) {
            DeplacementReglages(DistanceDeplacement,- VitesseRapide);
        } else if (digitalRead(BoutonBas_R)== LOW) {
            DeplacementReglages(DistanceDeplacement,VitesseRapide);
        }
  }
  if (currentMenuLevel = Menu_Reglage) {;  //déplacement manuel par les touches
   Moteur.run(); 
  }
}   

void Deplace(unsigned long position1)  
 {  // Déplacement vers position1
    digitalWrite(EN_PIN, LOW);  // active les drivers
    digitalWrite(DCC_PIN, LOW); // coupe le DCC sur le pont pendant le déplacement
    Moteur.stop ();             // au cas où un déplacement manuel serait encore actif
    Reculer(1);                 // nécessaire pour débloquer le moteur après déplacement manuel vers le haut
    Moteur.setMaxSpeed(VMax);     // Vitesse max 
    Moteur.setAcceleration(Acceleration);  // distance accélération / décélération
    
    lcd.clear();
    lcd.setCursor(0, 0); lcd.print("Deplacement en cours ...");
    lcd.setCursor(0, 1); lcd.print("Vers Niveau ");
    lcd.print((currentMenuIndex > 0) ? ("-") : (" ")); lcd.print(currentMenuIndex);
    lcd.setCursor(0,2); lcd.print(Moteur.currentPosition()); lcd.print(" -> "); lcd.print(position1);
    
    Moteur.runToNewPosition(position1); // combine moveTo(position) et runToPosition()
    
    lcd.setCursor(0, 3); lcd.print("Atteint ");
    delay(2000);
    digitalWrite(EN_PIN, HIGH);        // coupe les drivers
    digitalWrite((Niveau + 13), LOW); // Active le relais de la voie de sortie
    digitalWrite(DCC_PIN, HIGH);      // et met le DCC sur le pont
}
   

Code : Tout sélectionner

// Fonctions pour les menus
//**************************
void readEncoder() 	// lecture de la position de l'encodeur rotatif
{  
  bool currentCLK = digitalRead(pinCLK);
  if (currentCLK != lastCLK && currentCLK == LOW) {
    if (digitalRead(pinDT) != currentCLK) {
      currentMenuIndex--; // vers la droite : descend
    } else {
      currentMenuIndex++; // vers la gauche : monte
    }
    if (currentMenuIndex < 0) currentMenuIndex = 0;
    if (currentMenuIndex >= activeMenuLength) currentMenuIndex = activeMenuLength - 1;

    // scroll des 4 lignes visibles
    if (currentMenuIndex < topMenuIndex) topMenuIndex = currentMenuIndex;
    if (currentMenuIndex > topMenuIndex + 3) topMenuIndex = currentMenuIndex - 3;
    updateMenu();
  }
  lastCLK = currentCLK;
}

void updateMenu() 
{
  lcd.clear();
  for (int i = 0; i < 4; i++) {
    int itemIndex = topMenuIndex + i;
    if (itemIndex < activeMenuLength) {
      lcd.setCursor(0, i);
      lcd.print((itemIndex == currentMenuIndex) ? ">" : " ");
      lcd.print(activeMenu[itemIndex]);
    }
  }
}

// Affichage progressif d’une ligne (lettre par lettre)
void afficherProgressivement(int ligne, String texte) 
{
  lcd.setCursor(0, ligne); lcd.print("                   "); // Nettoie la ligne

  for (int i = 0; i < texte.length(); i++) {
    lcd.setCursor(i, ligne); lcd.print(texte[i]);
    delay(80);
  }
}

Code : Tout sélectionner

// Fonctions de déplacement & Mémorisation
//****************************************************
void DeplacementReglages (long Distance,int Vitesse) 	 // Déplacements manuels réalisés avec les touches
{  
  currentMenuLevel = Menu_Reglage;
  digitalWrite(DCC_PIN, LOW); // coupe le DCC sur le pont
  digitalWrite(EN_PIN, LOW);  // active les drivers
  Moteur.setSpeed(Vitesse);
  Moteur.move(Distance);
  if (digitalRead(IR_PIN) == LOW )   // Sécurité si on cherche à monter trop haut
  { 
    Moteur.stop ();
    Reculer(200);
  }
}

void Memorise () 
{
  lcd.clear();
  lcd.setCursor(0, 0); lcd.print("Memorisation");
  lcd.setCursor(0, 1); lcd.print("Niveau ");
  lcd.print((Niveau > 0) ? ("-") : (" ")); lcd.print(Niveau);
  lcd.setCursor(0, 2); lcd.print("Valeur: ");
  lcd.print(Moteur.currentPosition());
  tableauPositions[Niveau] = Moteur.currentPosition();
  
  EEPROM.put(EEPROM_DATA_ADDR, tableauPositions);  // Écriture du tableau des positions
  EEPROM.put(EEPROM_MAGIC_ADDR, MAGIC_FLAG);       // en EEPROM
  
  delay(2000);
  activeMenu = mainMenu;
  activeMenuLength = mainMenuLength;
  currentMenuLevel=MAIN_MENU;
  updateMenu();
}

void Homing() {       // Recherche du point zéro
  digitalWrite(EN_PIN, LOW);
  lcd.setCursor(0,0); lcd.print("Recherche position  "); 
  lcd.setCursor(0,1); lcd.print("de reference ...    ");
  lcd.setCursor(0,2); lcd.print("                    ");
  Moteur.setMaxSpeed(HOMING_MAXSPEED);
  Moteur.setAcceleration(Acceleration);
  Moteur.setSpeed(HOMING_SPEED);

  while (digitalRead(IR_PIN) == HIGH) { Moteur.runSpeed(); }    // Mouvement continu à vitesse fixe
    
  Moteur.stop();  // Arrêt immédiat après détection
  Reculer(200);   // Reculer un peu pour dégager le capteur
  
  // Définir la position actuelle comme "0"
  Moteur.setCurrentPosition(0);
  lcd.clear();
  lcd.setCursor(0,1); lcd.print("Reference Atteinte");
  delay(1000);
}

void Reculer (int Offset) 
{
  Moteur.move(Offset);           // Définir déplacement relatif
  while (Moteur.distanceToGo() != 0) 
  {
    Moteur.run();               // Avancer doucement avec accélération
  }
}

[patrice_b]

Merci Patrick.

[bunny94]

En tout cas Patrick un grand bravo pour ton boîtier il fait très pro.

[ramasoft]

Merci Alain, il ne reste plus qu'à monter une chaîne de commercialisation ...

[likiki]

C'est marrant, j'ai pensé a toi ce matin Patrick.

Le driver
.

.


La carte Mega 2560 ( ou plus si affinité )
.

.

Le moteur pas a pas
.

.

Le moteur en fonctionnement (le son est sans trucage).

http://gofile.me/5bd43/nHIw814YF

Le débit de câble est de 5m/seconde

Une visite des lieux ...

http://gofile.me/5bd43/9jwN8M1Ct

Ce que vous entendez c'est la ventilation forcé du local.

[garedalesia]

Super impressionnant Christian !

[ramasoft]

Super, moi qui rêvait toujours de rentrer dans la machinerie d'un ascenseur, là c'est du lourd... pas le petit ascenseur d'immeuble.
Les cartes sont juste un peu plus grosses et on n'est pas en 12V ...
La vitesse de rotation du moteur est impressionnante
Christian, c'est très instructif