hulp nodig arduino uno met 3 velleman motorshields ka03 (vma03)

hallo allemaal,
ik heb dus een arduino uno met daarop 3 motorshields van velleman.
Ik ben een beginner in het hele concept .
De bedoeling is om de 3 stappenmotoren met ieder 1 shield constant te laten draaien met ieder zijn eigen ingestelde snelheid liefst via rpm.
Ik heb al vanalles geprobeerd, ben nu een beetje radeloos.
Ik zoek iemand die mij nu een programma kan schrijven voor mij .
het is de bedoeling om een tekenmachine te maken (lissagraph).
Degene die mij een programma kan schrijven die krijgt als beloning verscheidene tekeningen opgestuurd

Hallo Maarten van 37 jaar oud, welkom.

Arduino is erg leuk, en ook laagdrempelig.
Maar het is wel opgezet om iets van te leren.
Dat leren betekent dat je niet moet verwachten dat je van niets ineens een heel nuttig project zult kunnen maken.
Natuurlijk is het mogelijk om iemand te vragen het werk voor je te doen.
Maar is het niet veel leuker als je het zelf kunt, (ongeveer) snapt wat er gebeurt en zelf aanpassingen (verbeteringen/uitbreidingen) zult kunnen maken ?

Als je hulp nodig hebt zijn er hier best veel mensen die je er graag bij helpen, maar niet erg veel die het werk voor je willen doen (want het moet wel leuk blijven).

Omdat je project lissagraph heet, is het de bedoeling dat er iets met lissajous figuren gedaan word ?

Die motorshields kun je in ieder geval wel combineren, je kan per shield en per signaal 3 Arduino pins instellen.
Daarmee kun je dus ook 3 shields tegelijkertijd gebruiken.

Van alles geprobeerd zegt niet erg veel.
Geen idee wat je dan echt allemaal al geprobeerd hebt.
Heb je bijvoorbeeld al een enkele motor aan de praat gekregen ?
Je moet niet proberen alles in 1 keer te doen, stapje voor stapje dingen voor mekaar krijgen.

allereerst bestaan er diverse soorten lissagraph, cartesiaans, rond, en nog veel andere typen.
vroeger maakten we die met een xy plotter helemaal analoog.

Maar ach
de software van velleman is niet bruikbaar, dus zoek eens naar stepper op je IDE.

prik 1 shield op je arduino
sluit de stappenmotor aan zoals de tekening van velleman.
sluit een externe voeding aan, want de Vin kan niet veel stroom leveren zet deze op 9 Volt en alleen aanzetten als programma loopt. Hoeveel volt zijn jouw motoren?
de L298 heeft problemen met 5 Volt extern.

zet de jumper op extern
en de jumpertjes op 3,2,9,8
in de setup(); komt dan:

de enable uitgangen HIGH zetten dus digitalwrite 3,high
en digitalwrite 9,high
de stepper functie wordt dan stepper1 (100,2,8)
dit zou voldoende moeten zijn om de motor te laten draaien.
de loop leeg laten voor nu.
telkens als je reset gaat motor lopen.

En nee ik ga je niet een kant en klaar programma geven (ik wil wel helpen)
stepper2 is 4 en 12 (jumpers op het tweede shield dus op 5,4,10,12
stepper3 is 7 en 13 jumpers op derde shield dus 6,7,11,13

probeer maar eens en laat wat horen hier.

Bedankt alvast voor de feedback ,
ik had de hoop al bijna opgegeven. ik ben begonnen met de arduino met 15 projecten om de basis te leren maar daar staat niets in van stappenmotoren aansturen ik heb op het internet al veel drivers gezocht die in arduino geschreven zijn, maar bij mij schokt of trilt de motor alleen maar,
ik weet dat de draden juist zijn aangesloten. ik heb 3 motoren van 12v 350mA.
hieronder heb ik mijn code geplakt, mijn motor schokt weer ,het probleem is omdat ik geen voorbeeld heb weet ik niet wat ik nu weer allemaal vergeten ben.Er zit geen fout in wat ik al heb geschreven, dat is al iets.

#include <Stepper.h>

 int pwr_a = 3;
 int pwr_b = 9;
 int dir_a = 2;
 int dir_b = 8;
 
int stepDelay = 600;

const int stepsPerRevolution = 200;

Stepper myStepper(stepsPerRevolution, 3, 9, 2, 8);

void setup() {
  // put your setup code here, to run once:
digitalWrite(pwr_a,HIGH);
digitalWrite(pwr_b,HIGH);
digitalWrite(dir_a,LOW);
digitalWrite(dir_b,LOW);
 

}

void loop() {
  // put your main code here, to run repeatedly:

}

Hoe voed je het geheel ?

Je moet de shield voeden uit een andere voeding dan die voor de Arduino.
Verder moet die voeding ook veel meer stroom kunnen leveren dan alleen voor een Arduino nodig is.
Als je motor nu staat te schokken met de boven geposte code, dan komt dat omdat deze code steeds weer opnieuw begint.
Daar kan ik maar 1 oorzaak voor bedenken, en dat is dat de voeding te zwaar belast word, en zo de Arduino reset.
De bovenstaande code laat de motor 1 stap zetten, en doet vervolgens helemaal niets.

Maar iets doet me vermoeden dat er meer is dat niet klopt.
De code zoals die daar staat, lijkt meer op een combinatie van 2 heel verschillende sketches met motorshields.
Namelijk een die voor een stappenmotor is bedoeld, en eentje die voor 2 gewone motoren zijn bedoeld.
Want in de setup word er ergens spanning op gezet, en er niet meer afgehaald.
Een stappenmotor zou dan 1 stap zetten, en blijven staan (je kan m met de hand ook niet meer draaien dan).
Maar je hebt stepper.h en in setup stuur je de motor aan zonder stepper.h te gebruiken, dus door de uitgangen van de Arduino rechtstreeks aan te sturen.
Mogelijk doe je daar zelfs schade mee aan je stappen motor, omdat er nergens iets is wat wijst op een vorm van stroombegrenzing.
Dat is er niet in de hardware voor zover ik dat kan zien, en zeker niet in de code voor de motor.
Nou kan ik me natuurlijk vergissen hierin, maar het lijkt me goed toch nog eens naar de code te kijken.

Ik zou vragen of de motor warm word, maar dat zal meevallen omdat er ergens anders dus schijnbaar al een of andere beveiliging ingrijpt (hoop ik).
Welke kleur zijn de LEDs naast de motoraansluitingen ?

oke ik ben weer een stapje verder
ik heb een programma gevonden wat 1 stappenmotor op een vellemankit aanstuurt en ik kan de snelheid aansturen door de delay te veranderen maar ik zou uiteindelijk mijn snelheid willen aanpassen door de rpm in te stellen.
ik heb een voeding van 12v wel maar 1000mA. Maar ik ga als alles werkt mij een labo voeding halen.

// Initializing pins
const int pwr_a = 3;
const int pwr_b = 9;
const int dir_a = 2;
const int dir_b = 8;

const int STEPS = 200*2; //total count of halfsteps per full rotation (*2 for half steps!)

// e.g. 1.8deg stepper => 200 steps => 400 halfsteps
int currStep = 0; //current step, corresponds to angular position, limits: 0…STEPS
int sub = 0; //current halfstep within repeating sequence (8 halfsteps), limits: 0…7

int stepdelay_slow = 15000; //Wait time between steps (microseconds) - slow drive snelheid

void setup()
{
// Initialize the pins, in the correct type of mode.
pinMode(pwr_a,OUTPUT);
pinMode(pwr_b,OUTPUT);
pinMode(dir_a,OUTPUT);
pinMode(dir_b,OUTPUT);
}

void loop()
{
subStep(200, stepdelay_slow); //50 halfsteps forward, slow
//wait 1 second
subStep(200, stepdelay_slow); //50 halfsteps backward, slow
//wait 10 seconds
}

// This method is called in order to make the stepper motor make a number of sub steps (depending on your wiring).
// Variable steps is for number of steps (forwards = positive, backwards = negative)
// stepDelay is for waiting time between steps in microseconds => bigger means lower speed, smaller means higher speed

void subStep(long steps, int stepDelay){

// The function will run for the amount of times called in the method.
// This is accomplished by a while loop, where it will subtract 1 from the amount after every run (forwards).
// In case of backward rotation it will add 1 to the negative number of steps until 0 is reached.

while(steps!=0)
{

if(steps>0){currStep++;} //increment current halfstep (forward)
if(steps<0){currStep–;} //decrement current halfstep (backward)

if(currStep>STEPS){currStep= currStep-STEPS;} //position >360deg is reached => set position one turn back
if(currStep<0){currStep= currStep+STEPS;} //position <0deg is reached => set position one turn forward

sub = currStep%8; //determine the next halfstep

switch(sub)
{
case 0:
// Starting position (if repeated, ful step (4))
// EXPLINATION: in this case, both our power are high.
// Therefore both coils are activated, with their standard polarities for their magnetic fields.
digitalWrite(pwr_a,HIGH);
digitalWrite(pwr_b,HIGH);
digitalWrite(dir_a,HIGH);
digitalWrite(dir_b,HIGH);
break;

case 2:
//Full step (1)
// EXPLINATION: In this case, the b-coil is activated as in previous cases.
// But the a-coil now has it’s direction turned on. So now it’s active, but with the reversered polarity.
// By continuing this pattern (for reference: http://www.8051projects.net/stepper-motor-interfacing/full-step.gif) , you’ll get the axis to turn.
digitalWrite(pwr_a,HIGH);
digitalWrite(pwr_b,HIGH);
digitalWrite(dir_a,HIGH);
digitalWrite(dir_b,LOW);
break;

case 4:
// Full step (2)
digitalWrite(pwr_a,HIGH);
digitalWrite(pwr_b,HIGH);
digitalWrite(dir_a,LOW);
digitalWrite(dir_b,LOW);
break;

case 6:
// Full step (3)
digitalWrite(pwr_a,HIGH);
digitalWrite(pwr_b,HIGH);
digitalWrite(dir_a,LOW);
digitalWrite(dir_b,HIGH);
break;

}

delayMicroseconds(stepDelay); //Waiting time to next halfstep

if(steps>0){steps–;} //decrement of remaining halfsteps of forward rotation
if(steps<0){steps++;} //increment of remaining halfsteps of backward rotation
}
}

// This method simply just turn of the motors, called when ever we don’t need the motors anymore.
// In this way, we won’t fray the circuit or coils.
// Note 1: Motor has no torque anymore
// Note 2: If current position is between full steps, motor will move for a half step!
void TurnOfMotors(){
digitalWrite(pwr_a,LOW);
digitalWrite(pwr_b,LOW);
digitalWrite(dir_a,LOW);
digitalWrite(dir_b,LOW);
}

Maarten, code graag in code tags.
Dit leest heel vervelend.

hoe moet dit ?

// Initializing pins
const int pwr_a = 3;
const int pwr_b = 9;
const int dir_a = 2;
const int dir_b = 8;



const int STEPS = 200*2;      //total count of halfsteps per full rotation (*2 for half steps!)

                              // e.g. 1.8deg stepper => 200 steps => 400 halfsteps
int currStep = 0;             //current step, corresponds to angular position,  limits: 0...STEPS
int sub = 0;                  //current halfstep within repeating sequence (8 halfsteps), limits: 0...7


int stepdelay = 1000;    //Wait time between steps (microseconds) - slow drive      snelheid


void setup()
{
  // Initialize the pins, in the correct type of mode.
    pinMode(pwr_a,OUTPUT);
    pinMode(pwr_b,OUTPUT);
    pinMode(dir_a,OUTPUT);
    pinMode(dir_b,OUTPUT);
}


void loop()
{
    subStep(200, stepdelay);        //50 halfsteps forward, slow
                           //wait 1 second
    subStep(200, stepdelay);       //50 halfsteps backward, slow
             //wait 10 seconds
}


// This method is called in order to make the stepper motor make a number of sub steps (depending on your wiring).
// Variable steps is for number of steps (forwards = positive, backwards = negative)
// stepDelay is for waiting time between steps in microseconds => bigger means lower speed, smaller means higher speed

void subStep(long steps, int stepDelay){

  // The function will run for the amount of times called in the method.
  // This is accomplished by a while loop, where it will subtract 1 from the amount after every run (forwards).
  // In case of backward rotation it will add 1 to the negative number of steps until 0 is reached.

    while(steps!=0)
        {

        if(steps>0){currStep++;}       //increment current halfstep (forward)
        if(steps<0){currStep--;}       //decrement current halfstep (backward)

        if(currStep>STEPS){currStep= currStep-STEPS;}         //position >360deg is reached => set position one turn back
        if(currStep<0){currStep= currStep+STEPS;}             //position <0deg   is reached => set position one turn forward

        sub = currStep%8;           //determine the next halfstep

        switch(sub)
        {
               case 0: 
        // Starting position (if repeated, ful step (4))
        // EXPLINATION: in this case, both our power are high.
        // Therefore both coils are activated, with their standard polarities for their magnetic fields.
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,HIGH);
        digitalWrite(dir_b,HIGH);
                break;

        

        case 2:
                //Full step (1)
        // EXPLINATION: In this case, the b-coil is activated as in previous cases.
        // But the a-coil now has it's direction turned on. So now it's active, but with the reversered polarity.
        // By continuing this pattern (for reference: http://www.8051projects.net/stepper-motor-interfacing/full-step.gif) , you'll get the axis to turn.
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,HIGH);
        digitalWrite(dir_b,LOW);
                break;

        

        case 4:
        // Full step (2)
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,LOW);
                break;

        

        case 6:
        // Full step (3)
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,HIGH);
                break;

        
         }

        delayMicroseconds(stepDelay);        //Waiting time to next halfstep

        if(steps>0){steps--;}      //decrement of remaining halfsteps of forward rotation
    if(steps<0){steps++;}      //increment of remaining halfsteps of backward rotation
    }
}


// This method simply just turn of the motors, called when ever we don't need the motors anymore.
// In this way, we won't fray the circuit or coils.
// Note 1: Motor has no torque anymore
// Note 2: If current position is between full steps, motor will move for a half step!
void TurnOfMotors(){
   
}

Door de post met de code aan te passen, door op edit (niet quick edit) te klikken.
Dan selecteer je alle code, en klik je op de code knop, die met het <> icoon erop.

De code die je hebt geplaatst heeft een aantal problemen waardoor deze niet geschikt is om te gebruiken voor jouw doel, namelijk 3 motoren tegelijk laten werken.

Het ene probleem is dat er gebruik word gemaakt van delay (ook al is het in microseconden, het gebeurt elke keer wel 200 maal).
Een delay zet zowat alles stil en is daarmee blokkerende code.
Dat betekent dus dat erop dat moment helemaal niet anders gedaan word dan wachten tot de motor een stukkie gedraaid is.

Het andere probleem is dat de aansturing van de motor begint met een while.
Een while zegt: Doe alleen het volgende zolang nog niet aan mijn voorwaarde is voldaan.
Die voorwaarde is hier dat er 200 stappen gezet moeten zijn, oftewel een heel rondje gedraaid moet zijn.
Ook dat is blokkerende code, en ook dat wil je niet hebben.

Je maakt hier dus geen gebruik meer van de Stepper library, en stuurt de motor zelf aan.
Das mooi omdat je dan de kans hebt om te leren hoe dat nou gaat met zo’n stappenmotor.
Moet je wel de code kunnen lezen en begrijpen uiteraard.

Wanneer je 3 motoren bijna tegelijkertijd wil kunnen aansturen, zul je alle blokkerende code eruit moeten slopen er daar een alternatief voor moeten vinden.
Onderaan maak ik een opmerking over blink without delay, en das niet voor niets.

Ik heb geen idee of je met de Stepper library een mogelijkheid hebt om iets met RPM te doen.
Ik zou gaan voor het uitrekenen hoe je RPM in stappen per tijdseenheid kan omzetten, en even kijken hoeveel stappen je eigenlijk überhaupt nodig hebt voor 1 rondje.

Dit zijn al aardig wat opdrachten om dichter bij je doel te komen.
Doe het stap voor stap, dan behoud je het overzicht.

Mas3 heeft natuurlijk helemaal gelijk, maar je hebt dus code gevonden waarmee je dus een motor laat draaien, prima, dan weet je dat dat wel werkt.
1000 mA is voorlopig voldoende hoor.
Heb je deze aangesloten op de externe aansluitpunten van de shield prima.
Je mag deze zelfs ook met Vin verbinden dan wordt je UNO ook gevoed.

Nu even over het stappen:
zoals je ziet in jouw programma staan de enable (PWR) altijd aan, dat is prima. (In stepper moet jij dat dus doen en alleen de steppinnen moet je opgeven vandaar.

Mas3 heeft natuurlijk gelijk dat dit progje alleen met 1 shield werkt. maar niet getreurd dat volgt nog.
Het voornaamste was natuurlijk om te testen of je spul wel werkt.

Persoonlijk zou ik accelstepper gebruiken

// MultiStepper.pde
// -*- mode: C++ -*-
//
// Shows how to multiple simultaneous steppers
// Runs one stepper forwards and backwards, accelerating and decelerating
// at the limits. Runs other steppers at the same time
//
// Copyright (C) 2009 Mike McCauley
// $Id: MultiStepper.pde,v 1.1 2011/01/05 01:51:01 mikem Exp mikem $
#include <AccelStepper.h>


const int pwr1_a = 3;
const int pwr1_b = 9;
const int dir1_a = 2;
const int dir1_b = 8;
// hier de andere
const int pwr2_a = 5;
const int pwr2_b = 10;
const int dir2_a = 4;
const int dir2_b = 12;
const int pwr3_a = 6;
const int pwr3_b = 11;
const int dir3_a = 7;
const int dir3_b = 13;

// wel even nakijken ik kan ook fouten maken.


// Define some steppers and the pins the will use
AccelStepper stepper1(AccelStepper::FULL2WIRE,dir1_a,dir1_b); 
AccelStepper stepper2(AccelStepper::FULL2WIRE, dir2_a,dir2_b);
AccelStepper stepper3(AccelStepper::FULL2WIRE, dir3_a,dir3_b);

  // Initialize the pins, in the correct type of mode.
    pinMode(pwr1_a,OUTPUT);
    pinMode(pwr1_b,OUTPUT);
    pinMode(pwr2_a,OUTPUT);
    pinMode(pwr2_b,OUTPUT);
    pinMode(pwr3_a,OUTPUT);
    pinMode(pwr3_b,OUTPUT);

void setup()
{  
digitalWrite(pwr1_a,HIGH);
digitalWrite(pwr1_b,HIGH);
digitalWrite(pwr2_a,HIGH);
digitalWrite(pwr2_b,HIGH);
digitalWrite(pwr3_a,HIGH);
digitalWrite(pwr3_b,HIGH);

// hier worden dus settings neer gezet die je uiteraard kunt veranderen.

    stepper1.setMaxSpeed(200.0);
    stepper1.setAcceleration(100.0);
    stepper1.moveTo(24); // deze maakt dus 24 stappen absoluut
    
    stepper2.setMaxSpeed(300.0);
    stepper2.setAcceleration(100.0);
    stepper2.moveTo(1000000); // deze een hele hoop
    
    stepper3.setMaxSpeed(300.0); // deze draait iets sneller
    stepper3.setAcceleration(100.0);
    stepper3.moveTo(1000000); 
}
void loop()
{
    // Change direction at the limits
    if (stepper1.distanceToGo() == 0)  // als stepper1 op positie is dan gaat de motor naar -24 lopen.
        stepper1.moveTo(-stepper1.currentPosition());
/* Hier kan dus een heel sequentie onder komen die allerlei dingen gaat besturen, komt nog
*/
   // deze run dingen moeten zo vaak als mogelijk aangeroepen worden.
 stepper1.run();
    stepper2.run();
    stepper3.run();
/* die kijken of een stappenmotor een stap moet zetten (vanwege de snelheid, en kijken of de motor moet versnellen, vertragen of stoppen.)
in deze opzet blijft er altijd spanning op de motoren staan.
*/
}

dus eerst even accelstepper ophalen en spelen maar.
Als je de rekenmodule voor je figuren zelf wilt maken prima, (leuke vaardigheid)
kijk eens op mathiversity, cool man.

In het evoluon stond in de kelder ook een lissajous maker van meccano, hierbij werden alleen maar de snelheden verandert van de 2 motoren, begin daar maar eens mee, een meccanograph.

Hou in je achterhoofd even dat je straks ook de pen omhoog wilt doen, dan kun je een plotter maken.

Zoals je ziet is in shooters code ook geen RPM aanwezig.
Dat komt omdat RPM voor een stappenmotor niet erg logisch is.
Bij een stappenmotor draait nou eenmaal alles om de stappen.

Dus is het raadzaam om of een rekensom in je programma te stoppen, of een andere user interface (beeldscherm/lampjes/knopjes) te bedenken.

die rpm komt door het maken van de lissajous dat is helemaal afhankelijk van de ratio van de rpm tussen de motoren.
dat gaat overigens prima met stappenmotoren, het wordt wel wat hoekiger, maar als je het langzaam doet gaat het prima, met een grote vertraging zoals 1 op 24 of groter want dan krijg je een groot aantal punten, daar heb je met een analoge motor mider last van, dat blijft continu in beweging.

ik krijg een foutmelding dat hij de library van accelstepper niet herkent waar kan ik die downloaden want ik weet dat er bestaan op internet.

hier is ook nog een youtube link naar waar ik naar toe wil werken.
de man gebruikt wel een heel ander programma ,waarschijnlijk ook veel moeilijker.

probeer eens google?

accelstepper staat op deze website, ga naar arduino.cc en tik accelstepper in.

als het niet lukt geef dan PM stuur ik hem op.
wel in library zetten natuurlijk

filmpje gekeken, heel leuk, vooral het begin, lekker oud.

Wat hij feitelijk doet is 3 snelheden instellen, 2 radi, en 2 lengtes, 1 faseverschuiving(de hoek tussen de X en Y motor.

de snelheden zijn geen probleem, dat kan met die accelstepper prima.
De oplossing met die magneten is geniaal, weliswaar niet reproduceerbaar, maar wel heel mooi.

Zoals je ziet gebruikt hij vertragingen, vooral op de grote zit een heel grote. en heel grote stappenmotoren en heel mooie aansturingen. dat gaat niet met simpele L298, maar ach.

Het model werkt trouwens met 1 motor en een paar tandwielen, maar ach.
Je hoeft natuurlijk niet zo een mooie ronde tafel te maken, op een simpel plankje een A4 velletje leggen gaat ook prima.

Laat even horen hoe het verder gaat.

er was een foutmelding bij de pinmode ik heb de void setup boven de pinmode moeten zetten nu werkt het programma .Alvast bedankt om mij al zover te helpen.
ik zal een foto posten als het prototype in mekaar staat ,het zal wel nog niet voor morgen zijn :smiley: .

als je een pinmode probleem hebt, heb je ergens een pin 2 keer gebruikt.

dat betekent wel dat je accelstepper dus goed aan de gang hebt.

je hebt met een arduino dus veel meer mogelijkheden, dan de originele, zet acceleratie op 0 dan is de motor gelijk op snelheid
je zult merken dat als de ratio eenvoudig is er snel herhaling optreed.
ben je ooit in hengelo bij HEIM geweest?

Je kunt dit soort figuren ook maken met 2 motoren (zoals een oscilloscoop werkt.
maar dan moet je de hele beweging uitrekenen.

hier is een prototype alles werkt naar behoren, juist met de snelheid bij de stappenmotoren als ik de snelheid bij de 2 motoren van de armen op bv 100 zet lopen ze gelijk, dat is normaal maar als ik 100 en 101 wil dan lopen ze ook nog gelijk en dat gaat zo door tot 100 en 109.bij 100 en 110 gaan ze verschillend maar wel heel verschillend ik zou ze graag miniem verschillend van snelheid van mekaar laten draaien.
zou het kunnen dat het aan mijn stappenmotoren ligt dat ze te klein zijn ?
Ofwel moet ik met verdrijvingen gaan werken dat verhouding automatisch kleiner word van 100 en 110
naar bv 5000 en 5010 .