[OPGELOST] Steppermotor werkt even, daarna reageert Arduino Micro niet meer

Hallo lezers,

Voor mijn eerste Arduino Project heb ik mijzelf een beetje in het diepe gegooid.
Dit is wat ik probeer te bereiken. En voor een aantal minuten werkte dat goed, maar na de 3e keer aanzetten knipperde het powerlampje op de Arduino, en tikte de motor met dezelfde soort puls. Wanneer ik de arduino geïsoleerd aansluit via USB brand het powerlampje constant, maar wordt de Micro niet meer herkend door de IDE. In een vlaag van verstandsverbijstering heb ik een vervangende Arduino geplaatst en ook die heeft het zelfde lot ondergaan. Nu heb ik nog twee namaak Pro Micro’s over om het project mee af te ronden, tenzij de Arduinos nog te redden zijn. Ik weet niet of ze bricked zijn of doorgebrand, maar er is geen visuele schade zichtbaar. Wel worden ze redelijk warm bij het aansluiten.

Bijgevoegd heb ik een foto van het projectje en ik heb geprobeerd het schema te tekenen, dit is niet bijzonder goed gelukt, mijn excuses.

Ik gebruik een 12V adapter om de stepper-driver van stroom te voorzien en het logic-gedeelte van de stepper-driver(TMC2100) wordt gevoed via de 5V output van de arduino, die op zijn beurt gevoed wordt via USB.

Wat mij zelf opvalt is dat ik in de code maar 2 pins aangeef, een 3e zou misschien naar de Enable moeten van de Driver. Ik heb de kabel wel verbonden maar die niet in de code aangegeven, is het überhaupt nodig dit te doen? Het heeft in principe al gewerkt zónder deze in de code te declaren.

Verder heb ik slechts een 10V condensator tussen de + en - van de adapter gedaan op aanraden van iemand. Ik heb echter geen idee waarom, en of dat wel goed gaat aangezien het een 12V adapter is. Ook hier gene zichtbare schade, tot zover.

Ik ben geen fervente programmeur, en er zijn waarschijnlijk diverse betere manieren om te bereiken wat ik wil. Maar hier is mijn poging:

#include "AccelStepper.h"

// Define a stepper and the pins it will use
AccelStepper stepper(4,5);
int StepSpeed;      // scaled version of stepper speed in steps per second(?)), uses a cosine to vary in speed
int Counter;    // counts the amount of updates before adding to the index of the cosine; The time it takes to progress the cosine
int Index;      // drives the cosine that varies the stepperspeed (Scale)
int WavDir;     // direction of rotation
int Mod;        // introduces an extra modulation in speed for extra unpredictability 
int ModCounter; // counts amount of updates before adding to the index of the extra mod
int ModIndex;   // index that in turn drives another cosine to extra modulate the speed, maybe this should be a sine wave instead, 

bool WavDirEva;

void setup()
{  

  int speed = 1000;
  
  stepper.setMaxSpeed(speed);
  stepper.setAcceleration(100);
  stepper.setSpeed(1000);
  Serial.begin(9600);
  Counter = 0;
  StepSpeed = 0;
  Index = 0;
  Mod = 0;
  ModIndex = random(0,628);
  WavDir = random(-1,1);
  if (WavDir== 0) {WavDir = 1;}
  WavDirEva = false;

}

void loop()
{


Counter = Counter + 1;
if  (Counter >= Mod) // after this many updates changes speed by adding 1 index
    {
    StepSpeed = ((( cos ( Index / 100.0 ) * -0.5 ) + 0.5 ) * 1000 ) * WavDir; // cosine because it starts at the most outward amplitude, making it more smooth around both extremes
    // the * -1 + 1 makes the cos start at 0 and climb up to, perhaps better to multiply the StepSpeed with the mod rather than add it. So that the mod can have a random beginning point without losing the "fade in"
    Index = Index + 1;
    Counter = 0; 
    if  (Index == 628){ //6,28 = (2*pi) almost a full cos cycle.
        Index = 0;
        
        }
      // Serial.println(StepSpeed);
    }


ModCounter = ModCounter + 1; //introduces an extra modulation for stepperspeed.
if (ModCounter == 10000)
  {
  ModIndex = ModIndex + 1;
  Mod = (((cos(ModIndex/100.0)*-0.5)+0.5)*1000)+1500; // Maximum should be 1000 steps p/s. So compensate in StepSpeed
  ModCounter = 0;
  if(ModIndex == 628)
  {
    ModIndex = 0;
  }
 // Serial.println(Mod);
 
  if  (StepSpeed != 0 && WavDirEva == true)
      { 
      WavDirEva = false;
      }
  
  if  (StepSpeed == 0 && WavDirEva == false) // somewhere here something is still wrong, causing too often a negative stepspeed
      {
      WavDir = random(-1,1);
      if  (WavDir== 0) 
          {
          WavDir = 1;
          }
 //     Serial.println(WavDir);
      WavDirEva = true;
      }
      Serial.println(StepSpeed);
//      Serial.println(Mod);
//      Serial.println(WavDirEva);
  }

stepper.move(StepSpeed);
stepper.run();
}

Wat ik wil dat de motor doet is vanuit stilstand heel vloeiend versnellen, maar over het algemeen langzaam blijft. Dan weer vertraagd tot stilstand, en af en toe van richting veranderd bij het 0-punt van de snelheid.

Ik heb me laten vertellen dat ik de Arduino zelf samen met de driver kan voeden met de 12V adapter. En alsnog het Logic-deel van de driver voed via de 5V output van de Arduino Micro.

Al met al ben een ontzettende beginner en heb ik eigenlijk nauwelijks een idee van wat ik aan het doen ben, met name aan de hardware kant. Kan iemand me helpen? Hulp wordt ontzettend gewaardeerd!

Jorick

je schema is prima hoor je hebt helemaal gelijk met die 12 Volt naar 5 Volt.
dat betekent dus dat je arduino zelfs los van de USB zijn programma draait.
op het driver printje zit een potmeter die de stroom regelt door het motortje, want 12 Volt is vrij veel voor een stappenmotor en zal dus erg warm worden.
als je de stroom regelt gaat dat wel goed
minimale spanning is 7.5 Volt omdat daaronder de driver niet meer werkt.

Je programma zit op het eerste gezicht wel erg ingewikkeld in elkaar. Zet eens een paar variabelen via serial.print op je monitor.
zet wat commentaar in je programma zodat je kunt volgen wat er gebeurt,.
en inderdaad met accelstepper kun je mooi starten en stoppen.

Hee Paul,
Bedankt voor je antwoord! Weer wat geleerd over die potmeter.

Enig idee hoe hoog de stroom/spanning moet zijn, bij het regelen via die potmeter? De motor lijkt 1.7 A te vragen. Weet je hoe ik ik die meet, gaat dat via de Vref en de Ground, of de Vref en de Diag0/1?

Beide Arduino's verschijnen niet meer in de Port menu, en wanneer ik ze van 12V voorzie via de Vin komt er maar 3.0-3.5V uit de 5V output. Dat is vreemd, maar het zou in principe genoeg moeten zijn voor het logic-deel van de driver, dacht ik. Wat jij?

In meeste TMC2100 aansluitschema's staat een 3e pin verbonden met E, voor enable. Die gebruik ik nu niet, enig idee of dit verstandig is wél te doen?

Wat betreft programma, ik heb inderdaad niet de meest makkelijke weg gekozen waarschijnlijk, echter werkte het motorgedrag naar verlangen; een unipolaire Cosinus-modulator op de stapsnelheid, en een zelfde soort modulator die de snelheid van de eerste modulator weer beïnvloed. Ik heb in principe redelijk het gedrag bereikt dat ik zoek. Behalve dat niks het nu dus doet omdat de arduino's lijken te bokken. Zou het kunnen dat deze nog te reviven zijn? Anders moet ik overstappen naar de cheapy Pro Micro knock-offs die waarschijnlijk weer net even anders werken. Ze lijken heel erg op die van Sparkfun, wat mij doet denken dat ik daar aparte drivers voor moet installeren.

Also posted at:

de stroom kun je meten door de driver te meten, daar zit een aparte voeding en Gnd op, en daar kun je dus prima de stroom meten.
Een snelle methode is om af en toe even de motor temperatuur te voelen. Mag zeker niet boven de 100 graden komen.
dus moet aanraakbaar blijven.
als je object stil blijft staan kun je met die enable ook de stroom uitzetten en dat is dus gunstig voor stroomverbruik en de temperatuur.
Je moet echt die stroom beperken hoor want 1.8 Ampere bij 12 Volt is veel te veel voor die kleine motrtjes.
met accelstepper kun je dus elke stap versnellen met een waarde. je kunt zelfs verschillende motoren synchroon laten lopen etc.

Ik heb 1 van de laatste twee werkende pro micro’s doorgefikt. Ik probeerde de meting te doen maar ik heb nogal een trillende hand en raakte zodoende een ander component aan.
De tweede poging ging goed beter. Ik heb het voltage gemeten tussen GND en de potentiometer(op advies van youtube filmpje), en verlaagd naar 0.63V door die potentiometer te dimmen.

Bijgevoegd een fotootje van de huidige setup, aangezien hij iets anders is met nieuwe computertje.
Nieuwe code met enablepin.

#include "AccelStepper.h"

// Define a stepper and the pins it will use
AccelStepper stepper(5,6,3);
int StepSpeed;      // scaled version of stepper speed in steps per second(?)), uses a cosine to vary in speed
int Counter;    // counts the amount of updates before adding to the index of the cosine; The time it takes to progress the cosine
int Index;      // drives the cosine that varies the stepperspeed (Scale)
int WavDir;     // direction of rotation
int Mod;        // introduces an extra modulation in speed for extra unpredictability 
int ModCounter; // counts amount of updates before adding to the index of the extra mod
int ModIndex;   // index that in turn drives another cosine to extra modulate the speed, maybe this should be a sine wave instead, 

bool WavDirEva;

void setup()
{  

  int speed = 1000;
  
  stepper.setMaxSpeed(speed);
  stepper.setAcceleration(100);
  stepper.setSpeed(1000);
  Serial.begin(9600);
  Counter = 0;
  StepSpeed = 0;
  Index = 0;
  Mod = 0;
  ModIndex = random(0,628);
  WavDir = random(-1,1);
  if (WavDir== 0) {WavDir = 1;}
  WavDirEva = false;

}

void loop()
{


Counter = Counter + 1;
if  (Counter >= Mod) // after this many updates changes speed by adding 1 index
    {
    StepSpeed = ((( cos ( Index / 100.0 ) * -0.5 ) + 0.5 ) * 1000 ) * WavDir; // cosine because it starts at the most outward amplitude, making it more smooth around both extremes
    // the * -1 + 1 makes the cos start at 0 and climb up to, perhaps better to multiply the StepSpeed with the mod rather than add it. So that the mod can have a random beginning point without losing the "fade in"
    Index = Index + 1;
    Counter = 0; 
    if  (Index == 628){ //6,28 = (2*pi) almost a full cos cycle.
        Index = 0;
        
        }
      // Serial.println(StepSpeed);
    }


ModCounter = ModCounter + 1; //introduces an extra modulation for stepperspeed.
if (ModCounter == 10000)
  {
  ModIndex = ModIndex + 1;
  Mod = (((cos(ModIndex/100.0)*-0.5)+0.5)*1000)+1500; // Maximum should be 1000 steps p/s. So compensate in StepSpeed
  ModCounter = 0;
  if(ModIndex == 628)
  {
    ModIndex = 0;
  }
 // Serial.println(Mod);
 
  if  (StepSpeed != 0 && WavDirEva == true)
      { 
      WavDirEva = false;
      }
  
  if  (StepSpeed == 0 && WavDirEva == false)
      {
      WavDir = random(-1,1);
      if  (WavDir== 0) 
          {
          WavDir = 1;
          }
 //     Serial.println(WavDir);
      WavDirEva = true;
      }
      Serial.println(StepSpeed);
//      Serial.println(Mod);
//      Serial.println(WavDirEva);
  }

stepper.move(StepSpeed);
stepper.run();
}

Het huidige probleem is dat de setup simpelweg niet werkt. Het programmaatje lijkt goed te draaien obv wat ik terug zie komen in de monitor. Maar er zit geen enkele beweging in de motor. Ik heb al geprobeerd de motor te vervangen en ook de driver. Ik ben stuurloos. Moet er voor de namaak pro micro een sparkfun driver geinstalleerd worden?

de voeding van de driver moet zeker 7.5 Volt zijn, Is de Micro 5 Volt of 3.3
en wat zijn de poorten dan, want 3.3 als output werkt niet op 5Volt driver.
En ben gerust want iedereen overkomt dit soort simpele dingen en dan zitten er uren werk in.

Hee Paul,
Bedankt voor je volharding!

De steppendriver wordt met 12v gevoed, dezelfde 12V die ook de Pro Micro voedt. Het Logica deel van de driver kreeg volgens mij 5V van de Pro Mircro. Om dat te checken ging ik dat zojuist meten, ik was alleen vergeten dat voltage parallel gemeten moet worden ipv in serie. Met die fout heb ik zojuist mijn laatste computertje door laten fikken. :sob: Het is dan ook lang geleden dat ik zo hands-on met electronica bezig was.

Het was vrij zeker de 5V versie, wellicht had ik gewoon mijn geheugen moeten vertrouwen.
Hoe dan ook, het logica deel van de steppendriver kan overweg met 3 tot 5V als ik de pinout kan vertrouwen.

Ik ga dus wat nieuwe dingen moeten bestellen, want die doorgefikte 5V regulator vervangen gaat met mijn trilhanden zeker niet lukken. Denk jij dat het nodig is om een condensator tussen de + en - van de 12V voeding adapter te doen, zoals in de vorige foto te zien is? Zo ja: hoe weet je dan welke je nodig hebt. Ik heb een bak met oude condensators, maar geen daarvan is 12V en 47 microfarad.

Alsook: denk je dat dit project te draaien is op een Arduino Nano? Ik weet dat kleiner niet per sé handig is voor mijn handvastigheid, maar budget speelt na 4 computertjes slopen voor 1 projectje wel een rol. Ik dacht 3 nano's voor €22.80 plus een eventuele 12V condensator.

Fijne nieuwjaar!
Jorick

Ik had gisternacht een heel verhaal getypt, maar toch maar niet verstuurd.

Je nano's worden zonder de pinnen geleverd, en die heb je daarom zelf moeten solderen.
Dat is niet helemaal perfect gegaan, zo is op je foto te zien:

Voor zover ik het kan zien, is alleen pin 7 nagenoeg perfect, pins 1, 4, 8, 14 en A1 zien er erg slecht uit.

Voor condensatoren geldt dat groter ook OK is.
De kans dat je een 12 volt condensator gaat vinden is nagenoeg nul, en dat wil je ook helemaal niet.
Want je werkt met 12 volt en als er 12 volt op een condensator gedrukt staat, dan is dat de hoogste spanning die 'ie kan hebben.
En je wil juist oneffigheden met die condensator wegwerken, dus pieken en dalen ten opzichte van jouw 12 volt.
Daarom pak je een hogere waarde hiervoor, de eerstvolgende waarde is 16 volt, en dan 25 volt.
Maar ook als je een 50 volt condensator pakt is dat in orde (alleen zal die fysiek wat groter zijn, en z'n prijs ook).
47 micro Farad is niet heel veel, dus ik vraag me af of dat echt goed werken zal.
Maar ook daar geldt dat groter niet zo'n probleem is.
Dus 68 of 82, en zelfs 100 uF zal geen probleem zijn.
De draden waar je je condensator aan gesoldeerd hebt zijn een veel groter probleem en doen de werking van die condensator geen goed.
Ik snap wel waarom je dat gedaan hebt, maar als het echt niet anders kan, houd ze dan zo kort mogelijk.
Verder gebruik je een breadboard.
Breadboards zijn niet geschikt om vermogens doorheen te sturen.
Geen idee hoeveel stroom je motor verbruiken wil, maar om dat via een breadboard te doen is geen goed idee.

Overigens ziet die pen aan de rode draad en bij de motordriver er verdacht uit.
Het zwarte kunststof lijkt te zijn gaan smelten, of wellicht met lijm gefixeerd (dat laatste is bij meerdere van die stekkertjes te zien).
Deze "DuPont wires" van doorgaans Chinees fabricaat zijn berucht om de met regelmaat voorkomende slechte verbindingen die ze maken.

Dit zijn allemaal dingen die ik aan te merken heb op wat je in de foto laat zien, maar niet per se wat er misgaat, dus het blijft zoeken.

Ik raad je aan om voortaan geen metingen meer te doen terwijl de installatie onder spanning staat.
Zorg er eerst voor dat je meetpennen (correct) zijn aangesloten, en zet dan de spanning aan.
Voor een volgende meting eerst de spanning er af en dan de pennen op de volgende positie aansluiten en weer aanzetten.
Duurt iets langer, maar leeft ook langer, vermoed ik.
Een wat duurdere multimeter slaat alarm wanneer je een spanningsmeting instelt en de pennen in een stroom meet ingang hebt zitten.

Ontzettend bedankt voor je reactie, dat is een hoop nuttige informatie!

Wat betreft je reactie op de solderingen, klopt. Ben ik niet goed in, heb ook niet het beste gereedschap voor. Ik heb 2 nieuwe Arduino Micro’s besteld en wat kabeltjes van deze website.

Heb je een suggestie voor hoe ik het vermogen aansluit zonder breadboard?

Bedankt voor je tips omtrent metingen en welke condensator te gebruiken en hoe deze te verbinden.

Ik denk niet dat het plastic van de kabelpinnen is gesmolten, het gewoon goedkoop plastic gietwerk met uitstekende plastic braampjes hier en daar.

Jorick

Tja dat is een beetje een dingetje.

Soldeer goede draden rechtstreeks aan je driver en van de driver naar je voeding en motor.
Goede draden zijn niet te dik zodat je ze er aan kunt solderen zonder kortsluiting te maken, maar zeer zeker niet te dun zodat het vermogen er wel doorheen kan.
Je stuursignalen kun je wel prima via het breadboard doen want daar hoort geen vermogen doorheen te gaan.

Maar ja, dat solderen he...

Hee allen, bedankt voor de input.

Ik heb nu:

  • de driver los van het breadboard.
  • een 25 V, 100 uF Condensator tussen de + en - voor de arduino en driver.

Het logic deel van de driver wordt nog altijd gevoegd door de 5V output van de arduino.
Zie de bijgevoegde foto voor de nieuwe setup.

En mijn nieuwe code:

#include "AccelStepper.h"

// Define a stepper and the pins it will use
AccelStepper stepper(1,5,6); // the "1" tells the program we're using a driver, the 2nd arg is motorStepPin, the 3rd arg is motorDirPin
int StepSpeed;      // scaled version of stepper speed in steps per second(?)), uses a cosine to vary in speed
int Counter;    // counts the amount of updates before adding to the index of the cosine; The time it takes to progress the cosine
int Index;      // drives the cosine that varies the stepperspeed (Scale)
int WavDir;     // direction of rotation
int Mod;        // introduces an extra modulation in speed for extra unpredictability 
int ModCounter; // counts amount of updates before adding to the index of the extra mod
int ModIndex;   // index that in turn drives another cosine to extra modulate the speed, maybe this should be a sine wave instead, 

bool WavDirEva;

void setup()
{  

  int speed = 1000;
  
  stepper.setMaxSpeed(speed);
  stepper.setAcceleration(100);
  stepper.setSpeed(1000);
  Serial.begin(9600);
  Counter = 0;
  StepSpeed = 0;
  Index = 0;
  Mod = 0;
  ModIndex = random(0,628);
  WavDir = random(-1,1);
  if (WavDir== 0) {WavDir = 1;}
  WavDirEva = false;

}

void loop()
{


Counter = Counter + 1;
if  (Counter >= Mod) // after this many updates changes speed by adding 1 index
    {
    StepSpeed = ((( cos ( Index / 100.0 ) * -0.5 ) + 0.5 ) * 1000 ) * WavDir; // cosine because it starts at the most outward amplitude, making it more smooth around both extremes
    // the * -1 + 1 makes the cos start at 0 and climb up to, perhaps better to multiply the StepSpeed with the mod rather than add it. So that the mod can have a random beginning point without losing the "fade in"
    Index = Index + 1;
    Counter = 0; 
    if  (Index == 628){ //6,28 = (2*pi) almost a full cos cycle.
        Index = 0;
        
        }
      // Serial.println(StepSpeed);
    }


ModCounter = ModCounter + 1; //introduces an extra modulation for stepperspeed.
if (ModCounter == 10000)
  {
  ModIndex = ModIndex + 1;
  Mod = (((cos(ModIndex/100.0)*-0.5)+0.5)*1000)+1500; // Maximum should be 1000 steps p/s. So compensate in StepSpeed
  ModCounter = 0;
  if(ModIndex == 628)
  {
    ModIndex = 0;
  }
 // Serial.println(Mod);
 
  if  (StepSpeed != 0 && WavDirEva == true)
      { 
      WavDirEva = false;
      }
  
  if  (StepSpeed == 0 && WavDirEva == false)
      {
      WavDir = random(-1,1);
      if  (WavDir== 0) 
          {
          WavDir = 1;
          }
 //     Serial.println(WavDir);
      WavDirEva = true;
      }
      Serial.println(StepSpeed);
//      Serial.println(Mod);
//      Serial.println(WavDirEva);
  }

stepper.move(StepSpeed);
stepper.run();
}

Ik begrijp inmiddels niet meer hoe het überhaupt mogelijk is dat ik het gewenste motor gedrag heb kunnen bereiken met mijn initiële code en setup, namelijk:
de enable lijn van de driver had ik aan pin 4 verbonden.
belangrijker: de motor direction pin had ik niet eens gedeclareerd in de code!
Heeft iemand hier een antwoord op?

Met mijn huidige setup gebeurt er iets heel anders dan gewenst. De motoras schudt eerst heel wat heen en weer en draait vervolgens, veel te snel 1 richting op. Ik heb de spanning er afgehaald, en wanneer ik het nogmaals probeer doet de motor niks. Arduino power lampje doet het nog wel, en hij verschijnt ook nog in de lijst bij aansluiten via usb.

Ik durf niet veel meer te testen omdat ik niet NOG een arduino wil slopen.

Moet ik opnieuw beginnen met de code?
Heeft het er mee te maken dat de outputs die ik gebruik op de arduino PWM zijn? Dit lijkt, als ik ze verander, niet uit te maken.
Ik loop opnieuw tegen een nogal frustrerende muur op. :disappointed_relieved:

Gefixed! :open_mouth:

De stepperdriver bleek het niet meer te doen. Hoewel er geen zichtbare schade was, ik heb niet gemeten waar het defect zat, maar ik vermoed dat het tijdens een vorige meting is misgegaan en daardoor de driver is overbelast oid. Een vervangend exemplaar heeft het goed gedaan, alles opnieuw gesoldeerd en geïnstalleerd in de installatie. Of de eerste twee arduino's nog bruikbaar zijn weet ik nog niet. Daar ga ik eerst even research naar doen. Ze verschijnen in ieder geval niet in de device list. :-\

Bedankt voor jullie hulp! Dankzij jullie eindelijk af kunnen maken en heel. Veel. Geleerd. :smiley:

Het eindresultaat, minus een likje verf:

Ook heb ik de code een stuk overzichtelijker, en hopelijk, wat zuiniger gemaakt.

#include "AccelStepper.h"

// Define a stepper and the pins it will use
AccelStepper stepper(1,9,8); // the "1" tells the program we're using a driver, the 2nd arg is motorStepPin, the 3rd arg is motorDirPin
int stepSpeed;      // scaled version of stepper speed in steps per second(?)), uses a cosine to vary in speed
int unmodulatedSpeed;
int waveMillis;
int waveModMillis;
int speed;


float wavePhase;
float waveModPhase;
float modulator;

unsigned long currentMillis;
unsigned long previousMillis;
unsigned long interval;
unsigned long previousModMillis;
unsigned long intervalMod;


void setup()
{  
randomSeed(analogRead(0));


  speed = 1000;
  
  stepper.setMaxSpeed(speed);
  stepper.setAcceleration(100);
  stepper.setSpeed(700);
  Serial.begin(9600);
  stepSpeed = 0;
  interval = random(2380, 8000);
  intervalMod = random(2000,4000);
  previousMillis = 0;
  previousModMillis = 0;
  modulator = 0;
  wavePhase     = 0;
  waveModPhase     = 0;

}

void loop()
{
currentMillis = millis();
waveMillis    = currentMillis - previousMillis;
waveModMillis = currentMillis - previousModMillis;
wavePhase     = (float(waveMillis) / float(interval)) * 6.28 ;
waveModPhase  = (float(waveModMillis) /  float(intervalMod)) * 6.28;


if (currentMillis - previousMillis >= interval)
  {
    interval        = random(2380, 8000); // minimal and maximal length per wave in ms
    previousMillis  = currentMillis;
  }

if (currentMillis - previousModMillis >= intervalMod)
  {
    intervalMod       = random(2000,4000);
    previousModMillis = currentMillis;
  }

  modulator    = (cos( waveModPhase) * -0.2 ) + 0.8;

  unmodulatedSpeed = ( ( ( cos( wavePhase) * -0.5 ) + 0.5 ) * (speed - 25) + 25);
  stepSpeed    = unmodulatedSpeed * modulator;

/*  
  Serial.println(modulator);
  Serial.println(intervalMod);
  Serial.println(unmodulatedSpeed);
  Serial.println(stepSpeed);
  delay(30);
*/

stepper.move(stepSpeed);
stepper.run();
}

die stepper.run die moet zo vaak als mogelijk, de rest alleen maar als er iets verandert is.
die timers zitten een beetje vreemd in elkaar maar als het werkt dan prima toch, wel wat meer commentaar in je programma dan weet je volgende week ook nog wat er gebeurt.
al die floats hoeft niet hoor, een tijd is een long en als je daar een deling mee doet is het resultaat meestal een float, maar als je een int met 2 vermenigvuldigd krijg je niet automatisch een float dus eigenlijk prima gedaan zo.