Pages: [1]   Go Down
Author Topic: Stepper motor, doesn't turn counter clockwise, wrong steps number indication  (Read 7360 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 1
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hello everybody!

I'm new and it's my first topic. Hope I'm gonna make it right.

I just bought a kit to start with Arduino. You can see it here:
http://www.geeetech.com/advanced-genuine-arduino-leonardo-experiment-kit2-p-597.html

I got through some of the cool things inside. But the stepper motor is still a mastermind....
http://www.geeetech.com/5v-4phase-5wire-stepper-motor-p-368.html

Basically I have two problems: It doesn't want to turn anti-clock wise and it has apparently many more steps than indicated!!!

I tested it with different prefabricated examples so problems wouldn't come from my coding. Basically MotorKnob and stepper_oneRevolution which are both predefined in the Arduino IDE.

I will here only speak on the basis of stepper_oneRevolution. When I upload it (indicating 64 steps in the code), the motor doesn't turn in one direction and then in the other. Instead it goes from about 1/8 of the distance, always in the same direction. So:

1. it never go backward, all the clockwise and counter clockwise move go in the same direction.
2. Instead of using 64 steps and make a 360° rotation, it makes only a 1/8th of it, which represent a 45° rotation.

Videos will follow.

I don't understand how this is possible, and if somebody already encounter such a problem. What can I do at least to know the amount of steps in my stepper???

Thx!
Logged

Massachusetts, USA
Offline Offline
Tesla Member
***
Karma: 201
Posts: 8701
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

It appears to be a 64-step (5.625 degree) stepper with a 1:64 gearbox making it 4096 steps per revolution.

How is it wired?
Logged

Send Bitcoin tips to: 1L3CTDoTgrXNA5WyF77uWqt4gUdye9mezN
Send Litecoin tips to : LVtpaq6JgJAZwvnVq3ftVeHafWkcpmuR1e

Dubuque, Iowa, USA
Offline Offline
Edison Member
*
Karma: 45
Posts: 2472
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

The motor itself is 64 steps per rotation, but the gear reduction ratio of 1:64 makes it 4096 steps per rotation of the output shaft.
http://www.geeetech.com/Documents/Stepper%20motor%20datasheet.pdf

The 4096 is sometimes not quite right. There have been a lot of reports of inaccuracy in the gearing; it's what you get for $5 smiley-wink
Logged

0
Offline Offline
Shannon Member
****
Karma: 200
Posts: 11694
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Failure to go in either direction: either a winding isn't getting power or you are failing to sequence the motor correctly. 

Schematic?  Sketch?
Logged

[ I won't respond to messages, use the forum please ]

Offline Offline
Newbie
*
Karma: 1
Posts: 2
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I had a similar problem using the 28BYJ-48 5V motor, it would only travel clockwise.

I have modified the library as well as the sketch to overcome the direction issue and to add a new feature.
The new feature is Half step mode which has 8 steps rather than 4
I also adjusted the 4 wire step sequence which I believe solved the direction issue

Only just joined the forum so not sure how best to share this info, so i have added the details into this post

There are 2 files below, the stepper.cpp updated file will have to be posted separately owing to size limits.
You will probably want to make copies of your existing stepper.h and stepper.cpp for safety at this point.
Then copy the text between the scissor marks and save the first as stepper.h in your library folder
The last file is the sketch.

-------------- start of stepper.h ------------------------------------------------------------>
/*
  Stepper.h - - Stepper library for Wiring/Arduino - Version 0.5

  Original library     (0.1) by Tom Igoe.
  Two-wire modifications   (0.2) by Sebastian Gassner
  Combination version   (0.3) by Tom Igoe and David Mellis
  Bug fix for four-wire   (0.4) by Tom Igoe, bug fix from Noah Shibley
  Add Half Step mode      (0.5) by D Traynor

  Drives a unipolar or bipolar stepper motor using  2 wires or 4 wires

  When wiring multiple stepper motors to a microcontroller,
  you quickly run out of output pins, with each motor requiring 4 connections.

  By making use of the fact that at any time two of the four motor
  coils are the inverse  of the other two, the number of
  control connections can be reduced from 4 to 2.

  A slightly modified circuit around a Darlington transistor array or an L293 H-bridge
  connects to only 2 microcontroler pins, inverts the signals received,
  and delivers the 4 (2 plus 2 inverted ones) output signals required
  for driving a stepper motor.

  The sequence of for fullstep control signals for 4 control wires is as follows:

  # Modified from the original 1010, 0110, 0101, 1001 - since my motor would not reverse

  Step C0 C1 C2 C3
     1  0  0  1  1
     2  1  0  0  1
     3  1  1  0  0
     4  0  1  1  0

  # Added this 8 step sequence for halfstep control for 4 control wires as follows:

  Step C0 C1 C2 C3
     1  1  0  0  1
     2  1  0  0  0
     3  1  1  0  0
     4  0  1  0  0
     5  0  1  1  0
     6  0  0  1  0
     7  0  0  1  1
     8  0  0  0  1

  The sequence of controls signals for 2 control wires is as follows
  (columns C1 and C2 from above):

  Step C0 C1
     1  0  1
     2  1  1
     3  1  0
     4  0  0

  The circuits can be found at
  http://www.arduino.cc/en/Tutorial/Stepper
*/

// ensure this library description is only included once
#ifndef Stepper_h
#define Stepper_h

// library interface description
class Stepper {
  public:
    // constructors:
    // Additional parameter for the modulo count
    Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int mod_count);
    Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int motor_pin_3, int motor_pin_4, int mod_count);

    // speed setter method:
    void setSpeed(long whatSpeed);

    // mover method:
    void step(int number_of_steps);

    int version(void);

  private:
    void stepMotor(int this_step);

    int direction;        // Direction of rotation
    int speed;          // Speed in RPMs
    unsigned long step_delay;    // delay between steps, in ms, based on speed
    int number_of_steps;      // total number of steps this motor can take
    int pin_count;        // whether you're driving the motor with 2 or 4 pins
    int step_number;        // which step the motor is on

    // motor pin numbers:
    int motor_pin_1;
    int motor_pin_2;
    int motor_pin_3;
    int motor_pin_4;

    // Used to indicate the number of steps in each sequence
    int mod_count;

    long last_step_time;      // time stamp in ms of when the last step was taken
};

#endif
<------------------------ End of stepper.h ------------------------------------


------------------------- Start of Sketch -------------------------------------->
/*
 Stepper Motor Control - one revolution
 
 This program drives a unipolar or bipolar stepper motor.
 The motor is attached to digital pins 8 - 11 of the Arduino.
 
 The motor should revolve one revolution in one direction, then
 one revolution in the other direction.  
 
  
 Created 11 Mar. 2007
 Modified 30 Nov. 2009
 by Tom Igoe
 Modified 19 Jan 2013
 by D Traynor
 */

#include <Stepper.h>


int step_mode = 8;                               // 4 = full, 8 = half

int stepsPerRevolution = 2048 * (step_mode/4) ;  // change this to fit the number of steps per revolution for your motor [DT use 2048]
                                                 // twice as many SPR for halfstep mode
int mysteps = 1 * stepsPerRevolution;

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution,8,9,10,11,step_mode);

int coords[] = {-512,1024,256,-2048,512,256};

void setup() {
  // set the speed at 60 rpm:
  myStepper.setSpeed(60);
  // initialize the serial port:
  Serial.begin(9600);
  
}

void loop() {
  
  // step one revolution  in one direction:

  // This from the original example, used this to get things going (v0.5)
  // Either uncomment the top half or the bottom depending on desired function
  //Serial.println("clockwise");
  //myStepper.step(mysteps);
  //delay(500);
  
  // step one revolution in the other direction:
  //Serial.println("counterclockwise");
  //myStepper.step(-mysteps);
  //delay(500);

  // 2nd Example -> motor steps to the named points in the coords array
  int i;
  for (i = 0; i<6; i++) {
    int point = coords;
    Serial.println("Next point ");
    Serial.println(point);
    myStepper.step(point);
    delay(500);
  }
}
<------------------------------- End of Sketch -------------------------
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 2
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi

here is the stepper.cpp file to go with the last post, remember to copy between the scissor lines. save this as stepper.cpp in your library
----------------------- Start of stepper.cpp ---------------------------------->
/*
  Stepper.cpp - - Stepper library for Wiring/Arduino - Version 0.4

  Original library     (0.1) by Tom Igoe.
  Two-wire modifications   (0.2) by Sebastian Gassner
  Combination version   (0.3) by Tom Igoe and David Mellis
  Bug fix for four-wire   (0.4) by Tom Igoe, bug fix from Noah Shibley
  Add Half Step mode      (0.5) by D Traynor

  Drives a unipolar or bipolar stepper motor using  2 wires or 4 wires

  The sequence for full step of control signals for 4 control wires is as follows:
  # Modified from the original 1010, 0110, 0101, 1001 - since my motor would not reverse

  Step C0 C1 C2 C3
     1  0  0  1  1
     2  1  0  0  1
     3  1  1  0  0
     4  0  1  1  0

  The sequence for halfstep for 4 control wires is as follows:
  # Added this 8 step sequence for halfstep control (v0.5)

  Step C0 C1 C2 C3
     1  1  0  0  1
     2  1  0  0  0
     3  1  1  0  0
     4  0  1  0  0
     5  0  1  1  0
     6  0  0  1  0
     7  0  0  1  1
     8  0  0  0  1

  The sequence of controls signals for 2 control wires is as follows
  (columns C1 and C2 from above):

  Step C0 C1
     1  0  1
     2  1  1
     3  1  0
     4  0  0

  The circuits can be found at

http://www.arduino.cc/en/Tutorial/Stepper
 */


#include "Arduino.h"
#include "Stepper.h"

/*two-wire constructor.
 * Sets which wires should control the motor.
 */
Stepper::Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int mod_count)
{
  this->step_number = 0;      // which step the motor is on
  this->speed = 0;        // the motor speed, in revolutions per minute
  this->direction = 0;      // motor direction
  this->last_step_time = 0;    // time stamp in ms of the last step taken
  this->number_of_steps = number_of_steps;    // total number of steps for this motor
  this->mod_count = 4;      // default number of steps in a sequence (v0.5)

  // Arduino pins for the motor control connection:
  this->motor_pin_1 = motor_pin_1;
  this->motor_pin_2 = motor_pin_2;

  // setup the pins on the microcontroller:
  pinMode(this->motor_pin_1, OUTPUT);
  pinMode(this->motor_pin_2, OUTPUT);

  // modulo count is the No of control steps in a motor STEP sequence (v0.5)
  this->mod_count = mod_count;

  // When there are only 2 pins, set the other two to 0:
  this->motor_pin_3 = 0;
  this->motor_pin_4 = 0;

  // pin_count is used by the stepMotor() method:
  this->pin_count = 2;
}

/*   constructor for four-pin version at FULL step
 *   Sets which wires should control the motor.
 *   New parameter 'mod_count' to cater for halfstep sequence (v0.5)
 */

Stepper::Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int motor_pin_3, int motor_pin_4, int mod_count)
{
  this->step_number = 0;      // which step the motor is on
  this->speed = 0;        // the motor speed, in revolutions per minute
  this->direction = 0;      // motor direction
  this->last_step_time = 0;    // time stamp in ms of the last step taken
  this->number_of_steps = number_of_steps;    // total number of steps for this motor
  this->mod_count = 4;      // default number of steps  FULL STEP = 4 whilst HALF STEP = 8 (v0.5)

  // Arduino pins for the motor control connection:
  this->motor_pin_1 = motor_pin_1;
  this->motor_pin_2 = motor_pin_2;
  this->motor_pin_3 = motor_pin_3;
  this->motor_pin_4 = motor_pin_4;

  // modulo count is the No of control steps in a motor STEP
  this->mod_count = mod_count;

  // setup the pins on the microcontroller:
  pinMode(this->motor_pin_1, OUTPUT);
  pinMode(this->motor_pin_2, OUTPUT);
  pinMode(this->motor_pin_3, OUTPUT);
  pinMode(this->motor_pin_4, OUTPUT);

  // pin_count is used by the stepMotor() method:
  this->pin_count = 4;
}

/*
  Sets the speed in revs per minute
  Added a safeguard minimum delay of 2mS, may vary for other motors
*/
void Stepper::setSpeed(long whatSpeed)
{
  this->step_delay = 60L * 1000L / this->number_of_steps / whatSpeed;
  if (this->step_delay < 2) {
    this->step_delay = 2;    // if the delay is too small then the motor will stall (v0.5)
  }
}

/*
  Moves the motor steps_to_move steps.  If the number is negative,
   the motor moves in the reverse direction.
   Had to change the step sequence to get my motor [28BYJ-48] to reverse in full step (v0.5)
 */
void Stepper::step(int steps_to_move)
{
  int steps_left = abs(steps_to_move);  // how many steps to take

  // determine direction based on whether steps_to_mode is + or -:
  if (steps_to_move > 0) {this->direction = 1;}
  if (steps_to_move < 0) {this->direction = 0;}


  // decrement the number of steps, moving one step each time:
  while(steps_left > 0) {
  // move only if the appropriate delay has passed:
  if (millis() - this->last_step_time >= this->step_delay) {
      // get the timeStamp of when you stepped:
      this->last_step_time = millis();
      // increment or decrement the step number,
      // depending on direction:
      if (this->direction == 1) {
        this->step_number++;
        if (this->step_number == this->number_of_steps) {
          this->step_number = 0;
        }
      }
      else {
        if (this->step_number == 0) {
          this->step_number = this->number_of_steps;
        }
        this->step_number--;
      }
      // decrement the steps left:
      steps_left--;
      // step the motor to step number 0, 1, 2, or 3:
      // or 4,5,6,7 for HALFSTEP mode (v0.5)
      stepMotor(this->step_number % this->mod_count);
    }
  }
}

/*
 * Moves the motor forward or backwards.
 */
void Stepper::stepMotor(int thisStep)
{
  if (this->pin_count == 2) {       // 3 parts of the IF are mutually exclusive -> hence the addition of the ELSE
    switch (thisStep) {
      case 0: /* 01 */
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, HIGH);
      break;
      case 1: /* 11 */
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, HIGH);
      break;
      case 2: /* 10 */
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, LOW);
      break;
      case 3: /* 00 */
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, LOW);
      break;
    }
  } else if (this->pin_count == 4 && this->mod_count == 4) {    // (v0.5) allows distinction between full and half step
    switch (thisStep) {
      case 0:    // 0011
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, HIGH);
      digitalWrite(motor_pin_4, HIGH);
      break;
      case 1:    // 1001
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, HIGH);
      break;
      case 2:    // 1100
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, HIGH);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 3:    // 0110
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, HIGH);
      digitalWrite(motor_pin_3, HIGH);
      digitalWrite(motor_pin_4, LOW);
      break;
    }
  } else if (this->pin_count == 4 && this->mod_count == 8) {    //(v0.5)
    switch (thisStep) {
      case 0:    //1001
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, HIGH);
      break;
      case 1:    //1000
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 2:    //1100
      digitalWrite(motor_pin_1, HIGH);
      digitalWrite(motor_pin_2, HIGH);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 3:    //0100
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, HIGH);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 4:    //0110
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, HIGH);
      digitalWrite(motor_pin_3, HIGH);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 5:    //0010
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, HIGH);
      digitalWrite(motor_pin_4, LOW);
      break;
      case 6:    //0011
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, HIGH);
      digitalWrite(motor_pin_4, HIGH);
      break;
      case 7:    //0001
      digitalWrite(motor_pin_1, LOW);
      digitalWrite(motor_pin_2, LOW);
      digitalWrite(motor_pin_3, LOW);
      digitalWrite(motor_pin_4, HIGH);
      break;
    }
  }
}

/*
  version() returns the version of the library:
*/
int Stepper::version(void)
{
  return 5;
}
<------------------------ End of stepper.cpp ----------------------------------
Logged

UK
Offline Offline
Newbie
*
Karma: 0
Posts: 34
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi
From your picture, your stepper motor looks suspiciously like the 28BYJ-48 unipolar stepper motor I bought on ebay (as a package with a ULN2003). I had a similar problem with it not turning backwards with the example code for stepper_oneRevolution.

It may be that your problem (like mine) was because the wires on the motor were not in the expected order. I had to order my stepper pins as 8, 10, 9, 11 rather than 8,9,10,11 when creating the stepper instance. This enabled the motor to go backwards and forwards as expected. You could try other permutations to see which work for your stepper. (connect 8,9,10,11 to in1, in2, in3, in4 on the ULN)

For the speed/revolutions per minute issue I found combinations with speed * revolutions = about 2^13 (i.e.8192) would work as this is used to calculate the delay needed for the stepper to move. The most accurate one for my stepper was speed = 4 (used for setSpeed) and stepsPerRevolution = 2048 as my stepper moved at about 4 revs per minute.
smiley
Logged

UK
Offline Offline
Newbie
*
Karma: 0
Posts: 21
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

The suggestions froin Zaplady and davidtraynor work for me with my cheap ebayed stepper motors.
Like Zaplady mine came with a ULN2003 driver board with LEDs.
These things can now get purchased for less than £2.00.
So, assuming complete accuracy and the funky cross over wiring isn't a problem then they look like a good tinkerer option.

As a side note. When I wired mine up first time and used the same sketch it went clockwise and anti-clockwise with no modifications. I then disconnected the driver and motor to test my second one and it would only go clockwise. Re-attached the original and it would only go clockwise as well.
So, strange behaviour but then for £2.00 each I expect some slight fun in getting them working.

Thank you Zaplady and david traynor.

Albert.
Logged

Pages: [1]   Go Up
Jump to: