Overblog Suivre ce blog
Editer l'article Administration Créer mon blog

La fabrication du pont transbordeur avance bien . J'ai modifié la partie entrainement en ajoutant des pignons (récupérés sur un lecteur de CD) . j'ai ainsi pu doubler la vitesse  de déplacement .Ce n'est pas parfait mais cela m'a permit de continuer mes essais en attendant de changer le système d'entrainement.

Afin de vérifier d'effectuer la mise au point du programme du pont et vérifier la précision des déplacements, j'ai crée un gabarit avec la position de chaque voie.

Le programme est terminé . Il fonctionne . Pour les plus courageux il est à la fin de l'article.

Il me reste un problème à traiter sur le guidage de la plateforme . J'ai un blocage de temps en temps du à la fabrication de mes fourreaux de guidage (fabrication trop sommaire et pas assez précise) .

 

 

 

 

Pont Transbordeur : Le programme Arduino
Pont Transbordeur : Le programme Arduino

//**************************************************************
// Commande Pont Transbordeur
// 28BYJ-48 5VDC
// Driver ULN2003 et rapport de réduction 1:64
// Arduino UNO
// Olivier PETIT 20.03.2015
// Version V1.00
//**************************************************************


 #include <Stepper.h> // Inclus la librairie pour les fonctions stepper
 #define STEPS 100    //nombre de pas pour 1 tour moteur 
 
Stepper Mon_moteur(STEPS, 8,  10,9, 11);     
 
        
 // Définir les broches
const int fdc_xm =2; //Fin de course X-
const int fdc_xp =3; //Fin de course X+   
const int Rc_p1 =4; // Roue Codeuse Poids 1
const int Rc_p2 =5; // Roue Codeuse Poids 2
const int Rc_p4 =6; // Roue Codeuse Poids 4
const int Bp_va =7; // Bouton Poussoir validation mouvement
const int led_mvt = 12; // LED Mouvement en cours
const int led_pom = 13;   // LED Prise d'Origine Faite

int Etat_fdc_xm = 0; 
int Etat_fdc_xp =0;
int Etat_Rc_p1 =0;
int Etat_Rc_p2 =0;
int Etat_Rc_p4 =0;
int Etat_Bp_va =0;
int k=0;
int i=0;

 

boolean POM_OK=false;
long Compteur_pas =0;
long deplacement=0;

// Coordonnees absolues des voies
// multiple de 128

long offset_origine= -16128; // position prise d'origine voie 1
long coord_abs_1=0;            // position arret voie 1
long coord_abs_2=-32512;  // position arret voie 2
long coord_abs_3=-65024;  // position arret voie 3
long coord_abs_4=-97536;  // position arret voie 4


void setup() 
 {                
  Serial.begin(9600);     // 9600 bps
  Serial.println("Pont Transbordeur V1.00"); 
  pinMode(fdc_xm,INPUT);
  pinMode(fdc_xp,INPUT);
  pinMode(Rc_p1,INPUT);
  pinMode(Rc_p2,INPUT);
  pinMode(Rc_p4,INPUT);
  pinMode(Bp_va,INPUT);
  
  pinMode(led_mvt, OUTPUT);       
  pinMode(led_pom, OUTPUT);    
  }

void loop() 
  {    
    lecture_entrees();
    k=roue_codeuse(Etat_Rc_p1,Etat_Rc_p2,Etat_Rc_p4);
    
    Mon_moteur.setSpeed(300); //Vitesse de 300 (max) réduire cette valeur pour avoir un vitesse plus lente
  

  if ((k==0) && (Etat_Bp_va==HIGH) && (POM_OK==false)) { 
     pom();
  }
      
  if ((k==1) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Compteur_pas!=coord_abs_1)){
     deplacement=calcul_deplacement(Compteur_pas,coord_abs_1);
     deplacement_axe(k,deplacement,coord_abs_1);    
  }
 
  if ((k==2) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Compteur_pas!=coord_abs_2)){
     deplacement=calcul_deplacement(Compteur_pas,coord_abs_2);
     deplacement_axe(k,deplacement,coord_abs_2);
     
 }
 
  if ((k==3) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Compteur_pas!=coord_abs_3)){
     deplacement=calcul_deplacement(Compteur_pas,coord_abs_3);
     deplacement_axe(k,deplacement,coord_abs_3);
 }
 
  if ((k==4) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Compteur_pas!=coord_abs_4)){
     deplacement=calcul_deplacement(Compteur_pas,coord_abs_4);
     deplacement_axe(k,deplacement,coord_abs_4);
 }
  
  
 if ((k==5) && (Etat_Bp_va==HIGH)){
      vaetvient(50);
 }      
 if ((k==6) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Etat_fdc_xm!=HIGH)){
      mode_manuel_xm();
 }    
  if ((k==7) && (Etat_Bp_va==HIGH) && (POM_OK==true) && (Etat_fdc_xp !=HIGH)){
     mode_manuel_xp();
 } 
 // forcage POM sur position 1
  if ((k==1) && (Etat_Bp_va==HIGH) && (POM_OK==false)){
     forcage_pom(coord_abs_1);
  }  
 if ((k==2) && (Etat_Bp_va==HIGH) && (POM_OK==false)){
     forcage_pom(coord_abs_2);     
  }  
 if ((k==3) && (Etat_Bp_va==HIGH) && (POM_OK==false)){
     forcage_pom(coord_abs_3);
  }   
 if ((k==4) && (Etat_Bp_va==HIGH) && (POM_OK==false)){
     forcage_pom(coord_abs_4);
  }   
}

int forcage_pom(long forcage_val){
     Serial.print("Forcage POM: ");
     Compteur_pas=forcage_val;
     Serial.println(Compteur_pas);
     POM_OK=true;
     digitalWrite(led_pom,HIGH);
     
     Serial.println("POM Faite");
}     
//  
// lecture entrees
//

void lecture_entrees(){
    Etat_fdc_xm = digitalRead(fdc_xm); 
    Etat_fdc_xp= digitalRead(fdc_xp);
    Etat_Rc_p1 = digitalRead(Rc_p1);
    Etat_Rc_p2 = digitalRead(Rc_p2);
    Etat_Rc_p4 = digitalRead(Rc_p4);
    Etat_Bp_va = digitalRead(Bp_va);  
     
    
}   
//
// Decodage roue codeuse
//

int roue_codeuse(int p1,int p2,int p4){
    int a,b,c,result;
  
    if (p1==1) {a=1;} else {a=0;}
    if (p2==1) {b=2;} else {b=0;}
    if (p4==1) {c=4;} else {c=0;}
    result=a+b+c;
    return result;
}
  
//
// fonction prise d'origine
//

void pom(){
    Serial.println("Prise d'origine");
    digitalWrite(led_mvt,HIGH);
    Serial.println("En cours: ");
    do{
       Mon_moteur.step(128);        
       lecture_entrees();
   }while (Etat_fdc_xm==LOW);
   Mon_moteur.step(offset_origine);
   
   POM_OK=true;
   Compteur_pas  = 0;
   digitalWrite(led_pom,HIGH);
   Serial.println("POM Faite");    
   digitalWrite(led_mvt,LOW);  

//
// Mouvement X-
//

void mode_manuel_xm(){
  Serial.println("Deplacement X-");  
  lecture_entrees();
 if ((Etat_fdc_xm==LOW) && (Etat_Bp_va==HIGH) and (Compteur_pas!=0)){
     digitalWrite(led_mvt,HIGH);
     Mon_moteur.step(128);      
     Compteur_pas = Compteur_pas+128;
     digitalWrite(led_mvt,LOW);
    // Serial.println(Compteur_pas);
  }
  Serial.println(Compteur_pas);
}
//
// Mouvement X+
//

void mode_manuel_xp(){
  Serial.println("Deplacement X+");  
   lecture_entrees();
  if ((Etat_fdc_xp==LOW) && (Etat_Bp_va==HIGH)){
    digitalWrite(led_mvt,HIGH);
    Mon_moteur.step(-128);  
    Compteur_pas = Compteur_pas-128;
    digitalWrite(led_mvt,LOW);
    Serial.println(Compteur_pas);
  }  
}

// 
void vaetvient(int nb){
 for (int i=0;i<nb;i++){
   digitalWrite(led_mvt,HIGH);
   Mon_moteur.step(-128); 
   digitalWrite(led_mvt,LOW);
    Compteur_pas = Compteur_pas-128;
   }
   delay(5000);
   for (int i=0;i<nb;i++){
   digitalWrite(led_mvt,HIGH);  
   Mon_moteur.step(128);  
   digitalWrite(led_mvt,LOW);  
    Compteur_pas = Compteur_pas+128;
   } 
 }
//  
// CALCUL VALEUR DEPLACEMENT
//

long calcul_deplacement(long Val_cpt,long destination){
    long result;
    result=(Val_cpt*(-1))+destination;
     Serial.println("Resultat calcul deplacement");  
     Serial.println(result); 
    return result;
}

void deplacement_axe(int num_voie_dest,long valeur_depl,long destination){     
     int id;
     long i_to;
     int valeur_increment;
     
     Serial.print("+----->");
     Serial.println(num_voie_dest);
    
     digitalWrite(led_mvt,HIGH);     
     
     if (valeur_depl>0) {valeur_increment=128;} else {valeur_increment=-128;}
      Serial.print("valeur depl:");
      Serial.print(valeur_depl);
      Serial.print(" Valeur_increment:");
      Serial.println(valeur_increment);   
     
     i_to=abs(valeur_depl);
     i_to=i_to/128;
     
     Serial.print("i_to:");
     Serial.println(i_to);
     
     for (id=0;id<i_to;id++){
     Mon_moteur.step(valeur_increment);     
     }     
     digitalWrite(led_mvt,LOW);         
     Compteur_pas=destination;
     Serial.print("New Compteur Pas : ");
     Serial.println(Compteur_pas); 
}
 

Tag(s) : #Pont Transbordeur