1.11.9

News

Page  1 sur 3  > >>

2019-01-16
Catégorie : Arduino
Posté par : xavier
Un Circuit imprimé pour plusieurs sketches
2018-06-07
Catégorie : Arduino
Posté par : xavier
Des pistes pour developper un projet a base d'Arduino
2017-09-23
Catégorie : Expositions
Posté par : xavier

Les 4/5 Novembre 2017, au parc Savoie Expo de Chambéry (Savoie), se tiendra l'exposition Savoie Modelisme.

CMS - 1.11.9 - Bartolome
 

Pont Tournant

Comment motoriser un Pont Pournant Peco ?

  • Un Arduino Mega
  • Un EasyDriver V44 ou DRV8824 de Pollolu
  • Un moteur pas a pas RH7-1336 fixe sur 2 cornières en aluminium réglables en hauteur à chaque extrémité

 

Des idées pour la suite:

  • Commande RC5
  • Progamme interface PC

Le mode d'emploi est dans l'entête du programme. Ces commandes sont envoyées via USB.

Attention: ce programme utilise la librairie AccelStepper. Voir aussi la documentation de EasyDriver

Code

/*
===========================================================
X. Bouillard   2014/08/01
Commande de pont tournant avec acceleration et decelleration

Moteur Unipolaire 5V 400 pas (0.9°) RH7-1336
EasyDriver V44 double le nombre de pas (0.45°)
Clignottement led
===========================================================
? : Affichage du menu
E : passage en mode Exploitation
S : passage en mode Reglage
  Permet d'ajuster le positionnement du pont face a une voie
> : Next
  Passe a la voie suivante (Exploitation)
  Avance d'un micro pas (Reglage)
< : Prev
  Passe a la voie precedente (Exploitation)
  Recule d'un micro pas (Reglage)
R : Retour = demi tour
Z : Zero, La voie actuelle devient la voie Zero
===========================================================
*/

// ========================================================
// Gestion de la communication PC via USB
String inputString = "";        // Chaine permettatnt de recevoir les informations du PC via USB
boolean stringComplete = false; // Drapeau indiquant que la chaine recue est complete (finit par CR)

#include <AccelStepper.h>
// ========================================================
// Definition des messages
#define  Msg_Patience          "Patientez S.V.P."
#define  Msg_Done              "En "

#define  Msg_Next              "Next"
#define  Msg_Prev              "Prev"
#define  Msg_Half              "Retour"
#define  Msg_Zero              "Zero"
#define  Msg_Goto              " Goto  :"

#define  Msg_Exploit           "Exploitation"
#define  Msg_Setting           "Reglage"

#define  Msg_Move              "Move "
#define  Msg_Motor             " Cmd moteur "

#define  Err_Low               "Err <0"
#define  Err_High              "Err >"

#define  Msg_Recu_USB           "------ Recu :"

#define  Cmd_Exploit           "E" // pour Exploitation
#define  Cmd_Setting           "S" // pour Setting
#define  Cmd_Next              ">"
#define  Cmd_Prev              "<"
#define  Cmd_Half              "R" // pour Retournement
#define  Cmd_Zero              "Z" // pour Zero
#define  Cmd_Help              "?" // pour Aide

// Adaptation du materiel
#define  HalfTrack  20         // Nombre de voies /2
#define  r9        40          // Nombre de pas entre voies
#define  DIR_PIN   8           // Commande du sens
#define  STEP_PIN  9           // Commande de marche/arret
#define interval   500         // Timeout detection moteur
                               // A regler sur 110% du demi tour
#define led1       12
#define led2       13
#define BlkInterval   1000     // Frequence de clignottement
#define Alt        true        // Alterne le clignottement

// Define a stepper and the pins it will use
AccelStepper stepper(1, STEP_PIN, DIR_PIN);

int pos = 0; //3600;
boolean Connected=true;
boolean Done;
int rot = 1;            // sens de rotation
int voie=0;             // Numero de la voie principale
int mode=0;             // Exploitation=0, Reglage =1
long previousMillis = 0;
unsigned long currentMillis = millis();

int ledState = LOW;     // ledState used to set the LEDs
long LastBlk = 0;

// ========================================================
// Lecture USB Serial event reader
// ========================================================
void serialEvent() {
  while (Serial.available()) {
    // acquisition d'un nouveau caratere:
    char inChar = (char)Serial.read();
    // si c'est LF, positionne le drapeau pour que la boucle principale prenne en compte le message:
    if (inChar == '\n') {
      stringComplete = true;
    } else {
    // sinon l'ajouter au message en cours de construction:
      inputString += inChar;
    }
  }
}

// ========================================================
void Help() {
  Serial.print(Cmd_Exploit);Serial.print(" : "); Serial.println(Msg_Exploit);
  Serial.print(Cmd_Setting);Serial.print(" : "); Serial.println(Msg_Setting);
  Serial.print(Cmd_Next);Serial.print(" : "); Serial.println(Msg_Next);
  Serial.print(Cmd_Prev);Serial.print(" : "); Serial.println(Msg_Prev);
  Serial.print(Cmd_Half);Serial.print(" : "); Serial.println(Msg_Half);
  Serial.print(Cmd_Zero);Serial.print(" : "); Serial.println(Msg_Zero);
  Serial.println();
}

// ========================================================
void MoveMotor(int d) {
  if (Connected) {
    stepper.move(d);
    previousMillis = currentMillis;
  }
}

// ========================================================
void setup() {  
  Serial.begin(9600);        // initialise la communication USB:
  Serial.println(Msg_Patience);
  inputString.reserve(200);  // reserve 200 bytes pour la chaine en reception USB:
//  pinMode(DIR_PIN, OUTPUT);
//  pinMode(STEP_PIN, OUTPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);

  stepper.setMaxSpeed(30);
  stepper.setAcceleration(50);
  Help();
  Serial.println(Msg_Exploit);
}

// ========================================================
void loop() {
  int tmp=-99;
  // Gestion des info USB :
  if (stringComplete) {
    Done=true;
    inputString.toUpperCase();
    Serial.print(Msg_Recu_USB);
    Serial.println(inputString);
    String c = inputString.substring(0,1);
    //Serial.println(c);
    switch (mode) {
      case 0: // mode Exploitation
        if (c==Cmd_Help) {           // Aide
          Help();
        } else if (c==Cmd_Setting) { // Passe en Mode Settings
          mode = 1;
          Serial.println(Msg_Setting);
        } else if (c==Cmd_Next) {    // Next Step
          Serial.print(Msg_Next);
          pos=1;
          tmp=(voie+1)%(2*HalfTrack);
        } else if (c==Cmd_Prev) {    // Previous Step
          Serial.print(Msg_Prev);
          pos=-1;
          tmp=(voie-1+2*HalfTrack)%(2*HalfTrack);
        } else if (c==Cmd_Half) {    // 1/2 tour
          Serial.print(Msg_Half);
          pos=HalfTrack;
          tmp=(voie+HalfTrack)%(2*HalfTrack);
        } else if (c==Cmd_Zero) {    // Reset voie
          Serial.print(Msg_Zero);  
          voie=0;
        } else if (c!=""){                // Goto track
            tmp =inputString.toInt();     // Calcul du nombre de pas et du send
            if (tmp<0) {                  // Voie non disponible <0
              Serial.print(Err_Low);
              tmp=-99;
            } else if (tmp<=2*HalfTrack) {
              int t1;
              if (abs(tmp-voie)<=HalfTrack) {
                t1=tmp-voie;
              } else {
                t1=abs(voie-tmp)-2*HalfTrack;
                if (voie>tmp) {
                  t1=-t1;
                }
              }
              pos=t1;
              Serial.print(Msg_Move);
              Serial.print(t1);
              Serial.print(Msg_Goto);
            } else if (tmp>2*HalfTrack){ // Voie non disponible > max
              Serial.print(Err_High);
              Serial.print(2*HalfTrack);
              tmp=-99;
            }
          }
        break;
      case 1:  // Mode reglage
        if (c==Cmd_Help) {           // Aide
          Help();
        } else if (c==Cmd_Exploit) { // Passe en Mode Exploitation
          mode = 0;
          Serial.println(Msg_Exploit);
        } else if (c==Cmd_Next) {    // Next Step
          MoveMotor(-1);          
        } else if (c==Cmd_Prev) {    // Previous Step
          MoveMotor(1);     
        }
        break;
    }
    
    if (tmp!=-99) {         // Send command to motor
      Serial.print(tmp);
      Serial.print(Msg_Motor);
      pos=pos*r9;
      Serial.print(pos);  
      MoveMotor(pos);
      voie=tmp;
    }
    // re-initialize la chaine recue:
    inputString = "";
    stringComplete = false;
  }

// check goal is reached
  if (stepper.distanceToGo() == 0)  {
    if (Done) {
      Serial.print(" ... ");
      Done=false;
      if (mode==0) {
        Serial.print(Msg_Done);
        Serial.println(voie);
        digitalWrite(led1, LOW);
        digitalWrite(led2, LOW);
     }
    }
  } else { // detection de l'absence de moteur sur timeout
   // Clignottement leds lors du mouvement
    unsigned long curMillis = millis();
    if(curMillis - LastBlk > BlkInterval) {
      LastBlk = curMillis;
      if (ledState == LOW)
        ledState = HIGH;
      else
        ledState = LOW;
      digitalWrite(led1, ledState);
      if (Alt) {
        digitalWrite(led2, ledState);
      } else {
        digitalWrite(led2, !ledState);
      }
    }
    if(currentMillis - previousMillis > interval) {
      Connected=false;
    }
  }
  stepper.run();
 
}
Previous page: Dcc_Servo_Decoder  Page suivante : Dcc_Turntable_Decoder