Settare 1/16 step driver A4988

Sto impazzendo e non trovo da nessuna parte la soluzione: prima utilizzavo su arduino la shield ramps e per settare 1/16 di step del motore da driver A4988 mettevo semplicemente 3 jumper.

Ma solo su arduino, come faccio ad abilitare 1/16 di step????

Presa da questo link in italiano:

E dove viene indicato come abilitare gli step????
Allo schemino ci ero arrivato anche io, ma dalla breadboard cosa e come devo collegare ms0 ms1 ms2?

Nello schemino, dove c'e' L è low mentre H è high
Quindi metti a GND dove vedi L , e se H porti il Vcc (5V)

Nel caso di 1/16 quindi li metti tutti e tre a Vcc

Ok provo, se prendo fuoco sappi che sentirai 'cuoco muore incendiato non mentre cucinava ma mentre usava degli stepper'

Allora la soluzione è come dicevi tu.....piccolo problema, ho due A4988 e se su tutti e due porto a 5v i 3 MS, arduino non parte!

Posta uno schema di tutti i collegamenti.


Allora l'errore stava nel fatto che collegavo gli step a +5, mentre invece vanno collegati a vvc.
Ora ho il problema che inserendo un ednstop meccanico non solo il motore non si stoppa, ma rallenta e basta (però è come fosse un problema elettrico!

Non sono un elettronico, ma... penso servano molte più info.

  1. alimenti da esterno (quel jack a destra) e poi dalla breadboard alimenti Arduino ? O alimenti il tutto via usb ?
  2. non esiste vvc su arduino, il pin VIN è un ingresso alla scheda, bypassa il regolatore del jack nero. Sul jack puoi dare da 7 a 12V, poi il regolatore abbassa a 5V, mentre su VIN puoi alimentare arduino direttamente con 5V non regolati (quindi occhio)
  3. personalmente non capisco quei collegamenti tra pulsante e pin 10/11

Alimento motore con ATX 12v, arduino con cavo USB. Il pin 11 è libero (forse è un'errore di fritzing), mentre il 10 va allo switch.

Allora, ho notato una cosa....credo sia un problema di codice! Provo a postarlo:


#include <AccelStepper.h>
#include <Bounce2.h>

//definizione delle costanti dei pin di Arduino
const int ledEnable = 13; //il led on board ci mostrerà lo stato di attivazione dei motori
const int pinSwEnable = 7;  //il bottone presente nel modulo joystick che abilita o disabilita il controllo
const int pinEnable = 8;  //i pin che comandano lo stato ENABLE dei driver A4988 sono in collegati in serie per questo basta un solo pin per gestirli entrambi
const int buttonEND_Xpin = 10;
const int buttonEND_Ypin = 11;
const int buttonSTART_Xpin = 12;
const int buttonSTART_Ypin = 13;

boolean endX = false;
boolean endY = false;
boolean stX = false;
boolean stY = false;

unsigned long debounceDelay = 10; //millisecondi per il debonuce del bottone

const int jX = A0;  //pin analogico che legge i valori per le X
const int stepX = 3;  //pin digitale che invia i segnali di STEP al driver delle X
const int dirX = 4; //pin digitale che invia il segnale DIREZIONE al driver delle X
long speedX, valX, mapX;  //variabili di gestione movimenti motore X

const int jY = A1;  //pin analogico che legge i valori per le Y
const int stepY = 5;  //pin digitale che invia i segnali di STEP al driver delle Y
const int dirY = 6; //pin digitale che invia il segnale DIREZIONE al driver delle Y
long speedY, valY, mapY;  //variabili di gestione movimenti motore Y

//variabili utilizzate dalla libreria AccelStepper
const int maxSpeed = 200;  //stando alla documentazione della libreria questo valore può essere impostato fino a 4000 per un Arduino UNO
const int minSpeed = 10; //velocità minima del motore
const float accelerazione = 30.0; //numero di step al secondo in accelerazione

const int treshold = 30;  //la lettura dei potenziometri non è mai affidabile al 100%, questo valore aiuta a determinare il punto da considerare come "Stai fermo" nei movimenti
long tresholdUp, tresholdDown;  //variabili di servizio per espletare il compito descritto sopra

boolean abilitato, muoviX, muoviY, enable;  //variabili di gestione dei movimenti

Bounce btnEnable = Bounce();  //istanzia un bottone dalla libreria Bounce

//istanzia i motori
AccelStepper motoreX(AccelStepper::DRIVER, stepX, dirX);
AccelStepper motoreY(AccelStepper::DRIVER, stepY, dirY);

void setup() {
  Serial.begin(9600);
  //inizializza valori
  speedX = speedY = 0;
  enable = false;
  
  //definizione delle modalità dei pin
  pinMode(ledEnable, OUTPUT);
  pinMode(pinEnable, OUTPUT);

  pinMode(buttonEND_Xpin, INPUT_PULLUP);
  pinMode(buttonEND_Ypin, INPUT_PULLUP);
  pinMode(buttonSTART_Xpin, INPUT_PULLUP);
  pinMode(buttonSTART_Ypin, INPUT_PULLUP);
     
  pinMode(pinSwEnable, INPUT_PULLUP); //l'input dello switch ha bisogno di essere settato come INPUT_PULLUP

  digitalWrite(ledEnable, enable);
  digitalWrite(pinEnable, !enable); //I driver A4988 disabilitano i comandi al motore se sul pin ENABLE ricevono un segnale HIGH per questo motivo il valore è opposto a quello del LED

  //configura il bottone del joystick utilizzando la libreria Bounce
  btnEnable.attach(pinSwEnable);
  btnEnable.interval(debounceDelay);

  //calcola range valori entro i quali considerare la posizione del joystick come "Stai fermo"
  tresholdDown = (maxSpeed / 2) - treshold;
  tresholdUp = (maxSpeed / 2) + treshold;

  //configura parametri dei motori
  motoreX.setMaxSpeed(maxSpeed);
  motoreX.setSpeed(minSpeed);
  motoreX.setAcceleration(accelerazione);

  motoreY.setMaxSpeed(maxSpeed);
  motoreY.setSpeed(minSpeed);
  motoreY.setAcceleration(accelerazione);
}

void loop() {
  //esegui funzione di controllo e lettura del bottone che determina lo stato di abilitazione
  checkEnable();

  digitalWrite(ledEnable, enable);  //mostra stato di abilitazione tramite il led su pin 13
  digitalWrite(pinEnable, !enable); //imposta valore opposto sui pin ENABLE dei driver

  //esegui lettura analogica dei valori provenienti dai potenziometri del joystick
  valX = analogRead(jX);
  valY = analogRead(jY);

  //mappa i valori letti in funzione della velocità inima e massima
  mapX = map(valX, 0, 1023, minSpeed, maxSpeed);
  mapY = map(valY, 0, 1023, minSpeed, maxSpeed);
  endX = digitalRead(buttonEND_Xpin);
  //esegui funzione di comando dei motori
    if (digitalRead(buttonEND_Xpin) == LOW) {
        endX = true;
    }
    if (digitalRead(buttonEND_Ypin) == LOW) {
        endY = true;
    }
     if (digitalRead(buttonSTART_Xpin) == LOW) {
        stX = true;
    }
    if (digitalRead(buttonSTART_Ypin) == LOW) {
        stY = true;
    }
  pilotaMotori(mapX, mapY, endX, endY, stX, stY);
}

void pilotaMotori(long mapX, long mapY, int endY, int endX, int stX, int stY) {
if (endX != true && stX != true){
  if (mapX <= tresholdDown) {
    //x va indietro
    speedX = -map(mapX, tresholdDown, minSpeed,   minSpeed, maxSpeed);
    muoviX = true;
  } else if (mapX >= tresholdUp) {
    //x va avanti
    speedX = map(mapX,  maxSpeed, tresholdUp,  maxSpeed, minSpeed);
    muoviX = true;
  } else {
    //x sta fermo
    speedX = 0;
    muoviX = false;
  }
}

  if (mapY <= tresholdDown) {
    //y va giù
    speedY = -map(mapY, tresholdDown, minSpeed,   minSpeed, maxSpeed);
    muoviY = true;
  } else if (mapY >= tresholdUp) {
    //y va su
    speedY = map(mapY,  maxSpeed, tresholdUp,  maxSpeed, minSpeed);
    muoviY = true;
  } else {
    //y sta fermo
    speedY = 0;
    muoviY = false;
  }

  if (muoviX) {
    motoreX.setSpeed(speedX);
    motoreX.run();
  } else {
    motoreX.stop();
  }

  if (muoviY) {
    motoreY.setSpeed(speedY);
    motoreY.run();
  } else {
    motoreY.stop();
  }
}


void checkEnable() {
  btnEnable.update();
  if (btnEnable.fell()) {
    enable = !enable;
  }
}