Motorisation table raboteuse SICAR Bravissima 350 - Publication sur Le Bouvet  Hors série N°14 

Bonjour,

Pour la dernière question, je peux répondre => Oui...
C'est la valeur définie dans le programme pour ta machine (et aussi le contact, si tu l'utilises).
Donc, si tu utilises le contact pour "calibrer" la table, il te faut corriger la hauteur de la table dans le programme en fonction de la valeur vraie mesurée après l'avoir mesuré sur un petit bout de bois dur raboté ou alors modifier le réglage du contact... au choix.
Le dixième de précision est facilement atteint...

Olivier me corrigera si j'ai dit une bêtise...

Bonsoir

Merci Bernard pour cette confirmation.
La partie test est OK pour moi, reste plus qu'à aller dans l'atelier pour créer l'armoire de commande et son pupitre, dès que la météo le permettra...

Bonsoir,

Tu m'as mis le doute concernant tes petits soucis de changement d'adresse des DEV-13190, alors j'ai fais la même manip que tu as dû faire et pour cela j'ai téléversé le Uno_0_0 en prenant soin AVANT de bien débrancher la liaison I2C de l'afficheur INF.
Après avoir changé l'adresse de l'afficheur supérieur, j'ai téléversé le Uno_1_1 AVANT de rebrancher la liaison I2C de l'afficheur INF (qui ainsi conserve bien sa valeur "usine" donc 0x71).

Donc reconnexion de la liaison I2C, puis essais ==> Tout fonctionne normalement, l'afficheur SUP affiche bien la valeur de positionnement de la table, plus exactement celle entrée dans les paramètres (HHOME), l'afficheur INF affiche 0.0, puis la valeur entrée au clavier au fur et à mesure de cette entrée...puis l'appui sur START fait décrémenter la valeur de l'afficheur SUP jusqu'à atteindre la valeur cible demandée, enfin l'afficheur INF affiche 0.0 une fois la valeur cible atteinte.

Voilà, maintenant y'a plus qu'à comme on dit et bon courage pour ton armoire (tu peux, si tu le souhaites, jeter un œil sur le fil que j'avais fait sur ma Sicar si tu veux la réaliser en alu, comme

Bonsoir,

je n'ai pas encore défini ou et comment je vais le réaliser mais ta dernière photo Bernard, m'a peut etre apporté une solution quand au positionnement de la deuxième armoire de commande pour ma machine .

Actuellement :



le boitier actuel contient le convertisseur de fréquence qui permet déjà à l'heure actuelle de faire tourner le combiné en 380V à partir de 220 V .
Il a pris la place du boitier d'origine , en un peu plus gros.

pour la pose du nouveau boitier, 2 solutions :

1 - doubler le boitier actuel , il faudra que je renforce le bras qui supporte le 1 er afin dans tenir 2 ... et sur le dessus le pupitre de commande ...



2 -  Comme Bernard, carrément à l'opposé , en fixant une articulation à la place du panneau fixe vert de façon à toujours pouvoir accéder au "ventre de la bête" , le pupitre de contrôle toujours à l'opposé, au dos du 1 er boitier , coté entrée de la table de rabotage  ...



pour ce qui est du boitier lui-même, j' ai trouvé pour pas cher sur le bon coin un boitier électrique, ce qui me dispense de le fabriquer .

Sinon, je me suis amusé avec le code de l'arduino en doublant le clavier par un récepteur Infrarouge, ce qui me permet d'effectuer  mes réglages " à distance" .
En maquette, cela fonctionne bien ...

On verra en place avec la poussière de bois lorsqu'elle se déposera ...

Je reste encore avec un question sur fonctionnement de base :
lorsque l'on éteint l'arduino, on ne conserve nul part la position de la table ...

Au démarrage, la table est considérée comme positionnée à HHOME ??? même si ce n'est pas le cas ... ???

Si j'ai bien compris, lorsqu'il n'y a pas de contacteur HOME, il ne faut pas oublier de remettre la table à la position HHOME avant l'arrêt  ...

Et si on oublie, comment on peut renvoyer la table à cette position ?

Avec le présence d'un contacteur Home, ne faudrait-il pas , lors de l'allumage , envoyer systématiquement la table à HOME, afin de partir d'une position parfaitement définie ? ( automatiquement ou par une commande clavier ).

Bonsoir,

Tu as parfaitement raison, si on coupe la machine avec la table non renvoyée à la position "HHOME", soit 220 pour la mienne (enfin c'était sur ma Sicar, aujourd'hui c'est monté sur ma DG410 HolzProfi) à l'allumage, la machine considère que tu es en position HHOME, soit à 220 alors que tu as pu tout couper à une hauteur bien différente.

Faute de temps et peut-être de "cela vaut-il la peine, est-ce bien nécessaire en utilisation amateur", nous n'avons pas peaufiné cette notion, car avec l'habitude je n'oublie pas de "parquer" ma table sur 220 de hauteur et c'est de même pour Jean-Paul.

En fait, nous n'avons pas pris le temps de collaborer avec Olivier pour compléter le programme comme il était prévu à l'origine, tu peux en avoir une petite idée en reprenant le début de l'étude commune du fil de Jean-Paul, alias Diomedea (R/D HolzProfi).

Dans le synoptique d'origine, il était prévu de conserver en mémoire la dernière position de la table, le HHOME servant à "étalonner" la hauteur ou à parquer la machine pour pouvoir basculer la cape d'aspiration en position dégau., de même il était prévu d'entrer une valeur cible de rabotage et de passer en mode incrémentale automatiquement jusqu'à la valeur cible atteinte, avec des valeurs de passes successives prédéfinies, plus une ou deux passes de finition... Tu peux aussi consulter le mode d'emploi très bien fait sur la Dropbox d'Olivier qui décrit ces différentes fonctions.
Bref, encore pas mal de boulot de programmation et de réflexion (mais le temps.. toujours le temps, le plus précieux des trésors et pourtant celui que l'on gâche le plus).

Voilà pour les explications, mais je t'encourage sérieusement à bien réfléchir à l'implantation des composants et "à blinder, antiparasiter" les différents éléments placés dans le beau coffret que tu as dégoté sur le coin...
Il ne t'auras pas échappé qu'il y a plusieurs filtre type Schaffner dans mon coffret, nécessaire à cause des fréquenceurs (ma Sicar est aussi équipée d'un fréquenceur d'origine pour ses moteurs, option moteurs 3CV) et que tout est câblé avec du câble blindé.

N'hésites pas à nous questionner pour la suite...

Bonjour à tous et à Bernard en particulier ...

Tu dis :

Il ne t'auras pas échappé qu'il y a plusieurs filtre type Schaffner dans mon coffret,

Peux tu etre plus précis, car je comptais bien en mettre un en tete de tout ce qui est allimentation concernant Arduino et gestion des elements du moteur pas à pas , mais pas spécialement sur le convertisseur qui possède déja ses propres filtres ...

Merci de détailler combien et sur quel circuit, si tu as un peu de temps de disponible bien évidement...

De toutes façons , cela ne sera pas monté demain ....

Amicalement, Bruno

Bonjour,
Deux filtres:
Le premier filtre aliment seulement la PC qui reçoit le bloc secteur, qui alimente l'Arduino.
Le second filtre est placé sur la ligne qui va sur l'alimentation du driver du moteur pap, juste en amont de l'alim.
J'ai préféré séparer (pour protéger) et filtrer chaque alim. séparément, car l'alim. du pap est une alim. à découpage...
Bon montage.

Ok merci beaucoup pour ton aide.

Amicalement, Bruno

Pas de souci, c'est avec plaisir!

Bonjour, bonjour,

C'est le printemps, et ses températures permettant l'accès à l'atelier !!!
Une première étape: pose du boitier devant contenir le driver et alimentation pour le moteur pas à pas +le variateur de fréquence pour gérer le "nouveau" moteur sur l'entrainement du bois  .

J'ai choisi la deuxième solution pour son implantation (coffret...) .
Accès toujours possible au dessous de la machine, coffret démontable facilement sans outils, ( sauf pour les câbles ...)

toujours possible de laisser un peu de mou pour pouvoir le pivoter sans rien démonter ... à voir si possible ...



Un bout de cornière, 2 gonds pour volets,2 pentures , un poste à souder , de la peinture pour une première protection et un peu de temps ..., le tour est joué !



Demain, démontage du moteur tri de l'ancien aspirateur et essai d'implantation ...

A première vue , cela devrait rentrer...

Bonjour à tous,

ce message s'adresse peut être plus à Wyldix (si tu passes par là...)

Je viens de faire un "nouveau code pour ma machine" toujours concernant la mise à Home de la table.

J'ai codé la remise de la table à home dès la mise sous tension de l'arduino, afin d'avoir toujours la bonne hauteur au démarrage ...

Par contre, j'aurai besoin d'un conseil et expertise , le code fonctionne bien , le travail sur le moteur est correct à une exception prêt : les instructions censées  pilotées la vitesse et l'accélération  du moteur semble sans effet, que cela soit dans ma nouvelle partie code que dans celle que tu avais écrite pour remettre la table à HHOME en appuyant sur 'H' du clavier , et dont je me suis inspiré.

Ce qui m'étonne le plus, c'est que ces instructions fonctionnent bien dans la partie qui gère la mise à hauteur de la table (en fonctionnement standard donc,), que ce soit dans le sens montée ou descente .

Je joints le code créé et ou mes problèmes sont rangés :

// Démarrage procédure initialisation  home  moteur  au lancement programme et à else if (key == 'H')   // "Home"

instructions concernées :
   moteur.setMaxSpeed(VITESSE);      // Initialisation vitesse moteur
   moteur.setAcceleration(ACCEL);  // Initialisation Acceleration moteur
Comment donc, faire prendre en compte ces instructions par le moteur dans les parties de code concernées ...

.

Pour l'instant , toujours en version essai , pas encore monté sur la machine, donc pas de parasites (à priori ...)

Merci si tu as un peu de temps à y consacrer ...
Cordialement  Bruno

Code:

/*
   Nom du fichier: RemonteTable_Uno_2_1.ino
   Auteur: Wyldix (contact à travers le forum metabricoleur.com)
   Date de création: 02.04.2015
   Date de modification: 02.04.2018 - Celthib1
   Version: 2.1
   Description: Programme qui permet de déplacer la table d'une raboteuse à la hauteur voulue,
   Ajout du "Home" + initialisation home au démarrage + affichage lcd + télécommande infrarouge + clavier 4 colonnes - 5 lignes.
*/


#include <Wire.h>
#include <Keypad.h>
#include <AccelStepper.h>
#include <math.h>
#include <IRremote.h>
#include <LiquidCrystal_I2C.h>


// Constantes définies par l'utilisateur et dépendantes de la raboteuse
#define HMIN 50                      // Hauteur minimale de la table en 1/10 mm
#define HMAX 2300                    // Hauteur maximale de la table en 1/10 mm
#define HHOME (long)2300             // Position du switch Home (normalement à la hauteur maximale sauf si on souhaite le placer à une hauteur différente) (en 1/10 mm)
#define PASPARMM (long)(400/10)      // Nombre de pas du moteur pour que la table monte de 1 mm (divisé par 10 car toutes les hauteurs du programme sont en 1/10 mm)
#define ACCEL (2*PASPARMM*10)        // Accélération en mm/s^2 (200 = pas/s^2; d'où la multiplication par PASPARMM)
#define ACCELSTOP (10*ACCEL)         // Décélération en cas d'arrêt d'urgence
#define VITESSE ((500/6)*PASPARMM)   // Vitesse maximale de montée de la table en mm/min (ici 500; c'est la premier nombre qu'il faut changer)
#define INVDIR false                 // Sens de rotation du moteur pas à pas (pour inverser, remplacer "false" par "true")

#define INTERVAL 200                 // Période entre chaque rafraîchissement de l'écran en ms (ici 5 Hz (1/200 ms))

// Définition des entrées/sorties
// (c'est ici qu'il faut changer pour utiliser le programme sur une autre carte Arduino)
#define Lig1Pin 12        // Pins concernant les lignes du clavier
#define Lig2Pin 11
#define Lig3Pin 10
#define Lig4Pin 9
#define Lig5Pin 8

#define Col1Pin 7         // Pins concernant les colonnes du clavier
#define Col2Pin 6
#define Col3Pin 5
#define Col4Pin 4

#define StepPin 3         // Pins concernant le moteur pas à pas
#define DirPin 13

#define buzzer_Pin A1      //pin du buzzer

#define RECV_PIN A0         // pin IR

#define HomePin 2         // Pin du contact "Home"
#define HomePinInt 0      // Numéro de l'interruption correspondant au contact Home

// Adresses des deux afficheurs
#define AFFSUP_ADRESSE 0x72
#define AFFINF_ADRESSE 0x71
#define AFFSUP 1
#define AFFINF 2
#define LUMINOSITE1 255   // Valeur de la luminosité de l'afficheur 1 de 0 à 255 (le plus lumineux)
#define LUMINOSITE2 255   // Valeur de la luminosité de l'afficheur 2 de 0 à 255 (le plus lumineux)

// Nombre de lignes et de colonnes du clavier
const byte LIG = 5;       // 5 lignes
const byte COL = 4;       // 4 colonnes

// Tableau contenant la répartition des touches du clavier numérique
char numTouches[LIG][COL] = {     // F = Fonctions
  {'F', 'I', 'C', 'H'},           // I = Incrément/absolu - C = Clear - H = Home
  { 1 , 2 , 3 , 'm'},             // m = monte en continu
  { 4 , 5 , 6 , 'd'},             // d = descend en continu
  { 7 , 8 , 9 , 'P'},             // P = stoP
  {'H', 0 , 'C', 'S'}             // S = Start
};                                //

// Tableau contenant la répartition des touches du clavier "fonctions" (secondes fonctions des touches)
char foncTouches[LIG][COL] = {    // F = Fonctions
  {'F', 'I', 'C', 'H'},           // I = Incrément/absolu - C = Clear - H = Home
  {'m', 'd', 'i', 'F'},           // d = descend en continu - m = monte en continu
  {'a', 'b', 'c', 'I'},           // i = monte par incrément
  {'e', 'f', 'g', 'S'},           // a,b,c = hauteurs programmables
  {'H', 0 , 'C', 'P'}             // e,f,g = incréments programmables
};                                // Les autres touches sont communes aux deux claviers

// Connections correspondantes aux lignes et colonnes du clavier
byte rowPins[LIG] = {Lig1Pin, Lig2Pin, Lig3Pin, Lig4Pin, Lig5Pin};
byte colPins[COL] = {Col1Pin, Col2Pin, Col3Pin, Col4Pin};

// Création de deux claviers, un avec les nombres et l'autre avec les fonctions
Keypad numClav = Keypad(makeKeymap(numTouches), rowPins, colPins, LIG, COL);
Keypad foncClav = Keypad(makeKeymap(foncTouches), rowPins, colPins, LIG, COL);

// Définition d'un moteur pas à pas (control par driver avec step/dir), ajout du Enable possible avec setEnablePin()
// Step: une transition bas->haut signifie un pas (changement possible avec setPinsInverted())
// Dir:  niveau logique haut signifie rotation sens horaire
AccelStepper moteur(1, StepPin, DirPin);

// Variables globales
long hConsigne = 0;                  // Hauteur entrée par l'utilisateur
long hActuelle = HHOME;              // Variable contenant en permanence la hauteur actuelle de la table
static byte kpadState;               // Etat de la touche (PRESSED, HOLD, RELEASED, repectivement appuyée, maintenue ( > 2s dans notre cas), relâchée)
boolean alpha = false;               // Commence avec le clavier numérique (true = clavier fonctions)
char key;                            // Touche appuyée
long precedentMillis = 0;            // Sauvegarde de la dernière fois que l'écran a été rafraîchit
boolean moteurTourne = false;        // Flag signalant lorsque le moteur tourne
boolean moteurStop = false;          // Flag signalant un arrêt d'urgence
boolean drapaff = false;             // Flag signalant l'affichage hConsigne lors de la reception caractere via ir
int irkey;                           // recupération caractere reçu recepteur IR
String txt_lcd1;                        // texte lcd-ligne 1
String txt_lcd2;                        // texte lcd-ligne 2
String txt_lcd3;                        // texte lcd-ligne 3
String txt_lcd4;                        // texte lcd-ligne 4


// initialisation recepteur infrarouge
IRrecv irrecv(RECV_PIN);
decode_results resultsIR;


//  Variables moteur pour initialisation home
int move_finished = 1; // Used to check if move is completed
long initial_homing = -1; // Used to Home Stepper at startup

// initialisation ECRAN LCD
 LiquidCrystal_I2C lcd(0x27, 20, 4); // set the LCD address to 0x27 for a 16 chars and 2 line display


// Fonction exécutée au démarrage -> Initialisation de tous les périphériques nécessaires (com. avec le PC, afficheurs, clavier,...)
void setup(void)
{
  Serial.begin(9600);                               // Moniteur série pour le débogage (liaison avec le PC)

  // Initialisation des afficheurs et effacement du contenu de ces derniers
  Wire.begin();                                     // Initialisation du bus I2C
  Wire.beginTransmission(AFFSUP_ADRESSE);           // Début de la communication avec le premier afficheur
  Wire.write(0x7A);                                 // Commande pour le contrôle de la luminosité
  Wire.write((byte) LUMINOSITE1);                   // Valeur de la luminosité de l'afficheur
  Wire.write('v');                                  // Effacement du contenu de l'afficheur (par sécurité)
  Wire.endTransmission();                           // Fin de la communication avec l'afficheur
  Wire.beginTransmission(AFFINF_ADRESSE);           // Début de la communication avec le second afficheur
  Wire.write(0x7A);                                 // Commande pour le contrôle de la luminosité
  Wire.write((byte) LUMINOSITE2);                   // Valeur de la luminosité de l'afficheur
  Wire.write('v');                                  // Effacement du contenu de l'afficheur (par sécurité)
  Wire.endTransmission();                           // Fin de la communication avec l'afficheur

  
  // Initialisation des événements relatifs au clavier
  numClav.addEventListener(keypadEvent_num);        // Ajout d'un événement pour le clavier numérique
  numClav.setHoldTime(2000);                        // Par défaut 1000 ms (touche appuyée), maintenant 2000 ms
  foncClav.addEventListener(keypadEvent_fonc);      // Ajout d'un événement pour le clavier fonction
  foncClav.setHoldTime(2000);                       // Par défaut 1000 ms (touche appuyée), maintenant 2000 ms

  // Initialisation du contact Home
  pinMode(HomePin, INPUT_PULLUP); // Patte du contact Home est initialisée en entrée
  delay(5);                    // Wait for EasyDriver wake up
  attachInterrupt(HomePinInt, stopMoteur, RISING);  // Interruption déclenchée par un appuie (passage de 1 à 0 -> falling) sur le contact home
  // Lorsque cet événement se produit, le programme saute à la fonction "stopMoteur"

  // initialisation du buzzer
  pinMode(buzzer_Pin, OUTPUT);
  digitalWrite(buzzer_Pin, 0); // état bas

  // initialisation recepteur infrarouge
  pinMode(RECV_PIN, INPUT);
  irrecv.enableIRIn(); // Start the receiver ir

// initialisation ECRAN LCD
  lcd.begin();
 
  // Affichage des valeurs à l'allumage
  affDec(moteur.currentPosition() / PASPARMM, AFFSUP);
  affDec(hConsigne, AFFINF);

  // Démarrage procédure initialisation  home  moteur  au lancement programme
    txt_lcd1 = " Debut programme"; txt_lcd2 = " === ATTENTION ==="; txt_lcd3 = " Mise a Home "; txt_lcd4 = " Table raboteuse";
    affLCD(txt_lcd1,txt_lcd2,txt_lcd3,txt_lcd4);   // APPEL AFFICHAGE LCD
  
  // Initialisation du moteur
    moteur.setMinPulseWidth(100);                     // Impulsions de 100 us
    moteur.setPinsInverted(INVDIR, false, false);     // Inversion possible de dir (step et inable restent à leur valeur par défaut)
    moteur.setCurrentPosition(0);  // Table non initialisée - zéro par défault
    moteur.setMaxSpeed(VITESSE);      // Initialisation vitesse moteur
    moteur.setAcceleration(ACCEL);  // Initialisation Acceleration moteur
    
  while (digitalRead(HomePin)) {  // Si contact Homepin non coupé => movement du moteur vers HHOME
    moteur.moveTo((HHOME + 100) * PASPARMM);  // Set the position to move to
    moteur.run();  // mise en mouvement du moteur
    delay(5);
  }
    moteur.setPinsInverted(true, false, false);     // Inversion  de dir (step et inable restent à leur valeur par défaut)
    moteur.setMaxSpeed(VITESSE / 10);      // Set Max Speed of Stepper (Slower to get better accuracy)
    moteur.setAcceleration(ACCEL / 10);  // Set Acceleration of Stepper
    delay(50);
  
  while (!digitalRead(HomePin)) { // Make the Stepper move CW until the switch is deactivated
    txt_lcd1 = " Démarrage programme"; txt_lcd2 = " === ATTENTION ==="; txt_lcd3 = " Libération du contact"; txt_lcd4 = " Table raboteuse";
    affLCD(txt_lcd1,txt_lcd2,txt_lcd3,txt_lcd4);   // APPEL AFFICHAGE LCD
    moteur.moveTo(moteur.currentPosition() - 12000);
    moteur.run();  
    delay(5);
  }
   moteur.setCurrentPosition(HHOME * PASPARMM); // Enregistrement de la position exacte de la table
   txt_lcd1 = "Demarrage programme"; txt_lcd2 = "Table raboteuse"; txt_lcd3 = "initialisee a "; txt_lcd4 =(String)hActuelle + " mm";
    affLCD(txt_lcd1,txt_lcd2,txt_lcd3,txt_lcd4);   // APPEL AFFICHAGE LCD
    delay(5);
 
  moteur.setMaxSpeed(VITESSE);      // Set Max Speed of Stepper (Faster for regular movements)
  moteur.setAcceleration(ACCEL);  // Set Acceleration of Stepper
  moteur.setPinsInverted(INVDIR, false, false);     // Inversion de dir (step et inable restent à leur valeur par défaut) pour revenir au sens d’origine.
  
   // Affichage des valeurs une fois table parcker
  affDec(moteur.currentPosition() / PASPARMM, AFFSUP);
  affDec(hConsigne, AFFINF);
}

// Boucle sans fin -> tourne s'exécute aussi longtemps que la carte est sous tension
void loop(void)
{
  if (irrecv.decode(&resultsIR))
{  
   irkey=NULL;
  
     if (resultsIR.value == 0xFF6897){irkey = 0;drapaff=true;} //0  
     if (resultsIR.value == 0xFF30CF){irkey = 1;drapaff=true;} //1
     if (resultsIR.value == 0xFF18E7){irkey = 2;drapaff=true;} //2
     if (resultsIR.value == 0xFF7A85){irkey = 3;drapaff=true;} //3    
     if (resultsIR.value == 0xFF10EF){irkey = 4;drapaff=true;} //4
     if (resultsIR.value == 0xFF38C7){irkey = 5;drapaff=true;} //5
     if (resultsIR.value == 0xFF5AA5){irkey = 6;drapaff=true;} //6
     if (resultsIR.value == 0xFF42BD){irkey = 7;drapaff=true;} //7
     if (resultsIR.value == 0xFF4AB5){irkey = 8;drapaff=true;} //8
     if (resultsIR.value == 0xFF52AD){irkey = 9;drapaff=true;} //9
 
    if (drapaff)hConsigne = (hConsigne * 10) + irkey;

if (resultsIR.value == 0xFF22DD) {hConsigne = 0;drapaff=true;}  // "Clear"
        
      
if (resultsIR.value == 0xFFC23D)
    {//' S' start
    // Pour éviter de dépasser les limites de la machine, si une des limites est dépassée, la valeur est limitée
          // et il faut confirmer (ou modifier) en réappuyant sur "Start"
          
           if (hConsigne < HMIN)hConsigne = HMIN;
            
            // En appuyant sur Start, le moteur se déplace jusqu'à la position voulue
            moteur.moveTo(hConsigne * PASPARMM);  // Position souhaitée
            moteurTourne = true;
       }
    
     if (resultsIR.value == 0xFF906F) stopMoteur();  // "Stop" - En appuyant sur Stop, le moteur s'arrête
        
    
     if (moteurTourne)buzzer_ok();
  
  
  
    if (drapaff)  
      {// if true then aff
        affconsigne();
       drapaff=false;
      }
      
    delay(800);
    irrecv.resume();
 }
  moteurRun();
  
}
// Evénement concernant le clavier numérique
void keypadEvent_num(KeypadEvent key) {
  kpadState = numClav.getState();
  swOnState(key);
}

// Evénement concernant le clavier fonctions
void keypadEvent_fonc(KeypadEvent key) {
  kpadState = foncClav.getState();
  swOnState(key);
}

// Fonction qui stoppe le moteur -> arrêt d'urgence (déclenchée par le contact Home)
void stopMoteur()
{
  if (moteurTourne)
  {
    moteur.setAcceleration(ACCELSTOP);      // Augmentation de l'accélération pour un freinage rapide
    moteur.stop();                          // Envoie de la position d'arrêt
    moteurStop = true;                      // Pour signaler à la boucle principale l'urgence...
  }
}

void swOnState(char key)
{
  switch (kpadState)
  {
    case PRESSED:
      {
        if (key == 'C')   // "Clear"
        {
          hConsigne = 0;
        }
        else if ((key >= 0) && (key <= 9))      // Chiffre
        {
          hConsigne = (hConsigne * 10) + key;
        }
        else if (key == 'S')   // "Start"
        {
          // Pour éviter de dépasser les limites de la machine, si une des limites est dépassée, la valeur est limitée
          // et il faut confirmer (ou modifier) en réappuyant sur "Start"
          if (hConsigne > HMAX)
            hConsigne = HMAX;
          else if (hConsigne < HMIN)
            hConsigne = HMIN;
          else
          {
            // En appuyant sur Start, le moteur se déplace jusqu'à la position voulue
            moteur.moveTo(hConsigne * PASPARMM);  // Position souhaitée
            moteurTourne = true;
          }
        }
        else if (key == 'P')   // "Stop"
        {
          stopMoteur();                                        // En appuyant sur Stop, le moteur s'arrête
        }
        else if (key == 'H')   // "Home"
        {
          hConsigne = (HHOME + 100);
          affDec(hConsigne, AFFINF);  // Affichage inférieur
          delay(50);

          if (digitalRead(HomePin) == HIGH)      // Le switch n'est pas encore appuyé
          {
            if (hActuelle < (HHOME - 100))
            {
              moteur.setMaxSpeed(VITESSE * 2);                           // Initialisation de la vitesse maximale et de l'accélération du moteur pas à pas
              moteur.setAcceleration(ACCEL * 2);
              moteur.moveTo((HHOME - 100)*PASPARMM);                           // Descend 10 mm plus haut que la position théorique pour ralentir
              moteurTourne = true;
              while (moteurTourne)
              {
                moteurRun();
                buzzer_ok();
              }
              moteurTourne = false;
            }
            hConsigne = (HHOME + 100);
            affDec(hConsigne, AFFINF);  // Affichage inférieur
            delay(50);
            digitalWrite(buzzer_Pin, 0); // état bas

            moteur.setMaxSpeed(VITESSE / 10);                       // Vitesse et accélération pour une meilleure précision
            moteur.setAcceleration(ACCEL / 10);
            moteur.moveTo((HHOME + 100)*PASPARMM);         // Descend 10 mm plus bas que la position théorique

            moteurTourne = true;
            while (moteurTourne) {
             moteurRun();
              buzzer_ok();
            }
          }

          delay(80);                                          // Pour éviter de réagir aux rebonts du contact

          moteur.setMaxSpeed(VITESSE / 10);                       // Vitesse et accélération pour une meilleure précision
          moteur.setAcceleration(ACCEL / 10);

          moteur.moveTo(moteur.currentPosition() - 12000);   // On remonte jusqu'à que le switch soit relâché (HIGH)

          detachInterrupt(HomePinInt);
          attachInterrupt(HomePinInt, stopMoteur, FALLING);  // Interruption déclenchée au relachement du contact, la table n'appuie plus sur le switch

          moteurTourne = true;

          while (moteurTourne) moteurRun();     // On envoie des pas jusqu'à que le switch soit relâché
          detachInterrupt(HomePinInt);
          attachInterrupt(HomePinInt, stopMoteur, RISING);  // Interruption déclenchée par un appuie (passage de 1 à 0 -> falling) sur le contact home

          moteur.setMaxSpeed(VITESSE);                           // Initialisation de la vitesse maximale et de l'accélération du moteur pas à pas
          moteur.setAcceleration(ACCEL);
          moteur.setCurrentPosition(HHOME * PASPARMM);    // garder la position réelle de la table detectée par le contact "home"

          affDec(round(moteur.currentPosition() / PASPARMM), AFFSUP);  // Affichage supérieur
        }
        break;
      }
    case HOLD:
      {
        if (key == 'F')   // Passage du clavier numérique aux fonctions
        {
          if (alpha) alpha = false;   // Inversion du clavier (choix du clavier)
          else alpha = true;
        }
        break;
      }
    case RELEASED:
      {
        break;
      }
    default: break;
  }

  affDec(hConsigne, AFFINF);  // Affichage inférieur
}

void affDec(unsigned int valeur, byte afficheur)
{
  boolean flagDec = false;          // Pour afficher les zéros...

  // Choix du bon afficheur en fonction du paramètre "afficheur"
  if (afficheur == AFFSUP) Wire.beginTransmission(AFFSUP_ADRESSE);
  else Wire.beginTransmission(AFFINF_ADRESSE);

  // Si le choix de l'afficheur est correct, mais la valeur à afficher trop grande, rien ne se passe...
  if (valeur < 10000)
  {
    Wire.write('v');                // Effacement de l'affichage
    Wire.write(0x77);               // Commande pour allumer les points décimaux
    Wire.write(0x04);               // Affichage du point décimal

    if (valeur > 999)
    {
      Wire.write(valeur / 1000);    // Envoie du digit de gauche
      if ((valeur %= 1000) < 100)   // Enlever le digit de gauche du nombre qu'on souhaite afficher
        flagDec = true;             // Si le digit suivant est un zéro, agiter le drapeau!
    }
    else Wire.write(0x10);          // Envoie d'un caractère vide (digit éteint)

    if ((valeur > 99) || flagDec)
    {
      Wire.write(valeur / 100);     // Prochain digit...
      if ((valeur %= 100) < 10)
        flagDec = true;
    }
    else Wire.write(0x10);          // Envoie d'un caractère vide (digit éteint)

    Wire.write(valeur / 10);
    valeur %= 10;

    Wire.write(valeur);             // Envoie du digit de droite
  }
  Wire.endTransmission();           // Fin de la transmission
}

void moteurRun()
{
  unsigned long actuelMillis = millis();        // Temps écoulé depuis l'allumage de la carte Arduino

  if (alpha) key = foncClav.getKey();          // En fonction du clavier sélectionné...
  else key = numClav.getKey();

  if (moteurTourne)
  {
    if (moteurStop)
    {
      moteur.runToPosition();
      moteurStop = false;
      moteur.setAcceleration(ACCEL);
    }

    hActuelle = round(moteur.currentPosition() / PASPARMM);      // Position actuelle du moteur (donc de la table)

    if (moteur.distanceToGo() != 0)
    {
      moteur.run();
    }
    else
    {
      moteurTourne = false;
      hConsigne = 0;
      affDec(hActuelle, AFFSUP);
      affDec(hConsigne, AFFINF);
    }

    // Rafraîchissement de l'écran seulement si le moteur tourne (autrement pas de variation de la hauteur actuelle!)
    if (actuelMillis - precedentMillis > INTERVAL)
    {
      precedentMillis = actuelMillis;          // Sauvegarde du temps du dernier rafraîchissement de l'écran
      affDec(hActuelle, AFFSUP);                 // Affichage de la hauteur actuelle
    }
  }
}
// evenement buzzer
void buzzer_ok()
{
  digitalWrite(buzzer_Pin, 0); // état bas
  delayMicroseconds(1136); //on attend 1136 milli-secondes
  digitalWrite(buzzer_Pin, 1); // état haut
  delayMicroseconds(1136); // on attend 1136 millisecondes
}

void affLCD(String txt_lcd1,String txt_lcd2,String txt_lcd3,String txt_lcd4)
{
  lcd.clear();
  lcd.backlight();
  // Envoi du message
  lcd.setCursor(0, 0);
  lcd.print(txt_lcd1);
  lcd.setCursor(0,1);
  lcd.print(txt_lcd2);
  lcd.setCursor(0, 2);
  lcd.print(txt_lcd3);
  lcd.setCursor(0, 3);
  lcd.print(txt_lcd4);
  delay (50);
}

void affconsigne()
{
 
  if (hConsigne > HHOME)
  {
    hConsigne = 00;
  }

  affDec(hConsigne, AFFINF);  // Affichage inférieur
}


Bonjour à tous !!!  

Et non, le projet n'a pas été abandonné !!!

Juste, comme pour beaucoup, quelques contretemps  qui m'ont bien ralenti !!!

Bref, cette fois-ci ça y est , elle tourne avec les 2 modifications souhaitées :

Moteur séparé pour l'avance du bois  et motorisation de la monté de la table sur la raboteuse .

Je n'ai pas encore eu le temps de peaufiner le programme de pilotage pour mon application mais ce n'est que partie remise.

La version actuelle est déjà fonctionnelle et il est temps car maintenant , j'ai réellement besoin de ma machine car elle doit reprendre du service : ma fille attend son premier enfant (et moi mon premier petit enfant !!!).

Je dois  fabriquer le lit de Babychou pour au plus tard début février … Et la, je n'ai pas le droit d'être en retard !!!

Voici un lien permettant de voir la "bête" finie  :

Encore une fois, merci pour l'aide que vous m'avez apportée lors du démarrage de ce projet.

Félicitations au futur grand-père!
Bon, c'est pas le tout mais il ne faudrait pas trainer pour la réalisation du lit du bébé...
Il ne te reste plus qu'à modifier le programme pour qu'il soit "à ta main", c'est l'avantage de l'Arduino.
Bravo et encore quelques années de services pour ta Sicar.