Aller au contenu


***** Bienvenue dans le forum MikrOscOpia ! *****
Photo

Olympus BX50 motorisation du Z , arduino, stacking


  • Veuillez vous connecter pour répondre
70 réponses à ce sujet

#51 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 06 octobre 2018 - 12:59

Bonjour Jean Marie,

 

Tu as  raison, et le fait de compter en  décimal codé  binaire ne change rien .

Un convertisseur 10 bits (de résolution) va donner 1024 (2 ^ 10 ) valeurs, de 0 (0000000000) à 1023 (1111111111)

C'est pour cela qu'on ne décomposera pas 1024 en binaire en 10 bits (ce n'est tout simplement pas possible), puisque le convertisseur ne donnera jamais 1024 comme résultat maximum (10 bits obligent) mais 1023 . 

En Numérique le Zéro compte pour un élément , et on doit toujours compter à partir du zéro.

 

Amicalement.


  • 0

#52 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 06 octobre 2018 - 03:41

Oui, oui, le zero qui piege  !,le compteur bien affiche 1023 , tu avais raison Typhon, mais cela correspond bien a 1024 valeurs .


A suivre....

 

Avant de poster le programme dans sa totalité, une info sur l'alimentation .

Mon installation microscope est installé a demeure dans un camping car.

Je dispose de plusieurs sources de courants.
12V via un panneau solaire de 350W et d'une batterie auxiliaire gel de 100A.
220V via un convertisseur 500Watts connecté sur la batterie auxiliaire.

Le microscope est alimenté directement en 12 volts, eclairage led 12V.

L'Arduino uno et mega fonctionne en 5V , d'ou la necessité d'un transfo qui reduit la tension.

 

alim.jpg

 

la petite vis sur le boitier bleu permet d'ajuster la tension

 

  • Specifications:
  • Chip: XL4015
  • Input voltage range: 4-38V DC (Note: input voltage not exceeding 38V)
  • Output voltage range: 1.25-36V DC (adjustable)
  • Output current: 0-5A, recommended for use in 4.5A.
  • Output power: 75W
  • Working temperature: -40~+85℃
  • Operating frequency: 180KHz
  • Efficiency: 96% (max)
  • Short circuit protection: yes(limit current 8A).
  • Over temperature protection
  • Input reverse polarity protection: None (if required, high current diode in series with the input).
  • Size: 54x24mm/2.13x0.94"

 

j'ai grillé plusieurs alimentations 12v - 5v  avant de trouver celle-ci, 

 

le problème venait du panneau solaire et de son régulateur de charge, la tension varie de 12V au mini a 14.5V en charge plein soleil, naturellement les alim 12V grillaient !!

 

Cette alim est reglable de 4V a 36V et supporte 5A.


Modifié par michelflashman, 06 octobre 2018 - 03:59 .

  • 0

#53 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 06 octobre 2018 - 04:03

Ais-je oublié quelques choses ?

 

si oui, dites moi SVP mais je crois avoir fait le tour de mon installation automatisation du Z et prises de vues auto pour stacking.

 

dans un avenir proche, j'espère, divers modifications seront faites.

 

1 le relai remplacé par un transistor

2 suppression de la télécommande du Lumix G7

3 intégration dans une belle boite.

4 incorporation du réglage de la luminosité de la Led d’éclairage du microscope.

pour le moment, j'ai un boitier basic a découpage pas très satisfaisant , banding sur l'écran du Lumix en éclairage faible !!!

 

Avez-vous des suggestions a faire qui seraient les bienvenues ?


Modifié par michelflashman, 06 octobre 2018 - 04:13 .

  • 0

#54 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 06 octobre 2018 - 04:16

Le programme en entier

 

//****************************  carte Mega 2560****************************
 //programme de Motorisation du Z d'un microscope OLYMPUS BX 50
// et automatisation des prises de vus pour Stacking des photos
 //commande du pas microscope (Z) avec un écran shield tactile 2.8" Adafruit
 // marche arret avec l'ecran tactile et affichage de la preconisation de l'objectif
 // focus par joystick
 //*************************************************************************

//#include <SPI.h>
//#include <Wire.h>
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
#include <Adafruit_STMPE610.h>
#include <Stepper.h>

//coordonnées native ecran
#define TS_MINX 150
#define TS_MINY 130
#define TS_MAXX 3800
#define TS_MAXY 4000

// Pour le bouclier Adafruit, ce sont les paramètres par défaut.
#define STMPE_CS 8
Adafruit_STMPE610 ts = Adafruit_STMPE610(STMPE_CS);

// ecran broches a déclarer SPI, plus #9 & #10
#define TFT_CS 10
#define TFT_DC 9
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

// MOTEUR *************************************sur MEGA
#define STEPS 48 * 20                                                            //nombre de pas

#define IN1 34                                                                         //broches
#define IN2 38
#define IN3 36
#define IN4 32

Stepper moteur(STEPS, IN1,IN2,IN3,IN4) ;                            // pas et broches pour Mega

//MICROSCOPE***********************************
#define PASMINI -5                                                              //PAS MINIMUM DU Z
//RELAY **************************************
#define relaiPin 28                                                              //pin ou est connecté l'activation du relai
//bouton avec poussoir************************
// position et dimension du bouton rouge
#define FRAME_X 10                                                         //position X
#define FRAME_Y 160                                                        //positio y
#define FRAME_W 300                                                    //longueur
#define FRAME_H 60                                                       //hauteur

//**Joystick*******************************************************************************
const int VRx =A9;
const int SW =A8;

// Variables de lecture du joystick
int calX,  calSW, rawX, rawSW;

 int curseurX = 1;                                                           //position du curseur
 int    pasMicroscope = 0;                                              //pas pour Z du microscope
// boolean touchMA = false;                                          //bouton M/A
 boolean boutonRouge = true;
 boolean boutonBleu = false;
 int nbPhoto =0;                                                             //compteur de photos
 int pin = 21;                                                                  //pin pour le déclenchement de l'interruption
 //volatile boolean (etat);
 volatile int temps;
 
  String objectif[] {"100X plan N","40X UplanSapo","40X plan N", "20X plan N","10X plan N" } ;
 
void setup(void) {

//*******************************************test interuption***********************************************
    pinMode(pin, OUTPUT);
    attachInterrupt(digitalPinToInterrupt(pin),affiche, CHANGE);

  Serial.begin (9600);
 
  // Calibration de la valeur (0, 0) du joystick
calX = analogRead(VRx);
calSW = analogRead(SW);

    moteur.setSpeed ( 1 );                                                   // tours par minutes 9 max rpm/mn
    pinMode (relaiPin, OUTPUT );                                        //relay
 
             tft.begin();                                                            //ini ecran
             tft.setRotation(1);                                                 //ecran horizontal
             tft.fillScreen(ILI9341_BLACK);                             //fond d'ecran
             tft.setCursor(0, 0);
             tft.setTextColor(ILI9341_WHITE);
             tft.setTextSize(2);
          
   if (!ts.begin()) {
             tft.println("l'ecran tactile ne repond pas");
        }
      else {
             tft.println("Pret! ");
             tft.setCursor(5, 125);
             tft.setTextSize(2);
             tft.print("Nb de Photos :");            
           }        
 boutonCurseur();                                              //affichage de la barre boutton
 curseur();                                                          //affichage du poussoir
 
  tft.setCursor(100, 180);
  tft.setTextSize(2);
    tft.println("En attente..");
 
       marche();                                                      //affiche boutons Marche / Arret
       arret();         
}

void loop() {

  if (! ts.bufferEmpty ())                                      //test buffer touch
     {         
            TS_Point p = ts.getPoint ();
            p.x        = map(p.x, TS_MINY, TS_MAXY, 0, tft.height());
            p.y        = map(p.y, TS_MINX, TS_MAXX, 0, tft.width());
                int y      = tft.height() - p.x;
                int x      = p.y;
 
 
       if (( x > 12 ) && (x < 298))                          //zone du bouton pour pas du microscope pour x
       {
          if (( y > 165 ) && (y < 218))                      //zone du bouton pour pas du microscope pour y
           {
                   curseurX  = x ;
                   pasMicroscope = map(x,12,290,0,-100);                          //calcul du pas du Z microscope
                   boutonCurseur();
                   curseur();
              if (pasMicroscope < PASMINI )
              {
                       tft.setTextSize(3);
                       tft.setCursor(150, 176);            
                       tft.print(int(pasMicroscope));
                     choixObjectifs();         
                }
              else
              {
                      arretMoteur();
                      tft.setCursor(100, 180);
                      tft.setTextSize(2);
                      tft.println("attente..");
              }
            }
        }

   
        /////////////// bouton rouge ARRET
      if (! boutonRouge)
       {
            if (( x > 195 ) && (x < 290))                                        //zone du bouton ARRET
              {
                if (( y > 20 ) && (y < 70))
                  {
                        pinMode(pin, INPUT);
                        noInterrupts();
                        boutonRouge = true;
                        boutonBleu = false;
                        arret();
                        marche();
                        delay(10);
                        arretMoteur();
                   }
               }

         }
        ///////////// boutons bleu MARCHE

       if ( ! boutonBleu)
        {
            if (( x > 95 ) && (x < 190))                                        //zone du bouton MARCHE
              {
         if (( y > 20 ) && (y < 70))
          {  
                       boutonRouge = false;
                       boutonBleu = true;
                       marche();
                       arret();
                       nbPhoto = 0;
                       delay (10);
                       interrupts();
           }
         }          
    }
 }
 
      if (boutonBleu && pasMicroscope < PASMINI)
          {
                delay(10);                                                          //REPOS POUR VIBRATIONS §§
                clicPhoto();                                                        //prend la photo
                gestionMoteur();                                                //moteur ..
          }

  //       joystick();
}

 

//****************************************************FIN DU LOOP*************************

//

// fonctions perso


   /////////////affichage du bouton curseur
void boutonCurseur()
  {
     tft.fillRect(FRAME_X,FRAME_Y,FRAME_W,FRAME_H,ILI9341_RED);
  }
 
void curseur()
  {
     tft.fillRect(curseurX ,162,25,56,ILI9341_BLUE);
  }

void arret()
  {
     tft.fillRect(200,10,100,50,ILI9341_RED);
        if (boutonBleu)
          {
              tft.setTextSize(2);
              tft.setCursor(216, 26);           
              tft.print("ARRET");
              tft.fillRect(100,10,100,50,ILI9341_BLUE);
              tft.setCursor(114, 26);           
              tft.print(".....");
           }    
  }
        
void marche()
  {
    tft.fillRect(100,10,100,50,ILI9341_BLUE);
        if (boutonRouge)
        {
              tft.setTextSize(2);
              tft.setCursor(114, 26);           
              tft.print("MARCHE");
              tft.fillRect(200,10,100,50,ILI9341_RED);
              tft.setCursor(216, 26);           
              tft.print("......");
        }
  }

void arretMoteur()
  {
                moteur.step (0);                                           //arret moteur a voir
                digitalWrite(IN1, LOW);
                digitalWrite(IN2, LOW);
                digitalWrite(IN3, LOW);
                digitalWrite(IN4, LOW);
   }
    
void gestionMoteur()
  {
      Serial.println (pasMicroscope);
       moteur.step (pasMicroscope);                             //nombre de pas ,zero = arret !
  }

  void clicPhoto()
  {
        nbPhoto ++;           
         digitalWrite (relaiPin, HIGH);                             //contact relai = clic photo
           delay (50);                                                      // temps de contact du relai
         digitalWrite (relaiPin, LOW);                             //relache contact relai

            tft.setTextSize(2);
            tft.fillRect(180,115,60,30,ILI9341_BLACK);
            tft.setCursor(190, 125);
            tft.print(nbPhoto);       
  }

void affiche()                                  //INTERRUPTION*************************

  {

      int present = millis();                                      // Lecture du chronomètre
           if ( temps+300 < present )                        // Vérification du chronomètre
               {
                    Serial.println("interruption");       
            //      etat = !etat;                                     // Changement d'état
                  temps = present;
               }

          pinMode(pin, OUTPUT);
 }

void choixObjectifs()
{
  int local;
  if (pasMicroscope < PASMINI && pasMicroscope < -11)
  {
        Serial.println ("100X plan N");
        local = 0;
  }
  if (pasMicroscope < -11 && pasMicroscope > -20)
  {
        local = 1;
  }

   if (pasMicroscope < -20 && pasMicroscope > -40)
  {
        local = 2;
  }
 
   if (pasMicroscope < -40 && pasMicroscope > -90)
  {
        local =3;
  }
             tft.fillRect(65,65,250,50,ILI9341_BLACK);
             tft.setCursor(70, 85);
             tft.setTextSize(3);
             tft.print(objectif[local]);                                  //affiche objectif

             
  }
 
  void joystick()

  {
     // Mesure des valeurs en X et Y
rawX = int (analogRead(VRx)- calX);
rawSW = int(analogRead(SW));

Serial.println(rawX);

    if (rawX < -100 or rawX > 100)
        {
            moteur.step ( map(rawX,-500,500,-20,20) );
        }
      else
        {
                 moteur.step (0);                                                //arret moteur a voir
                digitalWrite(IN1, LOW);
                digitalWrite(IN2, LOW);
                digitalWrite(IN3, LOW);
                digitalWrite(IN4, LOW);

        }
   }


Modifié par michelflashman, 06 octobre 2018 - 04:26 .

  • 0

#55 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 06 octobre 2018 - 04:32

Si vous avez des questions ?

 

Exemple

 

etat = !etat;                                     // Changement d'état

 

le point d'exclamation en langage C remplace le NOT (n'est pas).

 

Cette fonction inverse l'état logique de la variable, si elle est a VRAI ((true), elle devient FAUSSE (false), si elle est FAUSSE (false) elle devient VRAI  (true)..


Modifié par michelflashman, 06 octobre 2018 - 04:38 .

  • 0

#56 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 07 octobre 2018 - 11:02

Bonjour michelflashman,

 

Bravo, ton programme m'a l'air bien ficelé.

Pour le tester chez moi, il me  faudrait acquérir un écran tactile,  mais ce n'est pas dans mes préoccupations du moment.

Mais tu dis:

 

#define STEPS 48 * 20  

48X20 cela fait 960.

Dans ces conditions, le moteur fait à peu près 1/2 tour. si on lui demande de faire 960 pas, soit 1920 pas par tour (au lieu de 2048)

La bibliothèque stepper.h (dont je ne connais pas le contenu ) demande comme premier argument dans la déclaration du moteur, le nombre de pas par tour.

La valeur exacte avec le driver utilisé est de 2048.

Dans ce cas le moteur fait un tour complet si on lui demande de faire 2048 pas et chaque pas correspond bien à l'angle de base du moteur. 360° / 2048 soit 0.17°

Dans ton cas, nous aurions des pas d'environ 0.18°

Tu me diras que cela ne fait pas beaucoup de différence, et pour ton stacking cela ne se voit pas, mais dans une application plus précise, compte tenu déjà des jeux dans le réducteur, cela ne convient pas.

 

Amicalement.


  • 0

#57 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 07 octobre 2018 - 01:54

Re,

 

Je dois faire mon autocritique.

Ce que j'ai écrit pourrait porter à penser que dans un cas, le moteur délivre des pas de 0.18° et dans l'autre de 0.17°, ce qui serait tout à fait ridiculement erroné.

Que ce soit avec une bonne programmation ou une mauvaise, les pas d'un moteur PAP ont le même angle.

Ce qui va changer, c'est que pour une requête donnée, par exemple 100 pas, dans un cas, le nombre de pas effectifs ne sera pas le même que dans l'autre.

 

960 pas, cela fait moins d'un demi tour . De plus, le moteur est lent et le clignotement des LED est nettement visible.

Si l'on demande 1920 pas, c'est à dire le double de ce qui est déclaré, voici le chemin parcouru par l'axe du réducteur.

 

 

SZE.jpg

Bien entendu en 2048 pas, il fait un tour complet.

 

 

 

Amicalement.


  • 0

#58 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 08 octobre 2018 - 02:14

Bonjour Tryphon

J'ai modifié le pas du moteur suite a des problemes de chauffe !! J'ai grillé un moteur , je pense que le stacking sollicite trop le moteur ! Les arrets et reprises trop frequentes a un rhytme soutenue .

C'est pourquoi j'ai cherché voir tatonner une solution .

Suite a differents tests, la reduction du pas ma donné satisfaction, avec les leds de la platine, il est facile de constater que le moteur tourne beaucoup moins vite.

J'ai aussi trouver la possibilité de stopper le moteur par la mise a LOW de toutes les pins du moteur, a l'arret, des leds restaient allumées.
moteur.step(0) arrete bien le moteur mais une tension reste dans certains enroulements du moteur.



moteur.step (0) //arret moteur a voir
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);



Je crois que ce moteur , d'un prix dérisoire est un peu faible . Mais compte tenu justement de son prix , tres facile a changer !!

Je ne sais si dans le temps , je garderais ce type de moteur pourtant bien pratique, avec son reducteur qui offre l'avantage de rendre tres difficile un retour en arriere a chaque arret ! Grace a la demultiplicarion.
Beaucoup d'autres moteurs pas a pas , a chaque arret, ont un petit retour en arriere, ils n'arrivent pas a garder la position ! Un probleme en stacking.

Amicalement

Michel

Modifié par michelflashman, 08 octobre 2018 - 02:35 .

  • 0

#59 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 08 octobre 2018 - 03:40

Bonjour Michel,

 

Normalement le moteur ne doit pas être alimenté directement par l' Arduino, mais par une alim indépendante plus puissante, sauf a vide pour des essais, mais pas en charge..

Ces moteurs sont "increvables" j'ai un exemplaire qui tourne 24/24 h ou presque. Ce qui va s'user en premier, c'est le réducteur.e bobine rencontrée.

Pour tester ta configuration, il faudrait  que tu me donnes le brochage de la carte driver.

(34 ,38, 36 ,32 du Mega vers IN1, IN2, IN3, IN4 de la carte driver, dans quel ordre ?)

Un moteur PAP garde toujours sa position. Dès qu'il a fait un pas, il y reste.C'est ce qui fait sa force.

Pour garder sa position, il faut donc qu'il soit alimenté. Si on coupe le courant brutalement pendant qu'il tourne, il va s'arrêter un peu n'importe où. 

Si on arrête le moteur dans une position donnée, par programme, (par exemple sur le pas 12374 ! ) il va y rester en mode stall, sans bouger. Normalement, il ne va pas chauffer outre mesure.

 

Amicalement.


  • 0

#60 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 08 octobre 2018 - 07:40

Bonjour Thyphon

Voici l'ordre qui est dans le programme


// MOTEUR *************************************sur MEGA
#define STEPS 48 * 20 //nombre de pas

#define IN1 34 //broches
#define IN2 38
#define IN3 36
#define IN4 32

Stepper moteur(STEPS, IN1,IN2,IN3,IN4) ; // pas et broches pour Mega

Le pas est décalé, au lieu d'avoir 32 34 36 38 , ce que je faisais au debut, j'ai trouvé sur le net, Youtube , U=RI , ce site ou Alexandre Paillous, explique tres bien le fonctionement de ce moteur, ce type de brochage décalé.




Pour l'arret du moteur, je le stop avec un pas 0 puis je coupe les alimentations sur les broches. Dans mon message precedent, je n'aurais pas du dire arret du moteur mais coupure des alimentations suite a l'arret du moteur.

Dans ce cas, le Z microscope ne bouge absolument pas

Modifié par michelflashman, 08 octobre 2018 - 07:57 .

  • 0

#61 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 09 octobre 2018 - 05:35

J'ai oublié,

Le moteur est alimenté avec l'alimentation presenté plus haut.
  • 0

#62 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 09 octobre 2018 - 07:42

Bonjour Michel, tous,

 

Ma liaison internet est down ! 

Bon, chaque fois qu'il pleut, c'est pareil.

On m'annonce qu'il y en a pour plusieurs jours...

Heureusement que j'avais un téléphone dans un fond de tiroir, mais le débit est en edge alors je ne serais pas long.

Je connais bien Alexaqndre Paillous et son  DevDuino, c'est quelqu'un de compétent.

J'avais vu sa vidéo parmi tant d'autres, mais je ne me rappelle plus les détails (je revisionnerai quand cela sera possible) mais j'en ai tellement vu d'autres qui disaient n'importe quoi...

Attendons.

Avec ta connexion au driver et la programmation de ta carte, j'ai trouvé des anomalies, on en reparlera aussi.

 

Je vais en profiter pour faire de l'usinage, il y a tant à faire.

 

Amicalement.


  • 0

#63 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 11 octobre 2018 - 07:17

Bonjour,

 

Toujours pas vu de service de dépannage ! C'est aujourd'hui la date limite qui avait été fixée.

C'est beau la France !

Veuillez m'excuser pour mon absence forcée.

 

Amicalement.

 

10 mn quand même pour envoyer ce court message !


  • 0

#64 jmp76

jmp76

    Nucléotide

  • Membre confirmé
  • 23 messages

Posté 11 octobre 2018 - 02:10

Bonjour,

 

 

la valeur zéro est la première valeur qui correspond à l'absence de signal mais dont on est obligé de tenir compte.

Pour être plus précis: la valeur zéro dans un système de codage 10 bits correspond à 00 0000 0000.  (ou $000 en hexa)

Cela correspond à 10 signaux "inactifs" (états bas en logique positive). Mais ces signaux existent bien. On ne peut pas parler d'absence de signal.

 

[et maintenant pour les experts]

En électronique un signal inexistant  (dû à une coupure est souvent actif haut,) est donc un 1 en logique bipolaire) et indéterminé (fluctuant au moindre électron, entre le 0 et 1  voire en latch-up destructif)

Pour ces raisons les signaux de commandes sont toujours actifs bas (il seront donc inactifs si coupure de câble) et les entrées doivent comporter des pull-ups (résistances vers l'alim)

 

Cordialement


  • 0

#65 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 11 octobre 2018 - 07:02

Bonjour tous,

 

Me voilà de retour .

 

Je viens de voir en premier la vidéo.

Comme d'habitude, il y a des erreurs importantes.

 

Première erreur, ce que je croyais au début.: le moteur ne fait pas 48 pas comme il est écrit dans  la dénomination du moteur.

En fait le nombre de pas dépend de la manière dont on programme le moteur.

Si on prend la séquence PAS1,PAS3,PAS2,PAS4

 

On a les données suivantes.

48 pas moteur = 48 X 64 = 3072 pas au niveau du réducteur : le moteur fait 1 tour 1/2 de réducteur.

32 pas moteur = 32 X 64 = 2048 pas au niveau du réducteur : le moteur fait 1 tour de réducteur.

48 pas moteur = 48 X 20 = 960  : le moteur ne fait même pas 1/2 tour de réducteur. Cela ne correspond à rien de connu ou de classique.
 

64 étant le rapport de réduction du réducteur, il faut donc multiplier le nombre de pas moteur par 64 pour avoir le nombre de tours en sortie de réducteur.(20 n'est pas un rapport de réduction valide)

(Comme j'ai déjà dit, la carte utilisée avec le moteur ne gère pas les demi pas.)

 

 

Deux choses à savoir:

  • 1- Si le nombre de pas moteur multiplié par le rapport de réduction du réducteur ( qui est de 64) on doit avoir un tour de réducteur complet. Toute autre valeur ne peut être qu’erronée.
  • 2 - La séquence d'alimentation des bobines du moteur doit être correctes. AN-BS-AS-BN

2BOBINES.JPG

 

  1. Dans la pratique, il faut mesurer le parcours du rotor au niveau du réducteur.
  2. Noter la séquence d'alimentation du moteur au niveau des LEDs de la carte driver. ( ULN2003A )

Pour cela il faut écrire un petit programme que je vous donne.


// ------------------------ COMMENTAIRES -----------------------
// Version FULL-STEP
// Banc d'essai 28BY-48 (Moteur unipolaire 5 fils 2 Bobines avec point milieu à la masse
// 32 pas par tour en FULL-STEP et WAVE-STEP)
// Et sa carte ULN-203-A
// Le programme alimente les bobines du moteur alternativement selon la séquence désirée. En mode Full Step !
// Pour changer de mode changer les procedures PAS . Ce sera fait dans la version 2.
// La tempo fait que l'on peut noter quelles sont les LED qui s'allument sur la carte 
// et par là même quelle bobine est alimentée.
// Le  programme fait 8 pas (2 X 4 pas) à vitesse lente pour noter la séquence ...

// Mode WAVE
// 4321
// ---+  PAS1  AN 
// --+-  PAS2  BS 
// -+--  PAS3  AS 
// +---  PAS4  BN 

// Mode FULL STEP
// 4321
// --++  PAS1  AN + BS 
// -++-  PAS2  BS + AS
// ++--  PAS3  AS + BN
// +--+  PAS4  BN + AN

// Ensuite il fait un tour complet dans le sens horaire à vitesse rapide 16 tours /mn 
// puis la même chose en sens inverse.
// Et le cycle rcommence.

// ---------------------   DECLARATIONS -------------------------------

//int NbPasRéduits = 2048; // Modifier si nécessaire
// Il y a 2 Bobines A et B Chacune a 2 poles Sud et Nord
// Il y a donc 4 combinaisons que nous appellerons: AN, AS, BN, BS
// Sorties pour Arduino MEGA D 34,35,36,37
// Sorties pour NANO D 5,6,7,8
int A=34;  // BLEU        = AN
int B=35;  // VERT        = BS
int C=36;  // JAUNE BLANC = AS
int D=37;  // ORANGE      = BN
int T1=2;  //Tempo1 Il faudrait affiner en microsecondes entre 1 et 2 milli
int T2=3;  //Tempo2
int NbPAS = 2048; // A la sortie du réducteur (Moteur = 32)
int PAS=0; // Compteur de pas
 
void setup() {
  // Configure les Pin de commande en sortie
   pinMode(A,OUTPUT);
   pinMode(B,OUTPUT);
   pinMode(C,OUTPUT);
   pinMode(D,OUTPUT);
    
  }

void loop() {
  LENT();   // 2 cycles lents
  RAPIDE(); // Un tour complet rapide et retour

}
 
// ---------------------------------------
// ---------     PROCEDURES    -----------
// ---------------------------------------

void LENT(){
  T1=2000;
  PAS1();
  PAS2();
  PAS3();
  PAS4();
  
  PAS1();
  PAS2();
  PAS3();
  PAS4();
}
void RAPIDE(){
  AVANT();
  delay(500);
  ARRIERE();
  delay(500);
}
void AVANT(){
  T1=2;
  for (int i=0; i <= 2048/4; i++){
   PAS1();
   PAS2();
   PAS3();
   PAS4(); 
}
}
void ARRIERE() {
  for (int i=0; i <= 2048/4; i++){
    PAS4();
    PAS3();
    PAS2();
    PAS1();
  }
}
// ------------------------------  CYCLE --------------------------
void PAS1 () 
{
  digitalWrite(A,HIGH); // AN
  digitalWrite(B,HIGH); // BS
  digitalWrite(C,LOW);  // AS
  digitalWrite(D,LOW);  // BN
  delay (T1);
}
void PAS2 () 
{
  digitalWrite(A,LOW);
  digitalWrite(B,HIGH);
  digitalWrite(C,HIGH);
  digitalWrite(D,LOW);
  delay (T1);
}
void PAS3 () 
{
  digitalWrite(A,LOW);
  digitalWrite(B,LOW);
  digitalWrite(C,HIGH);
  digitalWrite(D,HIGH);
  delay (T1);
}
void PAS4 () 
{
  digitalWrite(A,HIGH);
  digitalWrite(B,LOW);
  digitalWrite(C,LOW);
  digitalWrite(D,HIGH);
  delay (T1);
}

// ------------ FIN ----------------

Le programme fait deux cycles de base à vitesse lente pour noter l'ordre d'alimentation des bobines.

Puis un tour complet dans le sens horaire à vitesse maximum qui est dans ce cas de 15.5 tours par minutes (et non 9 maximum comme indiqué partout!)

puis un autre tour dans le sens antihoraire.

Le moteur peut tourner à ce régime pendant des journées sans chauffer.

Cela démontre également que c'est la bonne façon de gérer ce moteur.

 

Amicalement.


  • 0

#66 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 12 octobre 2018 - 08:19

Bonjour tous,

 

Voici ce que donne la programmation maîtrisée du moteur, "pas par pas"

Programmation à l'aide de la bibliothèque "stepper.h" et sans elle.

 

Premier cas

 

stepper Moteur (2048 ,Pas1,Pas3,Pas2,Pas4);

 

D C B A

⚪🔴🔴⚪

🔴🔴⚪⚪

🔴⚪⚪🔴

⚪⚪🔴🔴

⚪🔴🔴⚪

🔴🔴⚪⚪

🔴⚪⚪🔴

⚪⚪🔴🔴

 

Deuxième cas :

 

stepper moteur(48*20, IN1,IN2,IN3,IN4) ; 

 

 

D C B A

⚪🔴🔴⚪

🔴⚪🔴⚪

🔴⚪⚪🔴

⚪🔴⚪🔴

⚪🔴🔴⚪

🔴⚪🔴⚪

🔴⚪⚪🔴

⚪🔴⚪🔴 

 

Troisième cas:

Programmation directe, sans la bibliothèque "stepper.h" avec le programme ci-dessus.

 

D C B A

⚪⚪🔴🔴

⚪🔴🔴⚪

🔴🔴⚪⚪

🔴⚪⚪🔴

⚪⚪🔴🔴

⚪🔴🔴⚪

🔴🔴⚪⚪

🔴⚪⚪🔴

 

On constate que 1 et 3 sont équivalents, sauf que le cycle ne commence pas au même moment, mais c'est rigoureusement pareil.

Par contre le cycle 2 est totalement erroné.

 

Amicalement.

 


  • 0

#67 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 12 octobre 2018 - 04:15

Bonjour a tous,

Tres interessant ! Il faut que je remonte un moteur sur un Arduino uno pour tester ton programme.

Pour le moment, je ne veux pas trop toucher mon programme qui fonctionne a 99%

Et suite aux intemperies , pluie, pluie, pluie ! Je fonctionne , suite a l'utilisation exclusive de panneaux solaire , en mode economie d'ernergie , donc silence informatique .

En reponse a JMP76, il n'existe rien en dehors de 0 ou 1 ! Je ne vois pas comment manipuler en binaire autre chose que 1 ou 0 !

En final, il ne s'agit que de signaux electrique , ya ou ya pas et bien sur , le zero a une valeur informative strictement identique au 1.

Souvent, il y a confusion entre le 0 et rien, rien , n'existe pas en informatique. Une adresse memoire qui ne contient aucune info n'est pas a rien ! mais 0 ou 1 suivant la façon de l'interroger.

Modifié par michelflashman, 12 octobre 2018 - 04:47 .

  • 0

#68 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 12 octobre 2018 - 07:44

Bonjour, bonjour,

 

Sujet très intéressant que le binaire à la base du "numérique" ou "digital".

 

En électronique un signal inexistant  (dû à une coupure est souvent actif haut,) est donc un 1 en logique bipolaire

Teu teu teu, un Zéro logique en logique TTL  = 0 V alors qu'un Un logique équivaut  à  + 5 V.

Bien sûr avec des inverseurs, on peut faire passer tous les Zéro à Un et vice versa.

 

Un signal analogique lumineux Noir, c'est à dire l'absence de signal, est transformé en une suite de  Zéros une fois converti et en Uns quand son intensité est au maximum. Leur nombre dépend du nombre de bits de résolution du convertisseur.

NOIR.JPG

 

 

 

Cela correspond à 10 signaux "inactifs" (états bas en logique positive). Mais ces signaux existent bien. On ne peut pas parler d'absence de signal.

 

Curieusement Il y a la même confusion entre signal réel et sa traduction en numérique, et le réel et virtuel en optique. (Ceux qui sont saturés par ce genre de débat peuvent passer, je les comprends.)

Un signal, c'est de l'analogique, du réel, du physique.

Un convertisseur est un dispositif électronique qui décompose un signal (analogique et réel donc) en petites tranches, et chaque tranche est symbolisée par une valeur numérique, donc virtuelle.

Ce convertisseur a donc une résolution, c'est à dire la dimension de la la tranche.

Si la valeur du signal est nulle = pas de signal du tout, ou que ce signal, bien réel mais plus petit que la résolution du convertisseur, la valeur (virtuelle = numérique) retournée par le convertisseur est Zéro ou une suite de Zéro.

  1. On ne peut pas dire s'il y a un signal, mais inférieur au seuil de résolution. Les zéros retournés ne prouvent pas qu'il n'y a pas de signal.
  2. Ou s'il n'y a pas de signal du tout. Dans ce cas, les zéros retournés par le convertisseur signifie qu'il n'y a pas de signal du tout.

Le signal, c'est donc la partie analogique et l'information numérique c'est la partie virtuelle. 

 

 le zero a une valeur informative strictement identique au 1

Dans le domaine informatique , qu'est la traduction de la réalité en virtuel, c'est tout à fait exact, l'informatique est un traitement de l'information ,neutre. L'informatique en tant que traitement de l'information (je n'ai pas dit du signal) n'a pas d'état d'âme.

Par contre, si on remonte au signal réel , dans le monde physique réel, le UN est tout le contraire du ZÉRO !

 

Il ne faut donc pas confondre les deux mondes !  Un zéro ou un un, cela peut correspondre dans le monde physique (réel)  à la différence entre , le vrai, le faux,  la présence, l'absence, la vie et la mort.

 

En fait, je pense qu'il n'y a aucune divergence dans nos propos, simplement une autre façon de le dire.

 

Amicalement.


  • 0

#69 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 28 octobre 2018 - 09:51

Bonjour,

 

A-t'on des nouvelles de Michel Flashman ?

J'espère que le vent qui a soufflé fort sur l' Aude ( pas loin du 34 ) ne lui a pas cassé ses panneaux solaires.

Je suis quand même un peu inquiet.

 

Amicalement.


  • 0

#70 michelflashman

michelflashman

    Nucléotide

  • Membre confirmé
  • 42 messages

Posté 01 novembre 2018 - 04:57

Bonjour a tous,

 

Pas d'inquiétude , un petit séjour a l'étranger non prévu et précipite .

 

De retour, il faut me remettre dans le bain !!!!!

 

Bien amicalement

 

Michel


  • 0

#71 Tryphon T

Tryphon T

    oooOooo

  • Membre confirmé
  • PipPipPipPipPipPipPipPipPipPip
  • 13 767 messages

Posté 03 novembre 2018 - 10:14

Merci pour ces bonnes nouvelles!


  • 0




N'oubliez pas de consulter notre Magazine en ligne ... MIK-MAG!