Aller au contenu

interface logicielle pc/arduino focuser

gerard33

Par gerard33
dans Les bricoleurs

 Partager

Messages recommandés

gerard33

gerard33

Posté
Posté

Salut :)

après 45 jours de marche, mon Arduino uno est enfin arrivé à pied par la Chine

j'ai fait le montage

 

7002-1457952178.jpg

 

avec le logiciel Arduino, j'ai injecté le code

   //**************************************************************
   //Commande de moteur pas-à-pas unipolaire 4 fils
       // Driver ULN2003 et moteur réducté au 1:64
   //
   //**************************************************************
   //Inclure la librairie stepper.h
    #include <Stepper.h>
    #define STEPS 100

                                                        //Créer une instance de la classe stepper
                                                      //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
     Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire

                                                      //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
     int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
     long temps =0;          //Durée de rotation pour un tour
                                              //************************************************************
                                                // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
                                             // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
                                                 // Démultiplication 1:64 pour ce moteur réducté mécaniquement
                                            //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
                                               //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour


   void setup()
    {               
     Serial.begin(9600);                            // 9600 bps
     Serial.println("Test de moteur pas a pas"); 
     }

   void loop()
     {
     Serial.println("Moteur en marche "); 
     //Faire tourner le moteur


     int received;                        // Variable servant à récupérer
                                      // les données reçues

 if (Serial.available()>0) {          // Si des données sont disponibles
   received = Serial.read();          // On les récupère
switch (received) {
   case 'a':
                                                                              // **********************  1/4 de tour avant

                                      // Si "a" est reçu
  small_stepper.setSpeed(50);        //Vitesse de 300 (max) réduire ce chiffre pour un mouvement plus lent
                                    //100 permet d'éavoir un couple élevé >300 le moteur vibre sans tourner

     Steps2Take  = 500;                                       // Une rotation complète avec 2048 pas (1 tour environ 4.5sec)
                                                              //Pour tourner à l'envers de 6 fois 1/30eme de tour, simplement multiplier Steps2Take par 6/30 et mettre un moins pour inverser le sens
                                                              // Exemple  Steps2Take  = -6*2048/30;
     temps = millis();
     small_stepper.step(Steps2Take);  //Ca tourne
                                                             // fin de a



   break;

                                                                               // **********************  1/2 de tour avant
      case 'c':
       //si la variable vaut x, effectuer une action

       // if(received == 'a') {              // Si "c" est reçu
  small_stepper.setSpeed(200); 

     Steps2Take  = 1000; 

     small_stepper.step(Steps2Take);  //Ca tourne


   break;
                                     // vitesse X0.5
                                                                             // **********************  1/8 de tour avant
      case 'e':

  small_stepper.setSpeed(50);

     Steps2Take  = 250; 

     small_stepper.step(Steps2Take);  //Ca tourne

   break;
                                                                          // ***************************** 1/4 tour arrière
   case 'b':
 small_stepper.setSpeed(50);

     Steps2Take  = -500;

     small_stepper.step(Steps2Take);  //Ca tourne

break;
                                                                             // *****************************1/2 tour arrière

  case 'd':
 small_stepper.setSpeed(200);

     Steps2Take  = -1000;  

     small_stepper.step(Steps2Take);          //Ca tourne

break;

                                                                            // **************************** 1/8 de tour arrière
  case 'f':
 small_stepper.setSpeed(50); 

     Steps2Take  = -250;  

     small_stepper.step(Steps2Take);  //Ca tourne

  }   

   } 

}

 

il me reste l'interface PC à réaliser

j'ai Lazarus (ou Delphi)

avez-vous des exemples de code?

  • Réponses 67
  • Créé
  • Dernière réponse

Les pipelettes du sujet

Les pipelettes du sujet

gerard33

gerard33

Posté
  • Auteur
Posté

gmail a pas voulu de ton message: virus

c'est sans doute l'aspect "code source" qui à déclenché le binz

pas grave

il va falloir que je creuse la partie C car, entre les séquences, le moteur semble alimenté

température 25..30°

les voyants C et D de l'UNL2003 restent allumés

gerard33

gerard33

Posté
  • Auteur
Posté (modifié)

Bon, alors voilàcoi: ça marche!

ma petite interface avec Lazarus

 

interface_foc.jpg

 

enfin presque

les ordres sont envoyés, reçus et exécutés mais le moteur reste tiède (+-30°) et deux voyants de l'ULN2003 (A et B ) restent allumés

 

mon_focuser2.jpg

 

j'utilise la librairie Stepper mais je ne trouve pas la fonction qui va bien

le code a changé

   //**************************************************************
   //Commande de moteur pas-à-pas unipolaire 4 fils
       // Driver ULN2003 et moteur réducté au 1:64
   //
   //**************************************************************
   //Inclure la librairie stepper.h
    #include <Stepper.h>
    #define STEPS 100

                                                        //Créer une instance de la classe stepper
                                                      //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
     Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire

                                                      //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
     int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
     int  nb = 0; 
    long temps =0;          //Durée de rotation pour un tour

                                              //************************************************************
                                                // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
                                             // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
                                                 // Démultiplication 1:64 pour ce moteur réducté mécaniquement
                                            //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
                                               //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour


   void setup()
    {               
     Serial.begin(9600);                            // 9600 bps
     Serial.println("Test de moteur pas a pas"); 
     }

   void loop()
     {
     Serial.println("Moteur en marche "); 
     //Faire tourner le moteur


     int received;                        // Variable servant à récupérer
                                      // les données reçues

 if (Serial.available()>0) {          // Si des données sont disponibles
   received = Serial.read();          // On les récupère
switch (received) {
   case 'a':
   small_stepper.setSpeed(20);
   break;
   case 'b':
   small_stepper.setSpeed(40);
   break;
   case 'c':
   small_stepper.setSpeed(60);
   break;
   case 'd':
   small_stepper.setSpeed(80);
   break;
   case 'e':
   small_stepper.setSpeed(100);
   break;
   case 'f':
   small_stepper.setSpeed(120);
   break;
   case 'g':
   small_stepper.setSpeed(140);
   break;
   case 'h':
   small_stepper.setSpeed(160);
   break;
   case 'i':
   small_stepper.setSpeed(180);
   break;
   case 'j':
   small_stepper.setSpeed(200);
   break;
   case 'k':     
   nb  = 50;                                       
   break;
   case 'l':     
   nb  = 206;                                       
   break;
   case 'm':     
   nb  = 512;                                       
   break;
   case 'n':     
   nb  = 1024;                                       
   break;
   case 'o':     
   nb  = 2048;                                       
   break;
   case 'p':
   Steps2Take  = nb; 
   small_stepper.step(Steps2Take);
   small_stepper.step(0);
   break;
   case 'q':
   Steps2Take  = nb*-1; 
   small_stepper.step(Steps2Take);            
   small_stepper.step(0);
break;
}   

   } 

}

Modifié par gerard33
Invité chibani

Invité chibani

Posté
Posté
... arrivé à pied par la Chine...

 

Travail très intéressant et belle contrepèterie classique au passage :mdr:

gerard33

gerard33

Posté
  • Auteur
Posté
Ca doit faire mal non ? :cheesy:

 

sais pas :D

toi qui bidouille beaucoup, tu n'as pas de solution pour mettre le moteur et les voyants à 0?

j'ai essayé ".step(0)" mais aucun résultat

Greg34

Greg34

Posté
Posté

Salut,

Me suis toujours pas occupé du focuser aussi :D

 

Pour le moteur à 0, je déclarerai une variable 'nbrtours' qui additionnerait le nombre de pas/tours et forcement pour revenir en arrière suffirait d'inverser.

Une fonction genre reset() avec une écriture de la variable dans un fichier pour reprendre la position du PO en cours avec le moteur à l'ouverture/fermeture du programme ?

gerard33

gerard33

Posté
  • Auteur
Posté
Salut,

Me suis toujours pas occupé du focuser aussi :D

 

Pour le moteur à 0, je déclarerai une variable 'nbrtours' qui additionnerait le nombre de pas/tours et forcement pour revenir en arrière suffirait d'inverser.

Une fonction genre reset() avec une écriture de la variable dans un fichier pour reprendre la position du PO en cours avec le moteur à l'ouverture/fermeture du programme ?

 

je ne parlais pas de la position, ça c'est facile, mais de la tension résiduelle qui reste sur le moteur

banjo

banjo

Posté
Posté

Toutes les sorties mettre à 0 en fin de commande?

Le maintien est intéressant pour eviter la roue libre sur les moteur non réductés.

Paul

Raphael_OD

Raphael_OD

Posté
Posté (modifié)

regarde la doc de ta librairie mais je ne suis pas sûr que tu puisses le faire.

Avec un eazydriver ou une carte polulu c'est une pin à mettre à 0 ou 1. L'uln c'est juste des darlingtons qui amplifient le signal...j'avoue de pas voir de suite comment faire ou alors un reset de ton arduino dans une de tes boucles ...ou toutes tes pins-->uln à low en fin de commande de pas.

Modifié par Raphael_OD
francois-du-57

francois-du-57

Posté
Posté
regarde la doc de ta librairie mais je ne suis pas sûr que tu puisses le faire.

Avec un eazydriver ou une carte polulu c'est une pin à mettre à 0 ou 1. L'uln c'est juste des darlingtons qui amplifient le signal...j'avoue de pas voir de suite comment faire ou alors un reset de ton arduino dans une de tes boucles ...ou toutes tes pins-->uln à low en fin de commande de pas.

 

je vais suivre votre poste avec attention car ce sujet m'intéresse fortement

francois-du-57

francois-du-57

Posté
Posté (modifié)

hello j'ai trouver sur le net plusieurs fichier concernant la map avec un arduino, je voudrais vous les faire partager mais je n'arrive pas a les mettre ici car il sont en zip.

 

https://onedrive.live.com/redir?resid=95CAF9128FB28495!50486&authkey=!AO3Oq6kRrFkKQ24&ithint=folder%2czip

 

voici le lien pour télécharger les fichiers si ca peut vous être utile ......

Modifié par francois-du-57
gerard33

gerard33

Posté
  • Auteur
Posté
regarde la doc de ta librairie mais je ne suis pas sûr que tu puisses le faire.

Avec un eazydriver ou une carte polulu c'est une pin à mettre à 0 ou 1. L'uln c'est juste des darlingtons qui amplifient le signal...j'avoue de pas voir de suite comment faire ou alors un reset de ton arduino dans une de tes boucles ...ou toutes tes pins-->uln à low en fin de commande de pas.

 

Oui, "pinMode(x,LOW);"

mais cette commande impose un "delay" de la durée commande précédente et impose avant la suivante une "pinMode(x,HIGH);"

c'est jouable mais lourdingue

gerard33

gerard33

Posté
  • Auteur
Posté (modifié)

ayé :)

j'ai refait le code de l'Arduino

   //**************************************************************
   //Commande de moteur pas-à-pas unipolaire 4 fils
       // Driver ULN2003 et moteur réducté au 1:64
   //
   //**************************************************************
   //Inclure la librairie stepper.h
    #include <Stepper.h>
    #define STEPS 100

                                                        //Créer une instance de la classe stepper
                                                      //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
     Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire

                                                      //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
     int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
     int  nb = 0; 
    long temps =0;          //Durée de rotation pour un tour

                                              //************************************************************
                                                // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
                                             // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
                                                 // Démultiplication 1:64 pour ce moteur réducté mécaniquement
                                            //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
                                               //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour

   void setup()
    {               
     Serial.begin(9600);                            // 9600 bps
//      Serial.println("Test de moteur pas a pas"); 
     }

   void loop()
     {
     int received;                        // Variable servant à récupérer
                                      // les données reçues

 if (Serial.available()>0) {          // Si des données sont disponibles
   received = Serial.read();          // On les récupère
switch (received) {
   case 'a':
   Serial.println("vitesse 20  "); 
   small_stepper.setSpeed(20);
   break;
   case 'b':
   Serial.println("vitesse 40  "); 
   small_stepper.setSpeed(40);
   break;
   case 'c':
   Serial.println("vitesse 60  "); 
   small_stepper.setSpeed(60);
   break;
   case 'd':
   Serial.println("vitesse 80  "); 
   small_stepper.setSpeed(80);
   break;
   case 'e':
   Serial.println("vitesse 100 "); 
   small_stepper.setSpeed(100);
   break;
   case 'f':
   Serial.println("vitesse 120 "); 
   small_stepper.setSpeed(120);
   break;
   case 'g':
   Serial.println("vitesse 140 "); 
   small_stepper.setSpeed(140);
   break;
   case 'h':
   Serial.println("vitesse 160 "); 
   small_stepper.setSpeed(160);
   break;
   case 'i':
   Serial.println("vitesse 180 "); 
   small_stepper.setSpeed(180);
   break;
   case 'j':
   Serial.println("vitesse 200 "); 
   small_stepper.setSpeed(200);
   break;
   case 'k':     
   nb  = 50;                                       
   Serial.println("20 pas      "); 
   break;
   case 'l':     
   nb  = 206;                                       
   Serial.println("206 pas     "); 
   break;
   case 'm':     
   nb  = 512;                                       
   Serial.println("512 pas     "); 
   break;
   case 'n':     
   nb  = 1024;                                       
   Serial.println("1024 pas    "); 
   break;
   case 'o':     
   nb  = 2048;                                       
   Serial.println("2048 pas    "); 
   break;
   case 'p':
   Steps2Take  = nb; 
   Serial.println("extra       "); 
   pinMode(8,HIGH);             
   pinMode(9,HIGH);             
   pinMode(10,HIGH);             
   pinMode(11,HIGH);             
small_stepper.step(Steps2Take);
     pinMode(8,LOW);             
     pinMode(9,LOW);             
     pinMode(10,LOW);             
     pinMode(11,LOW);             

   break;
   case 'q':
   Steps2Take  = nb*-1; 
   Serial.println("intra       "); 
   pinMode(8,HIGH);             
   pinMode(9,HIGH);             
   pinMode(10,HIGH);             
   pinMode(11,HIGH);             
   small_stepper.step(Steps2Take);
     pinMode(8,LOW);             
     pinMode(9,LOW);             
     pinMode(10,LOW);             
     pinMode(11,LOW);             
break;
}   

   } 

}

 

le moteur se met au repos comme je voulais :]

le Pascal pour ki veut

 

unit foc;

{$mode objfpc}{$H+}

interface

uses
 Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
 ComCtrls, ExtCtrls, Buttons, CPort, CPortCtl;

type

 { TForm1 }

 TForm1 = class(TForm)
   Button1: TButton;
   intra: TSpeedButton;
   l1: TButton;
   ComComboBox1: TComComboBox;
   c1: TComPort;
   b8: TSpeedButton;
   l2: TButton;
   Label1: TLabel;
   Label2: TLabel;
   extra: TSpeedButton;
   Memo: TMemo;
   tb: TTrackBar;
   tb1: TTrackBar;
   procedure b8Click(Sender: TObject);
   procedure Button1Click(Sender: TObject);
   procedure c1RxChar(Sender: TObject; Count: Integer);
   procedure ComComboBox1Change(Sender: TObject);
   procedure extraClick(Sender: TObject);
   procedure FormCreate(Sender: TObject);
   procedure intraClick(Sender: TObject);
   procedure l1Click(Sender: TObject);
   procedure l2Click(Sender: TObject);
   procedure tb1Change(Sender: TObject);
   procedure tbChange(Sender: TObject);
 private
   { private declarations }
 public
 end;

var
 Form1: TForm1;
 pre: string;
implementation

{$R *.lfm}

{ TForm1 }





procedure TForm1.FormCreate(Sender: TObject);
begin
 l1.Caption:='vitesse: 20';
 l2.caption:= 'nombre de pas: 20';
 b8.Caption:='Connecter';
 l1.Enabled:=c1.Connected;
 l2.Enabled:=c1.Connected;
 extra.Enabled:=c1.Connected;
 intra.Enabled:=c1.Connected;

end;

procedure TForm1.intraClick(Sender: TObject);
begin
 c1.WriteStr('q');

end;

procedure TForm1.l1Click(Sender: TObject);
var  x: integer;

begin
x:=tb.Position;
if x=20 then c1.WriteStr('a');
if x=40 then c1.WriteStr('b');
if x=60 then c1.WriteStr('c');
if x=80 then c1.WriteStr('d');
if x=100 then c1.WriteStr('e');
if x=120 then c1.WriteStr('f');
if x=140 then c1.WriteStr('g');
if x=160 then c1.WriteStr('h');
if x=180 then c1.WriteStr('i');
if x=200 then c1.WriteStr('j');

end;

procedure TForm1.l2Click(Sender: TObject);
var  x: integer;
begin
 x:=tb1.Position;
if x=20 then c1.WriteStr('k');
if x=40 then c1.WriteStr('l');
if x=60 then c1.WriteStr('m');
if x=80 then c1.WriteStr('n');
if x=100 then c1.WriteStr('o');

end;

procedure TForm1.tb1Change(Sender: TObject);
var   x,y: integer;
t :array [1..5] of integer = (50,256,512,1024,2048);
tm:string;
begin
 x:= tb1.Position;
  if x<=20 then x:=20;
  y:=x div 20;
  x:=y*20;
  tb1.Position:=x;
  tm:=inttostr(t[y]);
  l2.caption:= 'nombre de pas: '+ tm;
  if l2.Enabled then l2.SetFocus;
  l2.Click;
end;

procedure TForm1.tbChange(Sender: TObject);
var   x,y: integer;

begin
 x:= tb.Position;
   y:=x div 20;
 x:=y*20;
 tb.Position:=x;
 l1.caption:= 'vitesse: '+ inttostr(x);
 if l1.Enabled then   l1.SetFocus;
 l1.Click;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 c1.Connected:=false;
application.Terminate;
end ;

procedure TForm1.c1RxChar(Sender: TObject; Count: Integer);
Var Chaine:String;
begin
chaine:='';
 C1.ReadStr(Chaine,Count);
 if chaine<>pre then
 Memo.Lines.Text := Memo.Lines.Text + Chaine;
 memo.SelStart:=MaxInt;
 pre:= chaine;
end;

procedure TForm1.b8Click(Sender: TObject);
begin
 c1.Port:=comcombobox1.Items[comcombobox1.ItemIndex];
 c1.Connected:=true;
 if c1.Connected then begin
   b8.Color:=clLime;
   b8.Caption:='OK';
   l1.Enabled:=true;
   l2.Enabled:=true;
   intra.Enabled:=true;
   extra.Enabled:=true;
 end;
 end;

procedure TForm1.ComComboBox1Change(Sender: TObject);
begin
 c1.Connected:=true;
end;

procedure TForm1.extraClick(Sender: TObject);
begin
 c1.WriteStr('p');

end;

end.

me reste la partie mécanique

 

nb: le composant mémo ne sert à rien, c'était pour voir où cela coinçait

Modifié par gerard33
gerard33

gerard33

Posté
  • Auteur
Posté

Re :)

je sèche un peu sur les engrenages, poulies et courroies nécessaires à la transmission

l'axe du moteur mesure 5 mm Ø avec deux méplats opposées (soit 3 mm entre méplats)

z'avez des pistes? l'adresse miracle?

francois-du-57

francois-du-57

Posté
Posté

""""""""""" après 45 jours de marche, mon Arduino uno est enfin arrivé à pied par la Chine"""""""""""

hello je viens de tout recevoir en une semaine ,maintenant ya plus qu'a sauf qu'a force de lire plusieur poste je suis un peux perdue.....

francois-du-57

francois-du-57

Posté
Posté
Salut :)

après 45 jours de marche, mon Arduino uno est enfin arrivé à pied par la Chine

j'ai fait le montage

 

7002-1457952178.jpg

 

avec le logiciel Arduino, j'ai injecté le code

   //**************************************************************
   //Commande de moteur pas-à-pas unipolaire 4 fils
       // Driver ULN2003 et moteur réducté au 1:64
   //
   //**************************************************************
   //Inclure la librairie stepper.h
    #include <Stepper.h>
    #define STEPS 100

                                                        //Créer une instance de la classe stepper
                                                      //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
     Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire

                                                      //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
     int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
     long temps =0;          //Durée de rotation pour un tour
                                              //************************************************************
                                                // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
                                             // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
                                                 // Démultiplication 1:64 pour ce moteur réducté mécaniquement
                                            //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
                                               //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour


   void setup()
    {               
     Serial.begin(9600);                            // 9600 bps
     Serial.println("Test de moteur pas a pas"); 
     }

   void loop()
     {
     Serial.println("Moteur en marche "); 
     //Faire tourner le moteur


     int received;                        // Variable servant à récupérer
                                      // les données reçues

 if (Serial.available()>0) {          // Si des données sont disponibles
   received = Serial.read();          // On les récupère
switch (received) {
   case 'a':
                                                                              // **********************  1/4 de tour avant

                                      // Si "a" est reçu
  small_stepper.setSpeed(50);        //Vitesse de 300 (max) réduire ce chiffre pour un mouvement plus lent
                                    //100 permet d'éavoir un couple élevé >300 le moteur vibre sans tourner

     Steps2Take  = 500;                                       // Une rotation complète avec 2048 pas (1 tour environ 4.5sec)
                                                              //Pour tourner à l'envers de 6 fois 1/30eme de tour, simplement multiplier Steps2Take par 6/30 et mettre un moins pour inverser le sens
                                                              // Exemple  Steps2Take  = -6*2048/30;
     temps = millis();
     small_stepper.step(Steps2Take);  //Ca tourne
                                                             // fin de a



   break;

                                                                               // **********************  1/2 de tour avant
      case 'c':
       //si la variable vaut x, effectuer une action

       // if(received == 'a') {              // Si "c" est reçu
  small_stepper.setSpeed(200); 

     Steps2Take  = 1000; 

     small_stepper.step(Steps2Take);  //Ca tourne


   break;
                                     // vitesse X0.5
                                                                             // **********************  1/8 de tour avant
      case 'e':

  small_stepper.setSpeed(50);

     Steps2Take  = 250; 

     small_stepper.step(Steps2Take);  //Ca tourne

   break;
                                                                          // ***************************** 1/4 tour arrière
   case 'b':
 small_stepper.setSpeed(50);

     Steps2Take  = -500;

     small_stepper.step(Steps2Take);  //Ca tourne

break;
                                                                             // *****************************1/2 tour arrière

  case 'd':
 small_stepper.setSpeed(200);

     Steps2Take  = -1000;  

     small_stepper.step(Steps2Take);          //Ca tourne

break;

                                                                            // **************************** 1/8 de tour arrière
  case 'f':
 small_stepper.setSpeed(50); 

     Steps2Take  = -250;  

     small_stepper.step(Steps2Take);  //Ca tourne

  }   

   } 

}

 

il me reste l'interface PC à réaliser

j'ai Lazarus (ou Delphi)

avez-vous des exemples de code?

 

hello gerard en regardant ta photo je vois que sur le 5v tu as mis des fils ,mais je voudrais savoir ce qu'il alimente merci d'avance

gbs

gbs

Posté
Posté

@Francois du 57

Le 5v est là pour alimenter le moteur (à travers la carte UNL). Ce n'est pas l'alim de l'arduino qui peut fournir la "puissance" pour faire tourner le moteur.

 

 

D'ailleurs j'en profite pour poser une question qui me turlupine (sans jeu de mot hein ;-)

Vous alimenter comment vos montages ? Pour l'arduino qui ne bouffe rien, une bête pile 9V suffit, d'ailleurs l'étage d'alimentation des arduino accepte de 7 à 12v si je ne me trompe pas ou faut-il mieux se rapprocher du 5V nominal avec une alim dédiée ?

Et pour le moteur ? 12v c'est l'idéal ? Vous mettez quoi ?

 

Comme j'envisage essentiellement d'utiliser le montage avec un PC, l'USB peut alimenter l'arduino, par contre faudra une alim 12v pour la partie moteur.

 

 

Bref je me demandais ce que vous autres utilisez.

Gandalf

Gandalf

Posté
Posté

L'arduino possède un régulateur embarqué donc si on l'alimente en externe il faut utiliser une tension d'au moins 1.5V au dessus de 5V.

 

Le régulateur statique de l'arduino va dissiper d'autant plus que l'écart entre la tension d'alim et le 5V est important.

 

Au delà d'un certain écart je préfère abaisser la tension par une régulation externe. Précaution peut-être inutile...mais déformation professionnelle.

 

On peut panacher effectivement les alim: un 12V pour alimenter la partie puissance (moteur/driver) et l'arduino par l'USB. Si techniquement il n'y à pas de soucis, sur un plan utilisation ça condamne à utiliser son montage uniquement avec un PC. Donc on se prive de la possibilité de piloter son focuser en se passant du PC pour un usage autre que photo.

 

C'est dommage car utiliser le 12V moteur ne complique pas énormément les chose et ne fait pas grimper les couts.

 

JL

Rejoignez la conversation !

Vous pouvez répondre maintenant et vous inscrire plus tard. Si vous avez un compte, connectez-vous pour poster avec votre compte.

Invité
Répondre à ce sujet…

×   Collé en tant que texte enrichi.   Coller en tant que texte brut à la place

  Seulement 75 émoticônes maximum sont autorisées.

×   Votre lien a été automatiquement intégré.   Afficher plutôt comme un lien

×   Votre contenu précédent a été rétabli.   Vider l’éditeur

×   Vous ne pouvez pas directement coller des images. Envoyez-les depuis votre ordinateur ou insérez-les depuis une URL.

×
 Partager
Aller sur la liste des sujets

  • En ligne récemment   0 membre est en ligne

    • Aucun utilisateur enregistré regarde cette page.
×
×
  • Créer...

Information importante

Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer.