Modification d'un programme arduino pour une regle de coupe plasma/oxy

mougp09
Compagnon
7 Décembre 2012
522
70
  • Auteur de la discussion
  • #1
Bonjour,

Je me suis bricolé il y a quelques temps une regle de coupe pour effectuer des coupes droite au plasma ou au chalumeau quand je suis en déplacement.

J'ai récupéré un programme sur internet pour piloter mon moteur pas à pas au travers d'un arduino et d'un driver de moteur pas à pas (pololu).

Mon système est très sommaire et j'aimerais lui apporter quelques améliorations.

Pour l'instant je branche l'alim, ce qui met tout sous tension et donc fait tourner le moteur. Pour l’arrêter je débranche ...

Je n'ai pas d'inversion de sens depuis l'arduino donc quand j'arrive au bout de la règle, soit je ramène le moteur à la main ou j’inverse une phase du moteur.

L'idée ce serait d'implémenter au programme :

- 2 fins de courses pour éviter la casse
- un petit switch pour aller d'un coté ou de l'autre
- un bouton qui lance la rotation du moteur quand on appuie dessus et qui l’arrête quand on rappuie

Voici le programme originale :

  1. /* Simple Stepper Motor Control Exaple Code
  2. *
  3. * by Dejan Nedelkovski, www.HowToMechatronics.com
  4. *
  5. */

  6. // Defines pins numbers
  7. const int stepPin = 3;
  8. const int dirPin = 4;

  9. int customDelay,customDelayMapped; // Defines variables

  10. void setup() {
  11. // Sets the two pins as Outputs
  12. pinMode(stepPin,OUTPUT);
  13. pinMode(dirPin,OUTPUT);

  14. digitalWrite(dirPin,HIGH); //Enables the motor to move in a particular direction
  15. }
  16. void loop() {
  17. customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function
  18. // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
  19. digitalWrite(stepPin, HIGH);
  20. delayMicroseconds(customDelayMapped);
  21. digitalWrite(stepPin, LOW);
  22. delayMicroseconds(customDelayMapped);
  23. }
  24. // Function for reading the Potentiometer
  25. int speedUp() {
  26. int customDelay = analogRead(A0); // Reads the potentiometer
  27. int newCustom = map(customDelay, 0, 1023, 300,4000); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)
  28. return newCustom;
  29. }

Et voilà ce que j'ai essayer de faire au moins pour inverser le sens ...

/* Simple Stepper Motor Control Exaple Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
*/

// Defines pins numbers
const int stepPin = 3;
const int dirPin = 4;
const byte rev = 5;
int customDelay,customDelayMapped; // Defines variables

void setup()

{
// Sets the two pins as Outputs
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
pinMode(rev,INPUT);
}

void loop(){

if (digitalRead(rev) == HIGH)
{
digitalWrite(dirPin, HIGH); //Enables the motor to move in a particular direction
}

else
{
digitalWrite(dirPin,LOW); //Changes the rotations direction
}


{
customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function
// Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
digitalWrite(stepPin, HIGH);
delayMicroseconds(customDelayMapped);
digitalWrite(stepPin, LOW);
delayMicroseconds(customDelayMapped);
}
// Function for reading the Potentiometer
int speedUp()
{
int customDelay = analogRead(A0); // Reads the potentiometer
int newCustom = map(customDelay, 0, 1023, 300,4000); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)
return newCustom;
}
}

Toute la partie mécanique, élec, câblage et lecture de programme ne me pose pas de problème mais pour crée ou modifier un programme j'ai beaucoup de mal.

Je cherche donc quelqu'un qui pourrait m'aider ou m'orienter.

Merci à vous.
 
mougp09
Compagnon
7 Décembre 2012
522
70
  • Auteur de la discussion
  • #5
C'est un pololu tout simple que ou j'utilise simplement STEP et DIR je n'utilise pas l'ENABLE et je suis en full pas.

Pour les switchs :

-Un poussoir marche/arrêt :
une pression sur le bouton fait tourner le moteur, si l'on rappuie sur le bouton le moteur s’arrête.

-Un interrupteur changement de direction :
Interrupteur ouvert le moteur tourne dans un sens,
interrupteur fermer le moteur tourne dans l'autre.

-Deux poussoir de fin de course (un de chaque coté de la règle) :
Si un poussoir est activé, arrêt du moteur et il ne doit pouvoir repartir qu'à l’opposé du fin de course qui à été activé.

Je ne sais pas trop si c'est simple ou pas à mettre en place ou même si c'est possible de cette façon, et n’hésiter pas si vous pensez à une autre solution que celle proposée.
 
Fichiers joints
mougp09
Compagnon
7 Décembre 2012
522
70
  • Auteur de la discussion
  • #7
A l'origine c'est un projet de petite cnc qui n'a jamais abouti, j'ai récupéré les axes X.

Les guidages ce sont des drylin de chez Igus (rail WS) fixés sur un elcom de 80x40.

Pour l'entrainement c'est une petite courroie qui serpente sur le pignon du moteur et des roulements.

Je vous mets quelques photos quand je rentre

Je vais aussi apporter quelques autres modifs, en particulier ajouter des électro-aimants, comme sur les perceuse magnétique, pour positionner facilement et solidement l’ensemble.

Et enfin faire quelque choses de propre et fini.

Au début j’utilisais 2 cornières comme guidage et quelques bout de ferraille pour le chariot avec pour entrainement une tige fileté et une visseuse pour la faire tourner. Ça marchait bien avec un peut moins de précision quand même.

L'avantage de cette règle électrique est d'avoir les mains libre pour lancer le plasma ou l’oxygène et contrôler la coupe.

C'est un outil très simple mais avec un peut d'imagination on peut quand même faire des choses sympas.
 
speedjf37
Compagnon
15 Octobre 2009
1 861
indre et loire
Bonsoir,

L'idée de base est bonne c'est juste un petit problème d'écriture

Version code légèrement restructuré.
Attention :
Respecter les { } qui encadrent les fonctions

Code vérifié en compilation , pas en réel !!!!

Code:
/* Simple Stepper Motor Control Example Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
*/

// Defines pins numbers
const int stepPin = 3;
const int dirPin = 4;
const int rev = 5;
int customDelayMapped; // Defines variables

void setup()
  {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT);
  pinMode(dirPin,OUTPUT);
  pinMode(rev,INPUT);
  }// end setup

void loop()
  {
  if (digitalRead(rev) == HIGH)
   {
   digitalWrite(dirPin, HIGH); //Enables the motor to move in a particular direction
   }
  else
   {
   digitalWrite(dirPin,LOW); //Changes the rotations direction
   }

  customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function
  // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
  } // end loop


// Function for reading the Potentiometer
int speedUp()
  {
  int customDelay = analogRead(A0); // Reads the potentiometer
  int newCustom = map(customDelay, 0, 1023, 300,4000); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)
  return newCustom;
  } //end speedUp

code modifié avec fin de course
Code:
/* Simple Stepper Motor Control Exaple Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
*/

// add sens select
// add fdc norm rev

// Defines pins numbers
const int stepPin = 3;
const int dirPin = 4;
const int rev = 5;
const int fdc_norm = 6;
const int fdc_rev = 7;

int customDelayMapped; // Defines variables

void setup()
  {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT);
  pinMode(dirPin,OUTPUT);
  pinMode(rev,INPUT);
  }// end setup

void loop()
  {
   if (digitalRead(rev) == HIGH)

   {

   digitalWrite(dirPin, HIGH); //Enables the motor to move in a particular direction

   if (digitalRead(fdc_rev ) == HIGH)
      {
      return;
      }
   }
  else
   {
   digitalWrite(dirPin,LOW); //Changes the rotations direction
   if (digitalRead(fdc_rev ) == HIGH)
       {
       return;
       }
   }



  customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function
  // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
  } // end loop

 
// Function for reading the Potentiometer
int speedUp()
  {
  int customDelay = analogRead(A0); // Reads the potentiometer
  int newCustom = map(customDelay, 0, 1023, 300,4000); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)
  return newCustom;
  } //end speedUp
JF
 
mougp09
Compagnon
7 Décembre 2012
522
70
Bonjour,

Merci a tous pour votre intérêt.

J'ai vraiment du mal avec la rigueur de ce type de programmation , je n'ai vraiment pas la logique du déroulement des instructions et je peine à trouver mes erreurs.

Du coup voila déjà quelques photo du système actuel.

Ce sont les guidages de l'axe X d'un ancien projet de CNC, le but va être de "rabouter" les 2 rails sur un grand profilé pour avoir une grande capacité de coupe. Actuellement 750mm de course.

20190503_105953.jpg


Avec l'entrainement et le système de tension de la courroie :

20190503_110001.jpg

20190503_110006.jpg


Je vais donc rajouter quelques options, 3 électroaimants avec un poussoir pour fixer plus facilement la règle (en commande).

Je commanderais en même temps que le profilé une équerre de ce type :

PIC_ANW_PRD_VBT_61559a__SALL__AIN__V2.jpg


Cette équerre réglable sera entre le bras de la règle de coupe et la fixation de la torche, elle est graduée en degré et ça devrait me permettre de régler plus facilement l'angle de la torche pour la coupe de chanfreins au chalumeau.

Enfin j'aimerais bien faire une petit système de réglage avec une vis ou une petit crémaillère pour ajuster la distance buse/pièce a couper.

Voilà le modifications mécanique qui devrait me donner un système fini et très simple à utiliser.


Pour la partie électronique, j'ai testé le programme et j'ai un problème. La logique est bonne, tous s'active comme il faut et ca marche.

Par contre j'ai un délais, par exemple pour l'inversion de sens, quand j'active l'entrée le moteur change tout de suite de sens, mais quand je désactive l'entré il met quelque secondes avant de repartir en sens inverse.

Idem pour les fin de course.

Je ne sais pas si c'est mon Arduino qui déconne ou si j'ai fait une erreur. encore une fois je suis perdu et je demande votre aide.

En tout cas merci déjà pour votre aide et votre implication.
 

Dernières discussions

Haut