Modifier un code pour moteur pas à pas

Bonjour,
j'ai un soucis pour adapter un code "C" que qqun ma donner pour piloter un moteur pas a pas avec le driver uln2003 .
En effet se conne fonctionne bien mais le moteur et trop petit , du coup je veux mettre un moteur nema17 avec un driver TB6612.
Le problème c'est que je sais pas comment adapter ou modifier le code pour se nouveau driver.
Qui a une idée .
je vous met un copie de code"C"

PS : est-ce que on peut joindre un fichier au sujet

// -*- mode: C++ -*-

#include "rotator.h"


/*

1 2 3 4 5 6 7 8		1 2 3 4 5
: G H #				N/A			Go home. Return to home position
: C W #				N/A			Set direction to clockwise
: C C #				N/A			Set direction to counterclockwise
: S N X X X X #		N/A			Set new position in degree (0 -> 360)
: G D #				X X #		Return rotator direction. 01 or 02
: G P #				X X X X #	Return current position
: F G #				N/A			Move rotator to new position
: S P X X X X #		N/A			Set rotator position
: S R X X X X #		N/A			Set home reference position
: G R #				X X X X #	Return home reference position
: G V #				X X #		Return version number
*/


/*******************************************************************************
 * 
 * 
 * 
 * 
*******************************************************************************/
int main() 
{	
  	serialInit(UBBR);
	
	initTimerMillis();
	
	initHardware();
	
	// Init contacteur
	SET_OPTION( DIRCW );
	
	while(1)
	{
		readSerialLine();
		
		if(ISSET_OPTION( Option::FULLDATA ))
		{
			UNSET_OPTION( Option::FULLDATA );

			switch( _Y(cmd) )
			{
				//---------------------------------------------------
				// set position
				//---------------------------------------------------
				case _X( "sp" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						value = HexToInt(param, DigitHex::FOUR_DIGITS);
						
						if(value > 360)	value = 360;
						
						uint16_t v = iroundf((float)value * STEP_INC);
						
						targetPos = currentPos = v;
					}
					
					break;

				//---------------------------------------------------
				// stop motor
				//---------------------------------------------------
				case _X( "fq" ):
					UNSET_OPTION( Option::RUNNING );
					UNSET_OPTION( Option::GOHOME );

					break;
				
				//---------------------------------------------------
				// firmware version
				//---------------------------------------------------
				case _X( "gv" ):
					SEND2D(VERSION_FULL);
					
					break;

				//---------------------------------------------------
				// go home
				//---------------------------------------------------
				case _X( "gh" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						setDir( nearTo( homeReference ) ); // set the most short path to homereference
						SET_OPTION( Option::GOHOME );
					}
					
					break;
					
				//---------------------------------------------------
				// set direction to clockwise
				//---------------------------------------------------
				case _X( "cw" ):
					if( ! ISSET_OPTION( RUNNING ) && ! ISSET_OPTION( GOHOME ) )
					{
						setDir( DIRCW );
					}
					break;
					
				//---------------------------------------------------
				// set direction to counter clockwise
				//---------------------------------------------------
				case _X( "cc" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						setDir( Option::DIRCCW );
					}
					break;
				
				//---------------------------------------------------
				// set position to reach
				//---------------------------------------------------
				case _X( "sn" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						value = HexToInt( param, DigitHex::FOUR_DIGITS);
						if(value > 360) value = 360;
						
						setDir( nearTo( homeReference ) ); // set the most short path to homereference
						targetPos = iroundf((float)value * STEP_INC);
					}
					break;
					
				//---------------------------------------------------
				// turn on motor
				//---------------------------------------------------
				case _X( "fg" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						SET_OPTION( Option::RUNNING );
					}
					break;
					
				//---------------------------------------------------
				// get direction
				//---------------------------------------------------
				case _X( "gd" ):

					SENDING2( getDir() );

					break;

				//---------------------------------------------------
				// get position
				//---------------------------------------------------
				case _X( "gp" ):
				{
					uint16_t v  = iroundf((float)currentPos / STEP_INC);
					SENDING4( v );
					break;
				}	
					

				//---------------------------------------------------
				// 
				//---------------------------------------------------
				case _X( "sr" ):
					if( ! ISSET_OPTION( Option::RUNNING ) && ! ISSET_OPTION( Option::GOHOME ) )
					{
						value = HexToInt( param, DigitHex::FOUR_DIGITS);
						if(value > 360) value = 360;
					
						homeReference = iroundf((float)value * STEP_INC);
					}
					
					break;
					
				//---------------------------------------------------
				// 
				//---------------------------------------------------
				case _X( "gr" ):
					SENDING4(homeReference);
					
					break;
			}
		}
		
		currentTimer = getMillis();

		if(ISSET_OPTION( Option::GOHOME ) )
		{
			goHome();
		}
		
		if( ISSET_OPTION( Option::RUNNING )) 
		{
			if(stepperRunToPosition() == MotorStatus::REACH)
			{
				UNSET_OPTION( Option::RUNNING );
			}
			
			millisLastMove = currentTimer;
		}
		else
		{
			if( ! ISSET_OPTION (Option::GOHOME) && millisLastMove > 0 && (currentTimer - millisLastMove) >= STEPPER_DISABLEDELAY)
			{
				// disable stepper
				PORTB &= ~pins;

				millisLastMove = 0;
				
				targetPos = currentPos;
			}
		}	
	}
	
	return 0;
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
MotorStatus goHome()
{
	uint8_t v = (PINB & PIN_CONTACTOR);
	
	if(v == PIN_CONTACTOR)
	{
		UNSET_OPTION( Option::GOHOME );
		SET_OPTION( Option::DIRCW );
		
		currentPos = targetPos = homeReference;
		
		return MotorStatus::NO_MOVE;
	}
	
	return moveStepper();
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
void setDir(const Option dir)
{
	if( dir == Option::DIRCCW )
	{
		SET_OPTION( Option::DIRCCW );
		UNSET_OPTION( Option::DIRCW );
	}
	else
	{
		SET_OPTION( Option::DIRCW );
		UNSET_OPTION( Option::DIRCCW );
	}
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
Option getDir()
{
	if( ISSET_OPTION( Option::DIRCW ))
		return 1;
		
	if( ISSET_OPTION( Option::DIRCCW ))
		return 2;
		
	return 0;
}
/*******************************************************************************
*
*
* 
*******************************************************************************/
void serialInit(const uint16_t ubbr)
{
	UBRR0 = ubbr;
	
	UCSR0A = 0;
	
	// Enable receive et transmit
	UCSR0B = SETBIT(RXEN0) | SETBIT(TXEN0);
		
	// 8 bits character size, 2 bit stop, no parity
	UCSR0C = SETBIT(UCSZ00) | SETBIT(UCSZ01)/* | SETBIT(USBS0)*/;
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
void SerialTransmitString(register const uint8_t * s)
{
	/*
	* Clear TXC0 bit before transmit. See §19.5 of ATMEL 7810 document
	*/
	UNSETBIT(TXC0, UCSR0A);
	
	while(*s)
	{
		while(!SBA())
			;
			
		UDR0 = (*s++);
	}
}

/*******************************************************************************
* Use Timer0 (8 bits) for generate interrupt for the getMillis() function. 
* This code was generated by http://www.8bit-era.cz/arduino-timer-interrupts-calculator.html
* 64 is the prescaler value
* 1000 is the freq (hz)
* 16000000 is the F_CPU freq (16mhz)
********************************************************************************/
void initTimerMillis(void)
{
	// TIMER 0 for interrupt frequency 1000 Hz:
	cli(); // stop interrupts
	
	// set counter (TCNT0) register to 0
	TCNT0 = 0;

	// set compare match register for 1000 Hz increments
	OCR0A = 249; // = 16000000 / (64 * 1000) - 1 (must be <256)

	// turn on CTC mode
	TCCR0A = SETBIT(WGM01);

	// Set CS02, CS01 and CS00 bits for 64 prescaler
	TCCR0B = SETBIT(CS01) | SETBIT(CS00);

	// enable timer compare interrupt (see ISR(TIMER0_COMPA_vect))
	TIMSK0 |= SETBIT(OCIE0A);

	sei(); // allow interrupts
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
ISR(TIMER0_COMPA_vect)
{
  timer_millis++;  
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
uint64_t getMillis() 
{
	uint64_t _t;
	uint8_t oldsreg = SREG;
	
	cli();
	_t = timer_millis;
	SREG = oldsreg;
	
	return _t;
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
void initHardware()
{
	pins = MotorPin::PIN_1 | MotorPin::PIN_2 | MotorPin::PIN_3 | MotorPin::PIN_4;

	DDRB |= pins; // output mode
	
	// init contactor
	DDRB &= ~PIN_CONTACTOR; // input mode 
	DDRB |= PIN_CONTACTOR;	// pull-up 
}

/*******************************************************************************
 * Read command start by ':' and finished by '#'.
 * In packet take only the real command with her parameters 
 * without the ':' and '#'
 * 
 ******************************************************************************/
void readSerialLine()
{
	uint8_t car;
	
	while( SDA() ) // Check if Serial Data is Available
	{
		if( STA() )
			return;

		car = UDR0; // Read char from buffer
			
		switch( car )
		{
			//char starting string 
			case DDOT:
			{
				SET_OPTION( Option::ISDDOT );
				
				UNSET_OPTION( Option::DATA );
				UNSET_OPTION( Option::FULLDATA );

				idx = 0;

				break;
			}

			// char ending string 
			case HASH:
			{
				UNSET_OPTION( Option::ISDDOT );
				
				if(ISSET_OPTION( Option::DATA ))
				{
					SET_OPTION( Option::FULLDATA );
					UNSET_OPTION( Option::DATA );
				}
					
				break;
			}

			// other char
			default:
			{
				if(ISSET_OPTION( Option::ISDDOT ) && idx < MAXCOMMANDLEN)
				{
					// convert char to lower case
					car = _isAlpha(car) ? _toLower(car) : car;
					
					// Check if char is a command
					if(idx < CMDLEN)
					{
						cmd[idx] = car;
					} 
					else
					{
						param[idx - CMDLEN] = car;
					} 
					
					idx++;
					
					SET_OPTION( Option::DATA );
				}
				
				break;
			}
		}
	}
}

/*******************************************************************************
 * special implementation convert string hex number to int
 * only string with DigitHex digits
 * never begin with 0x 
 * array s[] is always in lower case
*******************************************************************************/
uint16_t HexToInt(register const uint8_t s[], register const DigitHex dh)
{
	uint8_t i, v;
	uint16_t r = 0;

	for(i = 0; i < dh; i++)
	{
		v = 0xff;

		// Check if only a hex lower case char (a-f)
		if(_isHexChar( s[ i ] ) )
		{
			v = (s[ i ] - 'a') + 10;	// 0xA = 10
		}
		else if(_isDigit( s[ i ] ) )
		{
			v = s[ i ] - '0';
		}

		if(v != 0xff) 
			r = (r << 4) + v;
	}

    return r;
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
MotorStatus stepperRunToPosition()
{

	uint16_t d = (targetPos >= currentPos) ? (targetPos - currentPos) : (currentPos - targetPos);
	
	// Position is reach ?
	if(d == 0)
	{
		return MotorStatus::REACH;
	}
	
	return moveStepper();
}

/*******************************************************************************
*
*
* 
*******************************************************************************/
MotorStatus moveStepper()
{
	uint64_t time = getMillis();
	static uint64_t lastTime = 0;
	
	if((time - lastTime) >= INTERVALTIME)
	{
		// Move only 1 step 
		currentPos += ( ISSET_OPTION(Option::DIRCW) ) ? 1 : -1;

		PORTB = *(seqHalf4Wire + ( currentPos & 7 ));

		lastTime = time;

		return MOVE;
	}
	
	return NO_MOVE;
}

Oh là Attention.

  1. Il existe deux types de moteur pas-à-pas : les unipolaires et les bipolaires qui ne se commandent pas de la même façon.
  2. "Nema 17", c'est comme "papier A4"ou "bouteille d'un litre" : cela donne les dimensions, mais pas ce qu'il y a dedans.

Le programme que l'on t'a donné est pour un unipolaire (uln2003).
Ce que tu dis sur le nouveau, laisse à penser que c'est un bipolaire -> il faut les références exactes : ce qui est important, c'est ce qu'il y a d'écrit après Nema 17.

Encore une fois voir le tuto d'Eskimon sur les moteurs.
https://eskimon.fr/

Voir aussi (mais après c'est copieux, il faut digérer le premier tuto) :

PS : j'ai modifié le titre pour qu'il soit plus représentatif de la question.
Les titres sont utilisés par le moteur de recherche du forum.

Bonsoir constant1462

Pourquoi un TB6612, un A4988 eut été mieux adapté.
Pour ce qui est du programme, si tu utilises un A4988, il faut repérer où les pas, la direction, et éventuellement l'activation du moteur pas à pas sont créés, pour commander les signaux, respectivement STEP, DIR et ENA. Je vais essayer, sans garantie :wink:, essaies, aussi, de ton côté.

Cordialement
jpbbricole

Le code que tu donnes n'est pas du code "Arduino". Il va y avoir besoin de faire quelques adaptations si tu veux compiler dans l'environnement Arduino.

On ne peut pas dire que le A4988 est mieux adapté si on ne connait pas le moteur. Si il s'agit d'un bipolaire 5V, le TB6612 permettra peut être le fonctionnement, mais on ne peut pas le piloter avec un A4988.

Il se trouve aussi que les signaux de commande pour un ULN2003 peuvent convenir à un TB6612, donc sans changer le programme qui tourne.

Le circuit idéal c'est parfois celui que l'on a dans le tiroir.

Parfaitement. Et avant de pouvoir dira quelque chose.

J'insiste :

Ce n'est parce qu'un modèle revient plus souvent que les autres que l'on est autorisé à généraliser.
Le nombre de pas par tour peut être différent, la tension de service peut être différente, le courant dans les bobines peut-être différent, le type même du moteur peut-être différent même si dans le cas présent il n'y a pas de doute sur le type pas à pas il existe des Nema 17 à moteur à balais.

alors il fonctionne avec , car j'ai trouvé un petit code d'essai pour voir .

Alors c'est justement se que je voudrais faire , adapter pour que cela fonctionne avec mon nema.
Le problème c'est que j'ai déjà de difficulté a comprendre le codage arduino quand c'est complexe , alors la avec du "C" autant dire que c'est incompréhensible pour moi.

alors je suis arrivé a compiler se code sans problème sur l'arduino.

au sujet du moteur c'est un NEMA17-03
Stepper Motor NEMA 17, 1,8 °, 1,2 A, 4,8 V

A bientôt
Christophe

Bonjour constant1462

Pourrais-tu mettre ce bout de code en ligne?

Que fait ce programme, à première vue il y a possibilité de lui envoyer des commandes.

Pourquoi ne pas réécrire un bout de programme qui fait comme si, avec l'aide d'une bibliothèque comme AccelStepper?

Cordialement
jpbbricole

hello
alors j'ai pris ce code pour essayer

#include <Stepper.h>

// change this to the number of steps on your motor
#define STEPS 200

// create an instance of the stepper class, specifying
// the number of steps of the motor and the pins it's
// attached to
Stepper stepper(STEPS, 4, 5, 6, 7);


void setup()
{
  Serial.begin(9600);
  Serial.println("Stepper test!");
  // set the speed of the motor to 30 RPMs
  stepper.setSpeed(60);
}

void loop()
{
  Serial.println("Forward");
  stepper.step(STEPS);
  Serial.println("Backward");
  stepper.step(-STEPS);
}

Par contre ,c est vrais ,j ai pas expliquer le principe.
Alors voilà, c'est pour pouvoir faire la rotation de champ d'une caméra pour l'astro.
En effet souvent la caméra n'est pas dans le bon sense pour capturer une galaxy où une autre cible.
Du coup il faut la tourner sur sont support.
Mais il existe des "rotateur" de caméra, c est que je suis entrain de fabriquer.
Du coup pour la commander je passe par le programme Kstars qui est sous Linux et je reprend une commande d'une extension qui existe et comme ça je peut commander le moteur nema pour tourner ma caméra avant de prendre les clichés.

Le programme en "C" du début le fais avec l'autre driver .
Dans la configuration il y a un switch de fin de course ou de référence, qui empêche que la caméra ne fasse plus que 1 tour, au début du lancement, le moteur peut aller en butée et revenir au milieu de sa cours.

Je sais pas si çà suffit comme explication

Par contre j ai un autre code et cette fois en langage arduino, mais je suis pas arrivé à le faire fonction, le truc c'est que c'est un code avec des onglet , je le mets en copie avev chaque onglet à la suite de suite.
A+

ArduinoRotator

#include <AccelStepper.h>

#define EnablePin 12
#define IN1 8
#define IN2 9
#define IN3 10
#define IN4 11
#define MotorInterfaceType 4

#include <EEPROM.h>

// EEPROM addresses
#define FOCUSER_POS_START 0
#define STEPPER_SPEED_ADD 3    

AccelStepper stepper(MotorInterfaceType, IN1, IN2, IN3, IN4);

// Global vars
boolean moving = false;
boolean hold = false;
boolean reversed;
boolean positionSaved;               // Flag indicates if stepper position was saved as new focuser position
boolean firstPrint = false;
boolean homeFound = true;
String inputString;                  // Serial input command string (terminated with \n)
boolean findingHome = false;

// *************  this value must be changed for each specific setup ***************************************
long maxSteps = 505960;  // **** steps needed for 2 complete revolutions.  prevent cord wrap.
long minStep = 0;
//  Must also enter this value/720 = steps/degree for first time ASCOM driver setup, click "properties 
// ******************************************************************************************************

int manualMoveStepSize = 50;  //higher number for faster manual moves
int findHomeStepSize = 100; //adjusts finding home speed

int buttonStateCW = HIGH;
int buttonStateCCW = HIGH;
boolean manualMoveCW = false;
boolean manualMoveCCW = false;

int HEState = 0;
long lastDebounceTime = 0;
long debounceDelay = 20;
void loop(){ 
  if (findingHome == true){
   findHome();
  } 

  // Stepper loop
  if (stepper.distanceToGo() == 0){
    if (hold == false){
      analogWrite(EnablePin, HIGH);
    }
  } else{
    analogWrite(EnablePin, 200);
  }
  if (stepper.distanceToGo() == 0 && !positionSaved){
    saveFocuserPos(stepper.currentPosition());
    positionSaved = true;
  }
  if(stepper.distanceToGo() != 0 && !firstPrint) { 
    firstPrint = true;
  }

  if(stepper.distanceToGo() != 0){
    moving = true;
  }else{
    moving = false;
  }
  stepper.run();
}

init

void setup() {
  // Initialize serial
  Serial.begin(57600);
  pinMode(EnablePin, OUTPUT);
  analogWrite(EnablePin, 0);

  // Initialize stepper motor
  stepper.setMaxSpeed(200);// 5000 works good,  use 500000 for confrom test1000 geared rotator10000 for geared stepper   200 for non-geared large stepper(500 max)  also may depend on what else is on loop()
  stepper.setAcceleration(1000);//1000 for geared rotator  10000 for geared stepper    1000 for non-geared large stepper
  stepper.setCurrentPosition(readFocuserPos());
  positionSaved = true;
  inputString = "";
  reverseDir(false);
}

Serial

// Interrupt serial event
void reverseDir(boolean rev){
    stepper.setPinsInverted(rev, false, false);  //for FSQ85(true, false, false) ---  for TSA 120should be (false, false, false)  (dir, step, enable) 
    //not reversed is std setup for tsa-120
    reversed = rev;
}
void Hold(boolean conthold){   
  hold = conthold;
}

void serialEvent(){
  while (Serial.available() > 0) {
    char inChar = (char)Serial.read();    
    if (inChar == ':' || inChar == '#'){
        if(inputString == "PV") inputString = "V"; // Version
        if(inputString == "GA") inputString = "B"; // bit 1 for switch 2
        if(inputString == "SH") inputString = "H"; // Starts the Find Home routine
        if(inputString == "GS") inputString = "Z"; // bit 2 for In limit switch
        if(inputString == "GT") inputString = "D"; // Sensor temperature in tenths of a degree, ex: 25°C = 250d
        if(inputString == "GV") inputString = "E"; // System voltage in tenths of a volt, ex 12.0V = 120d
        if(inputString == "PD") inputString = "D"; // Set the display brightness
        if(inputString == "PL") inputString = "D"; // Set the display sleep brightness
        if(inputString == "PF") inputString = "F"; // Gets the current focuser type. Ex: "2.5 NC#"
        if(inputString == "PS") inputString = "X"; // Gets the current focuser serial number
        if(inputString == "PU") inputString = "W"; // Gets a user defined field
        if(inputString == "PE") inputString = "C"; // Enables or disables the encoders
        if(inputString == "PR") inputString = "J"; // Issues a reset
        if(inputString == "Pt") inputString = "D"; // Adjusts the temperature offset
        if(inputString == "Pu") inputString = "Y"; // Sets the user text field
        serialCommand(inputString); 
        inputString = "";      
    } 
    else {
      inputString += inChar;
    }
  } 
}

void serialCommand(String command) {
  String param = command.substring(4); 
  String comando = command.substring(0,3);  //:2SN 12345678#  
  if(comando == "2GP") command = "G"; // Current position count, 8 digits, signed, 0 padding
  if(comando == "1GP") command = "K"; // DUMMY Current position 
  if(comando == "3GP") command = "K"; // DUMMY Current position   
  if(comando == "2GM") command = "Q"; // IS MOVING  
  if(comando == "2GN") command = "A"; // New (or Target) position count, 8 digits, signed, 0 padding
  if(comando == "2GR") command = "A"; // Motor step delay in 100 microsecond intervals
  if(comando == "2SQ") command = "S"; // Stops motor
  if(comando == "2SM") command = "A"; // Starts motor to move to the “NEW” focus position
  if(comando == "2SP") command = "P"; // Set the current position, 32 bit value, signed
  if(comando == "2SN") command = "M"; // Move to the New position count, 32 bit value, signed
  if(comando == "1SR") command = "A"; // Set the motor step rate in 100 microsecond intervals.
  if(comando == "2SR") command = "A"; // Set the motor step rate in 100 microsecond intervals.
  if(comando == "3SR") command = "A"; // Set the motor step rate in 100 microsecond intervals.

  //Serial.println(command);

  switch(command.charAt(0)) {
    case 'Q':
      if(moving == true){
        Serial.println("01#");
      } else {
        Serial.println("00#");
      }
    case 'Y':
      Serial.println("RC 8#");
      break;
    case 'K':
      Serial.println("30000#");
      break;
    case 'A':
      Serial.println("#");
      break;
    case 'B':
      Serial.println("00#");
      break;
    case 'Z':
      Serial.println("00#");
      break;
    case 'D':
      Serial.println("105#");      
      break;  
    case 'E':
      Serial.println("123#");      
      break;  
    case 'F':
      Serial.println("3.5 NC#");      
      break;  
    case 'X':
      Serial.println("20200516#");      
      break; 
    case 'W':
      Serial.println("StarPI Rotator#");      
      break;
    case 'G':   
      printCurrentPosition();
      break; 
    case 'P':    
      saveCurrentPos(stringToLong(param));
      break;
    case 'H':    // find home
      if(param = 2) findHome();  
      break;
    case 'M': 
      moveStepper(stringToLong(param), false);    
      break;
    case 'S':
       halt();
       break;
    case 'R':      
      int value;
      value = (stringToNumber(param));
      if (value == 0){
        reverseDir(false);
      } else {
        reverseDir(true);
      } 
      break;    
    case 'C':// continuos hold      
      int value2;
      value2 = (stringToNumber(param));      
      if (value2 == 0){
        Hold(false);
      } else{
        Hold(true);
      }
      Serial.println("#");
      break;
    case 'V':
      Serial.println("1.3#");
      break;
    case 'J': // Reset Arduino myFocuserPro2 controller
      software_Reboot();
      break; 
  }
}

void printCurrentPosition() {
  Serial.print("00"); 
  if(stepper.currentPosition()<100000) Serial.print("0");
  if(stepper.currentPosition()<10000) Serial.print("0");
  if(stepper.currentPosition()<1000) Serial.print("0");
  if(stepper.currentPosition()<100) Serial.print("0");
  if(stepper.currentPosition()<10) Serial.print("0");
  Serial.print(stepper.currentPosition());  
  Serial.println("#");
}

void moveStepper(long newPos, boolean manualMove) {
  Serial.println("#");
  if (findingHome == true){
    stepper.moveTo(newPos);
    return;
  }
      
  if(newPos != stepper.currentPosition()) {    
    if(newPos < minStep || newPos > maxSteps) {
      return;
    } else{
        stepper.moveTo(newPos);       
        positionSaved = false;
        firstPrint = false;
    }    
  }
}

void halt() {
  Serial.println("#");
  stepper.stop();  
}

void saveCurrentPos(long newPos) {
  Serial.println("#");
  if(newPos < minStep) newPos = minStep;
  stepper.setCurrentPosition(newPos);
  moveStepper(newPos, false);
  saveFocuserPos(newPos);
  positionSaved = true;
}

void findHome(){
  Serial.println("#");
  long newPos = maxSteps/4;  
  homeFound = true;
  findingHome = false;
  saveCurrentPos(newPos);    
}

Utilis

// reboot the Arduino
void software_Reboot(){
  // jump to the start of the program
  asm volatile ( "jmp 0");
}

void saveFocuserPos(long newPos) {
  writeLong(getSaveFocuserPosAddress() + 1, newPos);
}

long readFocuserPos() {
  return readLong(getReadFocuserPosAddress() + 1);
}

void writeWord(word address, word value) {
  EEPROM.write(address, lowByte(value)); 
  EEPROM.write(address + 1, highByte(value)); 
}

word readWord(word address) {
  return word(EEPROM.read(address + 1), EEPROM.read(address));   
}

long readLong(word address) {
  word lowWord = readWord(address);
  word highWord = readWord(address + 2);
  return lowWord + highWord * 65536;
}

void writeLong(word address, long value) {
  word lowWord = value % 65536;
  word highWord = value / 65536;
  writeWord(address, lowWord);
  writeWord(address + 2, highWord);
}

int stringToNumber(String thisString) {
  int i, value = 0, length;
  length = thisString.length();
  for(i=0; i<length; i++) {
    value = (10*value) + thisString.charAt(i)-(int) '0';     
  }
  return value;
}

long stringToLong(String thisString) {  
  boolean neg = false;
  if(thisString.indexOf("-") == 0) {
    thisString = thisString.substring(1); 
    neg = true; 
  }
  //Serial.println(thisString);
  long value = 0;
  int i, length;
  length = thisString.length();
  for(i=0; i<length; i++) {
    value = (10*value) + thisString.charAt(i)-(int) '0';     
  }
  if(neg == true) {
    value = maxSteps-value;
  }
  return value;
}

// Simple EEPROM wear leveling
int getSaveFocuserPosAddress() {
  for(byte x = 0; x < 20; x++) {
    int address = FOCUSER_POS_START + 5*x;
    if(EEPROM.read(address) == 0) {
      EEPROM.write(address, 0xFF);
      return address;
    }
  } 
  // Array is full, erase it and start from 0 - takes about 100ms
  for(byte x = 0; x < 20; x++){
    EEPROM.write(FOCUSER_POS_START + 5*x, 0);
    EEPROM.write(FOCUSER_POS_START, 0xFF);
    return FOCUSER_POS_START;
  }
}

int getReadFocuserPosAddress() {
  for(byte x = 0; x < 20; x++) {
    int address = FOCUSER_POS_START + 5*x;
    if(EEPROM.read(address) == 0) {
      return FOCUSER_POS_START + 5 * (x-1);
    }
  }
}

Bonjour constant1462

Si tu est plus à l'aise avec un prgramme dans un seul fichier, c'est facile à faire.

Tu est sur quel modèle d'Arduino?

Cordialement
jpbbricole

Bonjour Jpbbricole,
Alors pour le programme avec les onglets c'est pas mal , bon je sais pas comment faut faire , mais c'est presque plus propre.

Au sujet de la carte ,pour les essaies je fais avec une arduino uno, mais pour le projet final, cela sera une arduino nano , car je vais souder directement dessus et c'est aussi pour le gain de place.

A bientôt

Bonjour constant1462

Je te fais ça, en mettant les ports de commande du Nema comme dans le post #10.
Aurais-tu un lien vers le site où tu as trouvé ce code, c'est pour avoir la liste des commandes, ainsi que leur syntaxe, comme ça je peux mieux tester le programme.

A+
Cordialement
jpbbricole

Au sujet du code qui a les onglets , je sais pas si il est vraiment mieux que celui en "C", ou la, je suis sur qu'il fonctionne correctement.

je dis ça parce que justement je suis pas arrivé a l'essayer, et le pire, c'est que je sais pas si c'est le code ou les branchements entre le drive et le moteur.
Car la personne qui m'as donné le code (qu'il a lui aussi trouvé) ne la jamais vraiment essayé , le seule chose qui et bon, c'est que le programme Kstars arrive a se connecter a l'arduino mais rien de plus.
D'ailleurs je pense si il y a un switch de fin de cours , car je peut faire le "GO HOME", mais je n'est rien trouvé a ce sujet , mais si vous avez une possibilité pour que je puisse faire un essai , je suis preneur !! :wink:

A+