Is this normal??

I recently assembled the Adafruit Bluetooth Camera Slider and came across an unusual problem. Well, I think it's a problem. The slider is jittery at all speeds. I am unfamiliar with how stepper motors should perform so this may be normal operation. Attached is a video of the highest speed setting for this slider. It uses a Arduino Uno, Motor Shield V2, and a bluetooth board. The motor is a Nema 17 part number 17HS13-0404S. I also attached a pic of the wiring. I just want to know if this is norma operation or if I possibly have a bad motor or something else. Thanks in advance!

https://youtu.be/qa4qP8gGdNI

Looks like the image was a bit large. Should be good this time.

Image from Reply #1 so we don’t have to download it. See this Image Guide

3a6c6bb243e871b8eee8248f9e582b3c54dbdde9.jpg

…R

I can’t tell from your video what you mean by jittery. It seems to be moving in regular steps.

I have no idea what the photo is meant to convey.

You need to post the program you are using and a link to the datasheet for your stepper motor. Also tell us what stepper motor power supply you are using (volts and amps).

…R
Stepper Motor Basics
Simple Stepper Code

Below is the code I got from Adafruit.

I am using the following stepper motor:
https://www.amazon.com/gp/product/B00PNEQ9T4/ref=oh_aui_detailpage_o04_s01?ie=UTF8&psc=1

// Smartphone- or tablet-activated timelapse camera slider.
// Uses the following Adafruit parts:
//
// Arduino Uno R3 or similar (adafruit.com/product/50 or #2488)
// Bluefruit LE SPI Friend (#2633)
// Motor/Stepper/Servo Shield v2 (#1438)
// NEMA-17 Stepper motor (#324)
// Miscellaneous hardware and 3D-printed parts; see guide for full list.
//
// Needs Adafruit_BluefruitLE_nRF51 and Adafruit_MotorShield libs:
// github.com/adafruit
// Use Adafruit Bluefruit LE app for iOS or Android to control timing.
// Buttons 1-4 select interpolation mode (linear vs. various ease in/out).
// Up/down select speed.  Left = home.  Right = start slider.

#include <SPI.h>
#include <Wire.h>
#include <SoftwareSerial.h>
#include <Adafruit_BluefruitLE_SPI.h>
#include <Adafruit_MotorShield.h>

#define LED 13 // Built-in LED on pin 13

// Bluefruit config --------------------------------------------------------
Adafruit_BluefruitLE_SPI ble(8, 7, 6); // CS, IRQ, RST pins

// Stepper motor config ----------------------------------------------------
#define STEPPER_STEPS 1100 // Length of slider
#define STEPPER_RPM     20

Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Stepper motor w/200 steps/revolution (1.8 degree) on port 2 (M3 & M4)
Adafruit_StepperMotor *motor = AFMS.getStepper(200, 2);

// Global stuff ------------------------------------------------------------

// Four motion interpolation modes are supported (corresponding to buttons
// 1-4 in the Bluefruit LE app for iOS & Android): linear is constant speed,
// ease_in_out accelerates/decelerates at the ends (fastest in middle),
// ease_in accelerates (fastest at end) and ease_out decelerates (fastest
// at beginning):
typedef enum interp { linear, ease_in_out, ease_in, ease_out };

// A few different time periods are supported, but not a whole lot.  Since
// there's no display connected, we just blink the onboard LED to indicate
// which setting is active, and there's only so many speed changes one can
// reliably 'read' this way.  Feel free to edit, but keep in mind there are
// upper and lower limits to the time interval -- the stepper can only move
// so fast and if you try to press beyond that it'll just move linearly
// regardless of the selected interpolation mode, and the micros() function
// rolls over about every 70 minutes, so the duration can't exceed that.
// Blink rate is similarly constrained due to BLE comm; about 2 Hz max.
struct {
  uint32_t totalTime;    // Total duration of movement along slider
  uint32_t LEDflashTime; // LED blink rate indicates selected speed
} speed[] = {
   5 * 60 * 1000000L, 1000000L / 2, //  5 min slide,   2 Hz blink
  10 * 60 * 1000000L, 1000000L,     // 10 min slide,   1 Hz blink
  20 * 60 * 1000000L, 1000000L * 2, // 20 min slide, 1/2 Hz blink
  60 * 60 * 1000000L, 1000000L * 3  // 60 min slide, 1/3 Hz blink
};
#define N_SPEEDS (sizeof(speed) / sizeof(speed[0]))

uint32_t startTime = 0;      // micros() value when slider movement started
interp   mode      = linear; // Selected interpolation mode
uint8_t  speedIdx  = 0;      // Selected speed index (0 to N_SPEEDS-1)
boolean  moving    = false;  // True if motor active & interpolating

// Setup function - runs once at startup -----------------------------------

void setup(void) {
  Serial.begin(57600);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, HIGH);       // LED steady on during init
  if(!ble.begin(false)) for(;;); // BLE init error? LED on forever
  ble.echo(false);
  AFMS.begin();
  motor->setSpeed(STEPPER_RPM);
  motor->release();              // Allow manual positioning at start
  digitalWrite(LED, LOW);        // LED off = successful init
}

// Loop function - repeats forever -----------------------------------------

void loop(void) {
  static uint16_t prevSliderPos = 0; // Slider position on prior call
  static uint8_t  led;               // Blink status on/off

  if(moving) { // Motor currently engaged?
    float p, t = (float)(micros() - startTime) /
                 (float)speed[speedIdx].totalTime; // Time 0.0 - 1.0

    switch(mode) { // Cubic easing functions from http://gizma.com/easing/
     case linear:
      p = (float)STEPPER_STEPS * t;
      break;
     case ease_in_out:
      t *= 2.0;
      if(t < 1.0) {
        p  = (float)STEPPER_STEPS * 0.5 * t * t * t;
      } else {
        t -= 2.0;
        p  = (float)STEPPER_STEPS * 0.5 * (t * t * t + 2.0);
      }
      break;
     case ease_in:
      p = (float)STEPPER_STEPS * t * t * t;
      break;
     case ease_out:
      t -= 1.0;
      p  = (float)STEPPER_STEPS * (t * t * t + 1.0);
      break;
    }

    // Move stepper to new position (if required)
    uint16_t sliderPos = (int)(p + 0.5);
    if(sliderPos > prevSliderPos) {
      // Microstepping is used to reduce vibration
      motor->step(sliderPos - prevSliderPos, FORWARD, MICROSTEP);
      prevSliderPos = sliderPos;
      if(sliderPos >= STEPPER_STEPS) { // At end of motion?
        motor->release();              // Turn off motor
        moving = false;
      }
    }
  } else {
    if((micros() - startTime) > (speed[speedIdx].LEDflashTime / 2)) {
      digitalWrite(LED, led++ & 1);
      startTime = micros();
    }
  }

  // Process any pending Bluetooth input
  if(ble.isConnected()) {
    ble.println(F("AT+BLEUARTRX"));     // Request string from BLE module
    ble.readline();                     // Read outcome
    if(!strncmp(ble.buffer, "!B", 2) && // Controller button command
       checkCRC(255-'!'-'B', 4)      && // Verify checksum
       (ble.buffer[3] == '1')) {        // Button press? 1=press 0=release
      switch(ble.buffer[2]) {
       case '1': if(!moving) mode = linear;      break;
       case '2': if(!moving) mode = ease_in_out; break;
       case '3': if(!moving) mode = ease_in;     break;
       case '4': if(!moving) mode = ease_out;    break;
       case '5': // Up (faster)
        if((!moving) && speedIdx) speedIdx--;
        break;
       case '6': // Down (slower)
        if((!moving) && (speedIdx < (N_SPEEDS-1))) speedIdx++;
        break;
       case '7': // Left (home)
        digitalWrite(LED, LOW);
        motor->step(prevSliderPos, BACKWARD, DOUBLE);
        motor->release();
        prevSliderPos = 0;
        moving        = false;
        break;
       case '8': // Right (start/pause)
        if(!moving) { // Don't double-start
          digitalWrite(LED, LOW);
          moving    = true;
          startTime = micros();
        }
        break;
      }
    }
  }
}

boolean checkCRC(uint8_t sum, uint8_t CRCindex) {
  for(uint8_t i=2; i<CRCindex; i++) sum -= (uint8_t)ble.buffer[i];
  return ((uint8_t)ble.buffer[CRCindex] == sum);
}

The photo just shows how the stepper motor is connected to the motor shield. Being that I am fairly new to projects like this I may have hooked it up wrong. Power supply is an 8xAA battery pack supplied by Adafruit.

My issue is that it seems to be making regular steps instead of microsteps. The amount of movement during each step is causing camera shake and choppy video during time-lapse sessions.

jbartman: My issue is that it seems to be making regular steps instead of microsteps.

You did not say that in your earlier Post.

I think you should address your question to Adafruit. I don't know if their motor shield can do microsteps or how you set that up if it can.

I have some motors that are similar (but not identical) to yours and I drive them with Pololu A4988 drivers. The A4988 drivers can certainly do microstepping.

...R

Without microstepping stepper motors move in discrete steps with lots of noise and vibration.

You almost never want to drive a stepper without microstepping.