Moteur pas a pas et vis à bille

Bonsoir Jpbbricole,
Merci :grinning:
Amicalement

Bonjour Cavok
Quelques modifications et ajouts :

Les LED RGB :
de type WS2812 (Bibliothèque Adafruit_NeoPixel.h), il y en a 3, pour le moment. Le bus des LED est connecté sur la pin ledBusPin
Elles se commandent par :
LED1 :1 pour LED 1 en rouge
LED2 :2 pour LED 2 en vert
LED1 :0 pour LED 1 éteinte
Les couleurs vont de 0-7


enum signLedColorsIndex {ledColOff, ledColRed, ledColGreen, ledColBlue, ledColOrange, ledColYellow, ledColWithe, ledColNombre};

La LED 0 est réservé au système.
Au départ les 3 LED s’allument les unes après les autres, ensuite la LED 0 est verte si tout est OK ou rouge si le système est en mode initialisation.

La commande ALLOK :
Cette commande, à mettre en fin de macro ou série de macros, pour dire que tout c’est bien terminé et que les éléments sont dans une position telle qu'un nouveau cycle complet peut s'effectuer..
Attention, cette commande peut s’introduire manuellement, attention de le faire que si l’état du système le permet !

La commande HALL (Homing all) :
Fait démarrer la macro décrite dans la variable macHomingAll.
Cette macro doit contenir les commandes nécessaires à remettre le système dans un état qui permet son redémarrage sans problème.
Exemple MH1, MH2, V1:F10, V2:F10, ALLOK
A ajuster selon tes besoins mais doit absolument se terminer par la commande ALLOK .

Le bouton macHomingAllBtn :
Sur la pin macHomingAllBtnPin et contre GND.
Nécessite la bibliothèque JC_Button.h.
Une pression d’environ 2 secondes lance la commande HALL

Récupération suite à crash ou reset :
Le système est régi par la variable macStatus qui peut prendre les états :
macStatusNull, macStatusInit, macStatusRunning, macStatusAllOk
macStatusAllOk
(LED 0 verte) étant la position de repos où tout les moteurs ou vérins sont à leur position de départ, c’est-à-dire qu’une macro ou série de macro peut démarrer sans problème.
Chaque fois que macStatus change, macStatus est enregistré en EEPROM.
Dès qu’un moteur ou un vérin a bougé, macStatus devient macStatusRunning (LED 0 bleue).
Le seul moyen que macStatus redevienne macStatusAllOk, est une commande HALL ou ALLOK.
Ainsi, s’il y a crash ou reset pendant macStatusRunning (LED 0 bleue), c’est détecté au redémarrage de l’Arduino et macStatus devient macStatusInit (LED 0 rouge) et le système s’arrête. Les moyens de le redémarrer sont le bouton macHomingAllBtn ou les commandes HALL ou ALLOK.

Le programme :

/*
    Name:       ARDFR_Cavok_VisAbillesAutomate.ino
    Created:	04.12.2021
    Author:     jpbbricole
*/

#include <Adafruit_NeoPixel.h>     // Gestion des LED RGB Neopixel
#include <AccelStepper.h>     // https://www.arduino.cc/reference/en/libraries/accelstepper/
							  // /https://groups.google.com/g/accelstepper/c/i4XrfVpvuN8
                              // http://edge.rit.edu/edge/P14215/public/Software/P14215_Nick/Code/Arduino%20Library%20Folder/AccelStepper/doc/classAccelStepper.html

#include <JC_Button.h>     // https://github.com/JChristensen/JC_Button

#include <EEPROM.h>     // Pour sauvegarde des paramètres en mémoire EEPROM

#define programmeur     // Si programme pour utilisateur mettre //

#ifdef programmeur
#include "ARDFR_Cavok_VisAbillesAutomate_jpbbricole.h"
#else     //=========================== Paramètres propres à l'utilisateur, mettre //#define programmeur
#include "ARDFR_Cavok_VisAbillesAutomate_Cavok.h"
#endif

//-------------------------------------  Macro (mac)
struct macroDef
{
	String commandes;     // Commandes de la macro
	const int cmdMax = 5;     // Nombre maximum de commandes dans une macro
	int cmdNombre;     // Nombre de commandes dans la macro
};
macroDef mac;     // Création de l'objet macro

enum macStatusIndex  : byte  {macStatusNull, macStatusInit, macStatusRunning, macStatusAllOk};

byte macStatus = macStatusNull;
const int macStatusEeprom = 0;     // Adresse mémoire EEPROM

//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande

//------------------------------------- LED signalisation (led)
const int lebBrightMax = 20;                                                                                             // LED Luminosité maximum, se règle par menu
const int ledNombre = 3;

Adafruit_NeoPixel led = Adafruit_NeoPixel(ledNombre, ledBusPin, NEO_GRB + NEO_KHZ800);     // Création de l'objet Neopixel signLed
enum signLedColorsIndex {ledColOff, ledColRed, ledColGreen, ledColBlue, ledColOrange, ledColYellow, ledColWithe, ledColNombre};
uint32_t ledColors[ledColNombre];     // Valeurs RGB pour les couleurs (Tableau)

//------------------------------------- Bouton
Button macHomingAllBtn(macHomingAllBtnPin);       // Bouton pour homing all (HALL)

void setup()
{
	Serial.begin(115200);
	Serial.setTimeout(50);     // Pour fin des commandes depuis le moniteur
	delay(500);
	
	ledInitialisation();
	ledDisplay(0, ledColRed, 250);
	ledDisplay(1, ledColGreen, 250);
	ledDisplay(2, ledColBlue, 250);
	
	//--------------------------------- Initialisation des entrées/sorties
	pinMode(ledInfoPin, OUTPUT);     // Initialisation LED information
	macHomingAllBtn.begin();
	
	digitalWrite(ledInfoPin, !ledInfoEtatOn);     // Eteindre LED information
	
	//--------------------------------- Initialisation des contacts
	for (int v = 0; v < verNombre; v++)
	{
		for (int c = 0; c < 2; c++)
		{
			pinMode(verPin[v][c], OUTPUT);
			digitalWrite(verPin[v][c], !verCmdOnStat);     // Commande PWM à OFF
		}
	}
	
	//--------------------------------- Initialisation des contacts
	for (int c = 0; c < contNombre; c++)
	{
		pinMode(contPin[c], INPUT_PULLUP);
	}
 
    //--------------------------------- Initialisation mpap
	mpapInitialisation();
	
	macStatus = EEPROM.read(macStatusEeprom);     // Lecture du dernier etat des macro
	Serial.print(F("EEPROM = ")); Serial.println(macStatus);

	if (macStatus == macStatusRunning)     // S'il y a ru crash ou reset
	{
		macStatus = macStatusInit;
	}
	macStatusChange(macStatus);
}

void loop()
{
	for (byte m = 0; m < mpapNombre; m++)
	{
		mpap[m]->run();
	}
  //--------------------------------- Ecoute du port serie
  //serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
  // Pour Leonardo, Micro ou Yún
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		macExecute(cmdTexte);
	  
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
	
	//--------------------------------- Lecture du bouton homing all HALL
	macHomingAllBtn.read();
	
	if (macHomingAllBtn.pressedFor(2000))     // Si bouton pressé au moins 2 secondes
	{
		macExecute("HALL");     // Homing all
	}
}
//
//------------------------------------- Automate (auto)
void autoStart(int nbrFois)
{
	int macNbrFois = 2;

	for (int n = 0; n < nbrFois; n++)
	{
		macExecute("MMB1:5400, MMB1:-5400, MMB1:2700, V1:O5, MMB2:3000, V1:F5, MMB1:-2700, C1:1");
		Serial.print(F("\t\tFin boucle ")); Serial.println(n+1);
	}
	macExecute("TI:5, MMB2:10000, TI:5, MGB1:0, MGB2:0, ALLOK");
	Serial.println(F(">>>>>>>>> Fin programme >>>>>>>>>>"));
}

/*------------------------- Macro (mac) -------------------
	Traitement des macros pour l'automate
	macStatus doit être == macStatusAllOk
	sinon seules les commandes HALL ou ALLOK sont valides
'*---------------------------------------------------------
*/

void macExecute(String macro)
{
	macro.toUpperCase();
	macro.replace(" ", "");     // Supprimer les espaces

	if (macStatus == macStatusInit)     // Si automate pas arrêté en homing all
	{
		if (!(macro == "HALL" || macro == "ALLOK"))     // Les seules commandes en etat macStatusInit
		{
			Serial.print(F("\nMacro impossible : ")); Serial.println(macro);
			Serial.println(F("Reinitialiser l'automate HALL ou ALLOK"));
			return;
		}
	} 

	macro += ",";     // Ajout un séparateur en fin de macro
	Serial.print(F("Macro execution "));  Serial.println(macro);

	mac.cmdNombre = toolStringCountOccurence(macro, ",");
	while (macro.indexOf(",") > -1)     // Tant qu'il y a un séparateur
	{
		int sepPos = macro.indexOf(",");
		String macCommande = macro.substring(0, sepPos);     // Extraction de la première commande
		String macCommandParam = macCommande.substring(macCommande.indexOf(":")+1);     // Extraction du paramètre
		macCommande = macCommande.substring(0, macCommande.indexOf(":"));     // On garde que la commande
		
		if (macCommande > "")     // Si commande concise
		{
			if (macCommande.startsWith("X"))     // Commande répétition
			{
				int repeatNbr = macCommandParam.toInt();
				String repeatMacro = macro.substring(0, macro.indexOf(")")+2);
				macro.replace(repeatMacro, "");     // On supprime la macro répétition
				repeatMacro = repeatMacro.substring(repeatMacro.indexOf("(")+1, repeatMacro.indexOf(")"));

				Serial.print(F("\nRepetitions macro")); Serial.println(String(repeatNbr) + " X");

				for (int r = 0; r < repeatNbr; r ++)
				{
					Serial.print(F("> > > > Repetition ")); Serial.println(r+1);
					Serial.println(repeatMacro);
					macExecute(repeatMacro);
				}
			}
			else
			{
				macExecuteCommande(macCommande, macCommandParam.toFloat(), macCommandParam);
				macro = macro.substring(sepPos + 1);     // On supprime la commande executée
			}
		}
	}
}
/*
	LED1:1,X:3(MMB1:5400, MMB1:-5400, MMB1:2700, MGB1:0), led1:2, ti:3, led1:0, OK
	X:3(led1:3, TI:1, led2:2,ti:1, led1:0, ti=2,led2:0), led3:3,ti:1,led3:0
	MMN1:5000, MMN2:4000,MWR,TI:5,MGN1:0, MGN2:0
*/
void macExecuteCommande(String commande, long parametre, String parametreStr)
{
	int objectIndex = macCommandeExtractObjectIndex(commande)-1;     // Numéro de l'objet (MM1 MG2 C1 etc)
	
	if (commande.startsWith(F("AU")))     // Commande Automate
	{
		Serial.print(F("Automate ")); Serial.println("\t" + String(parametre));
		autoStart(parametre);
	}
	//--------------------------------- Commandes moteurs
	else if (commande.startsWith(F("MMB")))     // Commande moteur MOVE Bloquante
	{
		Serial.print(F("Commande moteur MOVE bloquant ")); Serial.println(commande + "\t" + String(parametre));
		mpapMove(objectIndex, parametre, moveModeBlocking);
	}
	else if (commande.startsWith(F("MGB")))     // Commande moteur GOTO Bloquante
	{
		Serial.print(F("Commande moteur GOTO bloquant ")); Serial.println(commande + "\t" + String(parametre));
		mpapGoto(objectIndex, parametre, moveModeBlocking);
	}
	else if (commande.startsWith(F("MMN")))     // Commande moteur MOVE Non Bloquante
	{
		Serial.print(F("Commande moteur MOVE non bloquant ")); Serial.println(commande + "\t" + String(parametre));
		mpapMove(objectIndex, parametre, moveModeNonBlocking);
	}
	else if (commande.startsWith(F("MGN")))     // Commande moteur GOTO  Non Bloquante
	{
		Serial.print(F("Commande moteur GOTO  non bloquant ")); Serial.println(commande + "\t" + String(parametre));
		mpapGoto(objectIndex, parametre, moveModeNonBlocking);
	}
	else if (commande.startsWith(F("MH")))     // Commande Homing
	{
		Serial.println(F("Commande moteur HOMING ")); //Serial.println(commande + "\t" + String(parametre));
		homingStart(objectIndex);
	}
	else if (commande.startsWith(F("MWR")))     // Attente fin de run() des MPAP
	{
		Serial.println(F("Atente fin mode run()"));
		mpapRunWaitEnd();
		Serial.println(F("FIN mode run()"));
	}
	//--------------------------------- Commandes vérins
	else if (commande.startsWith(F("V")))     // Commande Vérin
	{
		macStatusChange(macStatusRunning);
		
		String fonction = parametreStr.substring(0, 1);     // Extraire le temps de la fonction
		parametreStr.replace(fonction, "");
		int verCmdTimer = parametreStr.toInt();
		
		Serial.print(F("Commande verin ")); Serial.print(commande + "  "); Serial.print(String(verCmdTimer) + " sec.  ");
		
		if (fonction == "O")     // Si Ouvrir
		{
			Serial.println(F("Ouvrir"));
			digitalWrite(verPin[objectIndex][verPwmCmdLeft], verCmdOnStat);
			digitalWrite(verPin[objectIndex][verPwmCmdRight], !verCmdOnStat);
		}
		else if (fonction == "F")     // Si Fermer
		{
			Serial.println(F("Fermer"));
			digitalWrite(verPin[objectIndex][verPwmCmdLeft], !verCmdOnStat);
			digitalWrite(verPin[objectIndex][verPwmCmdRight], verCmdOnStat);
		}
		else if (fonction == "A")     // Si position arrêt
		{
			Serial.println(F("Arret"));
			digitalWrite(verPin[objectIndex][verPwmCmdLeft], !verCmdOnStat);     // Tout off
			digitalWrite(verPin[objectIndex][verPwmCmdRight], !verCmdOnStat);
		}
		if (verCmdTimer > 0)
		{
			delay(verCmdTimer * 1000UL);     // Temps de la fonction
			digitalWrite(verPin[objectIndex][verPwmCmdLeft], !verCmdOnStat);     // Tout off
			digitalWrite(verPin[objectIndex][verPwmCmdRight], !verCmdOnStat);
		}
	}
	//--------------------------------- Commandes Homing all
	else if (commande.startsWith(F("HALL")))     // LED RGB
	{
		ledDisplay(0, ledColBlue, 0);
		Serial.println(F("Homing ALL "));
		macStatusChange(macStatusRunning);     
		macExecute(macHomingAll);  
	}
	//--------------------------------- Commandes led   led1:3, V1:O5, led1:2,LED2:3, V1:F5, led2:2,ti:5,led1:7,led2:7
	else if (commande.startsWith(F("LED")))     // LED RGB
	{
		Serial.print(F("Commande LED "));  Serial.println(commande + "\t" + String(parametre));
		ledDisplay(objectIndex, parametre, 0);
	}
	//--------------------------------- Commandes Timer
	else if (commande.startsWith(F("TI")))     // Temporisation en secondes
	{
		Serial.print(F("Timer ")); Serial.println(parametre);
		delay(parametre * 1000UL);
	}
	//--------------------------------- Commandes Contact
	else if (commande.startsWith("C"))     // Commande Contact
	{
		Serial.print(F("Commande contact "));  Serial.println(commande + "\t" + String(parametre));
		if (objectIndex < 0 || objectIndex > contNombre-1)
		{
			macExecuteWarning(commande);
		}
		else
		{
			contAttente(objectIndex, parametre, 2000);
		}
	}
	//--------------------------------- Commandes Répétition macro X:3(led1:3, V1:O5, led1:2,LED2:3, V1:F5, led2:2,ti:5,led1:7,led2:7)
	else if (commande.startsWith(F("X")))     // LED RGB
	{
		Serial.print(F("Commande Repetition "));  Serial.println(commande + "\t" + String(parametre));
	}
	//--------------------------------- Si tout est OK
	else if (commande.startsWith(F("ALLOK")))
	{
		//macStatus = macStatusInit;     // Macro en mode initialisation
		Serial.println(F("Macro tout OK "));
		macStatusChange(macStatusAllOk);
	}
	else
	{
		Serial.print(F("Commande inconnue!!! ")); Serial.println(commande);
	}
}

//------------------------------------- Warning sur macro
void macExecuteWarning(String warningText)
{
	Serial.print(F("Ereur de commande >>> ")); Serial.println(warningText);
	
	unsigned long warnTimer = millis();
	
	while (millis() - warnTimer < 5000)     // Durée 5 secondes
	{
		digitalWrite(ledInfoPin, !digitalRead(ledInfoPin));     // Eteindre LED information
		delay(40);
	}
	digitalWrite(ledInfoPin, !ledInfoEtatOn);
}

//-------------------------------------Macro changement d'état
void macStatusChange(int newStatus)
{
	switch (newStatus)
	{
		case macStatusNull:     //
			ledDisplay(0, ledColWithe, 0);
			break;
		case macStatusInit:     //
			ledDisplay(0, ledColRed, 0);
			break;
		case macStatusRunning:     // Si macro est en exécution
			//macStatusChange(macStatusInit);
			ledDisplay(0, ledColBlue, 0);
			break;
		case macStatusAllOk:     // Si macro exécution complète§
			ledDisplay(0, ledColGreen, 0);
			break;
	}
	
	macStatus = newStatus;
	EEPROM.update(macStatusEeprom, macStatus);
}

/*-----------------------------------------------------------------------------
	Retourne l'index de l'objet en commande qui se trouve en fin de commande
	M2 retourne 2   MG3 retourne 3
'*-----------------------------------------------------------------------------
*/
int macCommandeExtractObjectIndex(String cmdWindex)     
{
	cmdWindex = cmdWindex.substring(cmdWindex.length() - 1);
	return cmdWindex.toInt();

}

//===================================== Moteur pas à pas (MPAP)
//------------------------------------- Move pas
void mpapMove(int mpapIndex, long moveSteps, int moveMode)
{
	Serial.println("MOVE M" + String(mpapIndex+1) + "\t" + String(moveSteps));
	mpapGoto(mpapIndex, mpap[mpapIndex]->currentPosition()+ moveSteps, moveMode);
}
//------------------------------------- Goto pas
void mpapGoto(int mpapIndex, long gotoSteps, int moveMode)
{
	macStatusChange(macStatusRunning);
	
	Serial.print("GOTO M" + String(mpapIndex+1) + "\t" + String(gotoSteps));
	Serial.print(F(" mode "));
	Serial.println((moveMode == moveModeBlocking) ?  " Bloquant" : " Non bloquant");

	mpap[mpapIndex]->enableOutputs();     // Activer le moteur
	
	if (moveMode == moveModeBlocking)
	{
		mpap[mpapIndex]->runToNewPosition(gotoSteps);
		(!mpapParam[mpapIndex].driverStayEnabled) ? mpap[mpapIndex]->disableOutputs() : mpap[mpapIndex]->enableOutputs();     // Désactiver éle moteur si nécessaire
	} 
	else
	{
		mpap[mpapIndex]->moveTo(gotoSteps);
	}

	Serial.println("\tOK");
}

/*--------------------------------------------------------------
	Attente de la fin des mouvements des MPAP en mode 
	moveTo() ou move()
'*--------------------------------------------------------------
*/
void mpapRunWaitEnd()
{
	long distanceRemaining = 0;
	
	while(1)
	{
		for (byte m = 0; m < mpapNombre; m++)
		{
			mpap[m]->run();
			distanceRemaining += abs(mpap[m]->distanceToGo());
		}

		if (distanceRemaining == 0)
		{break;} 
		else
		{distanceRemaining = 0;}
	}
	for (byte m = 0; m < mpapNombre; m++)
	{
		(!mpapParam[m].driverStayEnabled) ? mpap[m]->disableOutputs() : mpap[m]->enableOutputs();     // Désactiver les moteur si nécessaire
	}
}

void mpapInitialisation()
{
	for (byte m = 0; m < mpapNombre; m++)
	{
		mpap[m] = new AccelStepper(mpapParam[m].driverType, mpapParam[m].driverPin[driverPinStep],
		mpapParam[m].driverPin[driverPinDir]);
		mpap[m]->setMaxSpeed(mpapParam[m].maxSpeed);
		mpap[m]->setAcceleration(mpapParam[m].acceleration);
		mpap[m]->setPinsInverted(mpapParam[m].driverDirReverse, false, mpapParam[m].driverEnaReverse);
		mpap[m]->setEnablePin(mpapParam[m].driverPin[driverPinEnable]);
	
		(mpapParam[m].driverStayEnabled) ? mpap[m]->enableOutputs() : mpap[m]->disableOutputs();
		
		pinMode(mpapParam[m].homingPin, INPUT_PULLUP);
	}
}

//------------------------------------- Retour à la position de départ
void homingStart(int mpapIndex)

{
	macStatusChange(macStatusRunning);
	Serial.print(F("\nHOMING M")); Serial.println(mpapIndex +1);

	digitalWrite(ledInfoPin, ledInfoEtatOn);
	
	if (digitalRead(mpapParam[mpapIndex].homingPin) != mpapParam[mpapIndex].homingPinOnStatus)     // Si pas sur contact home
	{
		mpap[mpapIndex]->enableOutputs();     // Activer le moteur
		Serial.println(F("Retour <<"));

		mpap[mpapIndex]->moveTo(-mpapParam[mpapIndex].stepsMax*4);
		
		while (digitalRead(mpapParam[mpapIndex].homingPin) != mpapParam[mpapIndex].homingPinOnStatus)    // Tant que pas home
		{
			mpap[mpapIndex]->run();
		}
		
		mpap[mpapIndex]->stop();     // Stop aussitôt que possible
		(!mpapParam[mpapIndex].driverStayEnabled) ? mpap[mpapIndex]->disableOutputs() : mpap[mpapIndex]->enableOutputs();     // Désactiver éle moteur si nécessaire
	}

	mpap[mpapIndex]->setCurrentPosition(0);
	digitalWrite(ledInfoPin, !ledInfoEtatOn);
	
	Serial.println(F(">> Homin OK <<"));
}


//===================================== Contacts (cont)
//------------------------------------- Attente sur un contact
void contAttente(int contIndex, int contEtat, int contTimout)
{
	int contLecture = (contEtat == 0) ? !contOnStat : contOnStat;     // Définir l'état à lire
	
	while (digitalRead(contPin[contIndex]) != contLecture)
	{
		digitalWrite(ledInfoPin, !digitalRead(ledInfoPin));     // Eteindre LED information
		delay(125);
	}
	digitalWrite(ledInfoPin, !ledInfoEtatOn);
}

//===================================== LED de signalisation
void ledDisplay(int ledIndex, int colorIndex, int timeDispl)
{
	led.setPixelColor(ledIndex,ledColors[colorIndex]);
	led.show();
	
	if (timeDispl > 0)                                               // Si timeDispol > 0 millisec.
	{
		delay(timeDispl);
		led.setPixelColor(ledIndex,ledColors[ledColOff]);
		led.show();
	}
}

void ledInitialisation()
{
	ledColors[ledColRed] = led.Color(255, 0, 0);            // Définition des couleurs
	ledColors[ledColGreen] = led.Color(0, 255, 0);
	ledColors[ledColBlue] = led.Color(0, 0, 255);
	ledColors[ledColYellow] = led.Color(255, 255, 0);
	ledColors[ledColOrange] = led.Color(255, 165, 0);
	ledColors[ledColWithe] = led.Color(255, 255, 255);
	ledColors[ledColOff] = led.Color(0, 0, 0);
	
	led.begin();
	led.setBrightness(lebBrightMax);
}

/*-----------------------------------------------------------------------
  Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
  if (Serial.available())
  {
	  cmdTexte = Serial.readString();
	  cmdTexte.replace("\n", "");
	  cmdTexte.replace("\r", "");
	  cmdNouvelleRecue  = true;
  }
}

//=============================================================================
//------------------------------------- Divers outils
int toolStringCountOccurence(String text, String search)
{
	int retVal = text.length();
	text.replace(search, "");
	retVal = retVal - text.length();

	return retVal;
}

A ajouter en fin du fichier de paramètres personnels ARDFR_Cavok_VisAbillesAutomate_Cavok.h

//------------------------------------- LED signalisation (led)

const int ledBusPin = 12; // Connexion du bus

//------------------------------------- Macro homing all

const int macHomingAllBtnPin = 2; // Bouton pour homing all

String macHomingAll = "MH1, MH2, V1:F2, V2:F2, LED1:2, LED2:0, LED3:0,ALLOK";

Voilà, à toi de jouer, si tu as encore des propositions, n’hésite pas, essaies et surtout pose des questions.
Pour ce programme, envisages-tu une interface ?
Un lecteur de carte SD pour y mettre les macro ?
ou une interface en Processing ?
ou une interface avec Excel ?
Ou tout autre émulateur de terminal comme Terminal ?

Je n’ai pas le temps d’essayer tes macro du post #178, mais tu as les outils qu’il faut, n’oublies pas le X :6(,,,) pour les 6 cycles de M1 et M2 et, surtout, n’oublies pas la commande ALLOK ou HALL en toute fin.
Le mieux, pour développer et éviter de devoir compiler chaque fois, est d’écrire tes macro dans le bloc-notes, par exemple, et de les copier/coller dans la ligne de commande.

J’ai essayé (String &cmdWindex) mais ça causait des trucs bizarres, faute de temps je n’ai pas pu approfondir, mais je vais m’y mettre.

Cordialement

Jpbbricole

si vous parlez de

int macCommandeExtractObjectIndex(String cmdWindex)     
{
	cmdWindex = cmdWindex.substring(cmdWindex.length() - 1);
	return cmdWindex.toInt();

}

le cmdWindex au sein de la fonction est une copie, donc l'allocation cmdWindex = cmdWindex.substring(...) ne modifie pas la chaîne appelante. Si vous mettez un & vous allez modifier l'original

Bonsoir Jpbbricole,

Beau travail , il me faut maintenant le ‘digérer ‘

Je verrai ça demain, mais j’ai déjà essayé de le faire tourner,installer les librairies conseillées par toi ; et j’ai rencontré 3 fois un ‘exit status ‘ alors que ça ne devrait pas …

Pourrais tu me dire pourquoi ?

1


Exit status 1

macHomingAll was not declared in this scope

alors qu’il est déclaré dans ‘Cavokh’ ligne 66 :

String macHomingAll = "MH1, MH2, V1:F2, V2:F2, LED1:2, LED2:0, LED3:0,ALLOK";

Et si je copie/colle ça juste au dessus d :

macExecute(macHomingAll);

alors ça marche (normal…)


2

Pour

Button macHomingAllBtn(macHomingAllBtnPin);

Exit status 1

‘macHomingAllBtnPin’ was not declared in this scope

alors qu’il est déclaré dans ‘Cavokh’ ligne 64 :

const int macHomingAllBtnPin = 2; // Bouton pour homing all

Et si je copie/colle ça juste au dessus :

const int macHomingAllBtnPin = 2;

alors ça marche (normal…)

Même chose pour :

Adafruit_NeoPixel led = Adafruit_NeoPixel(ledNombre, ledBusPin, NEO_GRB + NEO_KHZ800); // Création de l'objet Neopixel signLed

‘ledBusPin’ was not declared in this scope

alors qu’il est déclaré dans ‘Cavokh’ ligne 60 :

const int ledBusPin = 12; // Connexion du bus

Et si je copie/colle ça juste au dessus :

const int ledBusPin = 12;

alors ça marche (normal…)

Pourquoi ça ne va pas chercher dans ‘Cavok.h ?)

Un grand merci à toi , car je vois qu’on avance…
:grinning:

Bonsoir Cavok

Milles excuses, j'ai oublié de mettre cette ligne en remarque!

//#define programmeur     // Si programme pour utilisateur mettre //

As-tu ajouté ces lignes comme indiqué ici?

A+
jpbbricole

J'ai rajouté la ligne en remarque
et cette fois j'ai :

  macStatusChange(macStatusRunning);
  
  Serial.print("GOTO M" + String(mpapIndex+1) + "\t" + String(gotoSteps));
  Serial.print(F(" mode "));
  Serial.println((moveMode == moveModeBlocking) ?  " Bloquant" : " Non bloquant");
'moveModeBlocking' was not declared in this scope

j'ai bien ajouté en fin du fichier de paramètres personnels ARDFR_Cavok_VisAbillesAutomate_Cavok.h,
comme ceci :
après:

unsigned long pauseInterMouvement = 5;     // Pause en secondes
const int stopPin = 11;     // Pin du contact d'arret des moteurs.
const int homingPin = 8;     // Pin du contact home.
const int homeOnStat = LOW;     // Etat du signal Home actif LOW = GND
const boolean homingOn = true;     // Pour active/désactiver le homing  

const int ledInfoPin = 13;     // Pin de la LED information
const  int ledInfoEtatOn = LOW;     // Etat pour allumer ledInfo


//------------------------------------- LED signalisation (led)

const int ledBusPin = 12; // Connexion du bus

//------------------------------------- Macro homing all

const int macHomingAllBtnPin = 2; // Bouton pour homing all

String macHomingAll = "MH1, MH2, V1:F2, V2:F2, LED1:2, LED2:0, LED3:0,ALLOK";

Merci de tes conseils

Bonsoir Cavok

La déclaration de cette variable se trouve au début de ton fichier de paramètres, ARDFR_Cavok_VisAbillesAutomate_Cavok.

Bonne nuit
jpbbricole

Bonjour Jpbbricole,
La compilation marche :slightly_smiling_face:

maintenant je vais étudier tout cela ,Merci à toi

Bonjour Cavok

Super, au boulot :wink:

Pour que je puisse réfléchir à une suite éventuelle, envisages-tu une interface ?
Un lecteur de carte SD pour y mettre les macro ?
ou une interface en Processing ?
ou une interface avec Excel ?
Ou tout autre émulateur de terminal comme Terminal ?

A+
Une bellej journée à toi, ici soleil mais très froid!
jpbbricole

Non, je n'envisage pas d'interface, en effet normalement une fois démarré, je ne devrais pas intervenir jusqu'à la fin . Je n'interviendrai que pour redémarrer le cycle une nouvelle fois si nécessaire ( c'est à dire plusieurs heures plus tard ou le lendemain.
Aussi c'est pour ça que je pense mettre les macros dans le dossier Cavok.h ,car les macros seront toujours les mêmes, une fois déterminées.
Mais peut-être que se serait mieux comme tu dis, je ne sais pas, et je ne vois pas comment faire...
A+
ici (Dordogne) il fait beau ,mais pas trop froid ...
Belle journée à toi aussi
Amicalement

petit soucis,
lorsque je démarre le programme (en simulation ) , j'appuie sur le bouton ' macHomingAllBtn',puis sur le contact ' homing' ,le programme démarre mais s’arrête après la macro écrite à la fin de Cavok.h :
Voici le moniteur série :

EEPROM = 3
Macro execution HALL,
Homing ALL 
Macro execution MH1,MH2,V1:F2,V2:F2,LED1:2,LED2:0,LED3:0,ALLOK,
Commande moteur HOMING 

HOMING M1
>> Homin OK <<
Commande moteur HOMING 

HOMING M2
>> Homin OK <<
Commande verin V1  2 sec.  Fermer
Commande verin V2  2 sec.  Fermer
Commande LED LED1	2
Commande LED LED2	0
Commande LED LED3	0
Macro tout OK 

et il ne passe pas aux autre macros de void autoStart

void autoStart(int nbrFois)
{
  int macNbrFois = 2;

  for (int n = 0; n < nbrFois; n++)
  {
    macExecute("MMB1:5400, MMB1:-5400, MMB1:2700, V1:O5, MMB2:3000, V1:F5, MMB1:-2700, C1:1");
    Serial.print(F("\t\tFin boucle ")); Serial.println(n+1);
  }
  macExecute("TI:5, MMB2:10000, TI:5, MGB1:0, MGB2:0, ALLOK");
  Serial.println(F(">>>>>>>>> Fin programme >>>>>>>>>>"));

Pourquoi ?
Merci

Bonjour Cavok

Il suffit d'ajouter AUT:6 en fin de macHomingAll
= "MH1, MH2, V1:F2, V2:F2, LED1:2, LED2:0, LED3:0,ALLOK , AU:6";
6 ou autre valeur étant le nombre de fois (nbrFois) que s'exécute, dans void autoStart(int nbrFois), la boucle:

	for (int n = 0; n < nbrFois; n++)
	{
		macExecute("MMB1:5400, MMB1:-5400, MMB1:2700, V1:O5, MMB2:3000, V1:F5, MMB1:-2700, C1:1");
		Serial.print(F("\t\tFin boucle ")); Serial.println(n+1);
	}

Entre parenthèse, la ligne int macNbrFois = 2; est un oubli et peut être supprimée.

A+
Cordialement
jpbbricole

Bonne soirée jpbbricole,
Merci, je continue
A+
Cordialement

Bonsoir jpbbricole,
J'ai fais selon tes conseils , et j'obtiens ce que je veux :grinning:
voici le moniteur série:

EEPROM = 3
EEPROM = 3
Macro execution HALL,
Homing ALL 
Macro execution MH1,MH3,MH2,MH3,V1:F2,LED1:2,LED2:0,LED3:0,ALLOK,AU:3,
Commande moteur HOMING 

HOMING M1
Retour <<
>> Homin OK <<
Commande moteur HOMING 

HOMING M3
>> Homin OK <<
Commande moteur HOMING 

HOMING M2
>> Homin OK <<
Commande moteur HOMING 

HOMING M3
>> Homin OK <<
Commande verin V1  2 sec.  Fermer
Commande LED LED1	2
Commande LED LED2	0
Commande LED LED3	0
Macro tout OK 
Automate 	3
Macro execution X:6(V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0),

Repetitions macro6 X
> > > > Repetition 1
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	3000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 2
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	6000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 3
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	9000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 4
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	12000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 5
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	15000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 6
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	18000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
		Fin boucle 1
Macro execution V1:F5,TI:5,MMB3:10000,TI:5,MMB2:-18000,TI:5,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB3	10000
MOVE M3	10000
GOTO M3	10000 mode  Bloquant
	OK
Timer 5
Commande moteur MOVE bloquant MMB2	-18000
MOVE M2	-18000
GOTO M2	0 mode  Bloquant
	OK
Timer 5
Macro execution X:6(V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0),

Repetitions macro6 X
> > > > Repetition 1
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	3000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 2
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	6000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 3
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	9000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 4
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	12000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 5
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	15000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 6
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	18000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
		Fin boucle 2
Macro execution V1:F5,TI:5,MMB3:10000,TI:5,MMB2:-18000,TI:5,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB3	10000
MOVE M3	10000
GOTO M3	20000 mode  Bloquant
	OK
Timer 5
Commande moteur MOVE bloquant MMB2	-18000
MOVE M2	-18000
GOTO M2	0 mode  Bloquant
	OK
Timer 5
Macro execution X:6(V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0),

Repetitions macro6 X
> > > > Repetition 1
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	3000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 2
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	6000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 3
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	9000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 4
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	12000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 5
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	15000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
> > > > Repetition 6
V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0
Macro execution V1:F5,TI:5,V1:O5,TI:5,MMB1:2700,MMB1:-5400,MMB1:5400,MMB1:-2700,TI:5,V1:F5,TI:5,MMB2:3000,TI:5,C1:0,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande verin V1  5 sec.  Ouvrir
Timer 5
Commande moteur MOVE bloquant MMB1	2700
MOVE M1	2700
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-5400
MOVE M1	-5400
GOTO M1	-2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	5400
MOVE M1	5400
GOTO M1	2700 mode  Bloquant
	OK
Commande moteur MOVE bloquant MMB1	-2700
MOVE M1	-2700
GOTO M1	0 mode  Bloquant
	OK
Timer 5
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB2	3000
MOVE M2	3000
GOTO M2	18000 mode  Bloquant
	OK
Timer 5
Commande contact C1	0
		Fin boucle 3
Macro execution V1:F5,TI:5,MMB3:10000,TI:5,MMB2:-18000,TI:5,
Commande verin V1  5 sec.  Fermer
Timer 5
Commande moteur MOVE bloquant MMB3	10000
MOVE M3	10000
GOTO M3	30000 mode  Bloquant
	OK
Timer 5
Commande moteur MOVE bloquant MMB2	-18000
MOVE M2	-18000
GOTO M2	0 mode  Bloquant
	OK
Timer 5
Macro execution V1:F5,TI:5,
Commande verin V1  5 sec.  Fermer
Timer 5
Macro execution TI:5,MGB1:0,MGB2:0,MGB3:0,ALLOK,
Timer 5
Commande moteur GOTO bloquant MGB1	0
GOTO M1	0 mode  Bloquant
	OK
Commande moteur GOTO bloquant MGB2	0
GOTO M2	0 mode  Bloquant
	OK
Commande moteur GOTO bloquant MGB3	0
GOTO M3	0 mode  Bloquant
	OK
Macro tout OK 
>>>>>>>>> Fin programme >>>>>>>>>>

j'ai mis le contact à 0 au lieu de 1, car j'en avais assez de toujours devoir appuyé sur l'interrupteur , mais à 1 ça fonctionne bien.
Reste à construire ça en grandeur nature
Si je suis arrivé, et que j'ai apris plein de choses , c'est grace à toi , à tes compétences, à ta patience ( car parfois j'ai été un peu dur de la 'comprenette', et surtout à ta gentillesse , et aussi à JML, et les autres intervenants du forum qui m'ont tous épaulé avec leur conseils judicieux
Donc un grand MERCI

Bonsoir Cavok

Super, je me réjouis de voire ça en grandeur nature!

Bonne soirée
jpbbricole.

Bonjour jpbbricole,
pas de problème, je commence à le construire avec une armature en bois ( c'est + facile de refaire des pièces si mal adaptées :worried: ) ,puis en métal pour définitif , et je te montre ça :slightly_smiling_face:
amicalement

Bonsoir,
voulant améliorer encore le système, j'aimerai ajouter un autre moteur (ça jpbricole m'a indiqué comment faire )
mais je voudrai que ce moteur pas a pas se mette en route, enfonçant une tige jusqu'à une distance mesuré par un capteur de distance , mesurant la distance jusqu'à une surface + une distance 'd' .
Et ça je ne vois pas trop comment articuler ce capteur de distance dans le programme.

j'ai à ma disposition un capteur HC-SR04 et un AHT20, Module de mesure de température et d'humidité
[Capteur numérique haute précision AHT10 AHT20, Module de mesure de température et d'humidité, Communication I2C, remplace SHT20 | AliExpress]

https://fr.aliexpress.com/item/32713522570.html?spm=a2g0o.productlist.0.0.469f2b20l1yyvA&algo_pvid=61c2e903-3df0-4861-a300-364f5e2068f7&algo_exp_id=61c2e903-3df0-4861-a300-364f5e2068f7-0&pdp_ext_f=%7B%22sku_id%22%3A%2210000002647706276%22%7D&pdp_pi=-1%3B1.72%3B-1%3BEUR+0.92%40salePrice%3BEUR%3Bsearch-mainSearch

Merci pour vos conseils

HC-SR04

Bonsoir Cavok

Quelle est la distanve mini et maxi?
Si cette fonction se fait toute seule, je veux dire, par là, qu'il ne se passe rien d'autre pendant ce temps, donc c'est une fonction bloquante, ça peut s'ajouter sans grand problème.

Je regarde ça demain.

PS: Que fait le capteur d'humidité?

A+
Cordialement
jpbbricole

La distance de la course de la vis où est fixé la tige , mini -maxi serait de 10 à 50 cms et la profondeur à laquelle s'enfonce la tige en dessous de la surface du grain serait de 1 à 10 cms mais réglée et fixe à chaque fois ,, ( la surface du grain n'étant pas horizontale et plate ,un peu comme un sol sur la terre, il y a des variations d'altitude .... mais pas énorme ) la précision doit être de 3 mm environ , mais doit suivre (en sous sol ) le dénivelé de la surface ,c'est pour ça que j'utiliserai un HC-SR04 + un moteur pas a pas
le capteur d'humidité c'est parce que j'ai vu que ça améliorait la mesure de la distance

Non, car en même temps, il y aura un autre moteur pas a pas ( moteur M2 ) qui fonctionnera , faisant avancer le module avec la tige en question pour lui faire courir une certaine distance , tout en la gardant à une profondeur fixe sous la surface
Bonne soirée à toi
Amicalement