Schrittfrequenz für Schrittsequens?

[Huber M. (michael_h784)]

Hallo,

ich möchte einen Schrittmotor ganz simpel ansteuern. Um mir einmal etwas 
richtig darunter vorstellen zu können. Und zwar möchte ich zu 
nachfolgenden Code anstatt des delays eine Funktion erstellen zb. 
motorspeed... Um die Geschwindigkeit zu regeln, dazu brauche ich die 
Startfrequenz und die Maximale Schrittfrequenz. Aber ich habe keine 
Ahnung wie ich dies umsetzen soll bzw. darauf komme. Denn ich kann mir 
einfach nichts daruter vorstellen.

soweit ich das verstanden habe hängt die Gechwindigkeit von der 
Geschwindigkeit der Schritt-sequence ab. Und wie ich im Forum Avr- 
tutorial hier gelesen habe ist das, mit delay zu lösen, der schlechteste 
fall. Die Frequenz soll wie zb. eine Ladekurve ansteigen?

Wie könnte jetzt für nachfolgenden Code eine Lösung aussehen.

Im Bild oben eine kleine Übersicht. Ich versorge den Motor momentan mit 
+5V

hier Datenblatt Motor.:
[[http://www.raspberrypi-spy.co.uk/wp-content/uploads/2012/07/Stepper-Motor-28BJY-48-Datasheet.pdf]]

Datenblatt Treiber.:
[[http://www.ti.com/lit/ds/symlink/uln2003a.pdf]]

Code.:

*SchrittFrequenz.c
 *
 * Created: 26.01.2017 09:04:19
 *  Author: USER
 */ 

#define F_CPU 1000000UL
#include <util/delay.h>
#include <avr/io.h>

// MOTORPINS HIGH
#define motorpin1_HIGH (PORTD |= (1<<PD0))  // ORANGE  IN1
#define motorpin2_HIGH (PORTD |= (1<<PD1))  // GELB    IN2
#define motorpin3_HIGH (PORTD |= (1<<PD2))  // VIOLETT IN3
#define motorpin4_HIGH (PORTD |= (1<<PD3))  // BLAU    IN4

// MOTORPINS LOW
#define motorpin1_LOW (PORTD &= ~(1<<PD0))  // ORANGE  IN1
#define motorpin2_LOW (PORTD &= ~(1<<PD1))  // GELB    IN2
#define motorpin3_LOW (PORTD &= ~(1<<PD2))  // VIOLETT IN3
#define motorpin4_LOW (PORTD &= ~(1<<PD3))  // BLAU    IN4

// SCHRITTFREQUENZ
#define Schrittfrequenz 100

int main(void)
{    // AUSGÄNGE für MOTORSTEUERUNG
  DDRD |= 0x0F;
  
  // Funktion Sequenz Uhrzeigersinn
  
  void Rechts (void)
  {
    //1
    motorpin1_HIGH;
    motorpin2_LOW;
    motorpin3_LOW;
    motorpin4_LOW;
    _delay_ms(Schrittfrequenz);
    //2
    motorpin1_HIGH;
    motorpin2_HIGH;
    motorpin3_LOW;
    motorpin4_LOW;
    _delay_ms(Schrittfrequenz);
    //3
    motorpin1_LOW;
    motorpin2_HIGH;
    motorpin3_LOW;
    motorpin4_LOW;
    _delay_ms(Schrittfrequenz);
    //4
    motorpin1_LOW;
    motorpin2_HIGH;
    motorpin3_HIGH;
    motorpin4_LOW;
    _delay_ms(Schrittfrequenz);
    //5
    motorpin1_LOW;
    motorpin2_LOW;
    motorpin3_HIGH;
    motorpin4_LOW;
    _delay_ms(Schrittfrequenz);
    //6
    motorpin1_LOW;
    motorpin2_LOW;
    motorpin3_HIGH;
    motorpin4_HIGH;
    _delay_ms(Schrittfrequenz);
    //7
    motorpin1_LOW;
    motorpin2_LOW;
    motorpin3_LOW;
    motorpin4_HIGH;
    _delay_ms(Schrittfrequenz);
    //8
    motorpin1_HIGH;
    motorpin2_LOW;
    motorpin3_LOW;
    motorpin4_HIGH;
    _delay_ms(Schrittfrequenz);
    
   }
   
   // MOTORSTOP
     void motorstop(void)
   {
     motorpin1_LOW;
     motorpin2_LOW;
     motorpin3_LOW;
     motorpin4_LOW;
   }
   
    while(1)
    {
        //TODO:: Please write your application code 
    }
}

Danke fürs lesen Grüsse Huber

[Paddy (Gast)]

Verstehst du auch warum ein delay besser nicht benutzt werden kann ?
Weil man dann zwischendurch schwierig etwas anderes machen kann zb 
kommunikation oder display update.

Ich weisz nicht welchen uP du benutzt (Pi?) aber zB fuer Arduino gibt es 
die funktion millis(). Solche funktionen gibt es auch fuer Pi oder du 
kannst die selber schreiben.

https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing

[Huber M. (michael_h784)]

Oh, da ist die Auflösung wohl zu schlecht. Der code wird mit AtmelStudio 
6.2 erstellt und auf einen Atmega88PA geschrieben:

Paddy schrieb:
> Verstehst du auch warum ein delay besser nicht benutzt werden kann ?
> Weil man dann zwischendurch schwierig etwas anderes machen kann zb
> kommunikation oder display update.

so in der art dachte ich es mir schon.

[aSma>> (Gast)]

Huber M. schrieb:
> Um die Geschwindigkeit zu regeln, dazu brauche ich die
> Startfrequenz und die Maximale Schrittfrequenz. Aber ich habe keine
> Ahnung wie ich dies umsetzen soll bzw. darauf komme. Denn ich kann mir
> einfach nichts daruter vorstellen.

Das ist schon ein Komplexes Thema. Hier hast du was zum Lesen:
http://www.embedded.com/design/mcus-processors-and-socs/4006438/Generate-stepper-motor-speed-profiles-in-real-time

Mit diesen Motor und Treiber wirst du auf langer Sicht nicht glücklich. 
Die Maximale Frequenz findest du heraus druch ausprobieren. Diese wird 
nicht allzu hoch sein, da du ein Gertriebe hast. Bei höheren Drehzahlen 
hat man einfach kein Drehmoment mehr.

Schrittmotoren müssen mit einer Rampe angesteuert werden. Ist die 
Startfrequenz zu hoch, dann kommt der Motor aus dem Takt, verliert 
Schritte oder macht Geräusche und dreht sich einfach nicht.

[Huber M. (michael_h784)]

aSma>> schrieb:
> Schrittmotoren müssen mit einer Rampe angesteuert werden. Ist die
> Startfrequenz zu hoch, dann kommt der Motor aus dem Takt, verliert
> Schritte oder macht Geräusche und dreht sich einfach nicht.

Da ich das ganze neben bei auch mit einem Arduino testen will. Weil ich 
mich da einfach leichter tue Sachen zu durchblicken. Jetzt dachte ich, 
ich mache mir auf dem Arduino mal etwas mit einem Timer. Jetzt komme ich 
mit dem einfachsten nicht klar, Und Zwar kann mir jemand sagen, wie ich 
""x = 1;"" richtig Eintrage, denn wenn ich das wie beim Atmelstudio 
mache, dann Kompiliert er es mir nicht.Wo liegt mein Fehler? ich glaube 
beim erneut vorwegladen??

das wäre jetzt so eingestellt das es mir alle 0,5s ein Interrupt 
aufruft. Und dann soll x = 1; sein.

hier hätte ich mal den Code..AM Arduino Board

 volatile int x = 0;
 int b = 0;

void setup()
{ 
  Serial.begin(9600);

   // Timer 1
  noInterrupts();           // Alle Interrupts temporär abschalten
  TCCR1A = 0;
  TCCR1B = 0;

  TCNT1 = 34286;            // Timer nach obiger Rechnung vorbelegen
  TCCR1B |= (1 << CS12);    // 256 als Prescale-Wert spezifizieren
  TIMSK1 |= (1 << TOIE1);   // Timer Overflow Interrupt aktivieren
  interrupts();             // alle Interrupts scharf schalten
}
// Hier kommt die selbstdefinierte Interruptbehandlungsroutine 
// für den Timer Overflow
ISR(TIMER1_OVF_vect)        
{
  TCNT1 = 34286;              
  x = 1;
}

void loop()
{
  if(x == 1)
  {
    b ++;
  }
   if( b >= 500)
  {
    b = 0;
  }
  
 Serial.println(b);
}

[posti (Gast)]

Hi

Selber kein Arduino, kein C

Liest sich so, daß beim ersten Overflow vom Timer 1 der Zählerwert auf 
den berechneten Startwert gesetzt wird (damit nach der gleichen Anzahl 
an Takten der nächste Interrupt zuschlägt).
Hier würde ich den Startwert als Variabel übergeben oder in ein Register 
packen - damit kannst Du die Geschwindigkeit einstellen.

Weiter wird X auf 1 gesetzt - da verbleibt das X auch bis der Strom 
abgestellt wird.
Denke, in Deiner Abfrage if X==1 gehört noch ein X=0 zum 'Flag löschen'.

Auch sehe ich nicht, wo der Motor angesprochen wird.

Bis jetzt scheint Dein Programm bis zum ersten OVL zu warten und dann 
ratz-fatz B immer wieder bis 500 hochzuzählen.

MfG

[Huber M. (michael_h784)]

posti schrieb:
> Bis jetzt scheint Dein Programm bis zum ersten OVL zu warten und dann
> ratz-fatz B immer wieder bis 500 hochzuzählen.

danke das mit dem Timer hat sich geklärt. Das hochzählen auf 500 und 
reset, war nur ein test, ob das zählen funktioniert.Mache es jetzt mit 
Atmelstudio 6.2 Und Atmega88PA

posti schrieb:
> Auch sehe ich nicht, wo der Motor angesprochen wird.

Genau das war die ursprüngliche Frage zum 1.Th wie dies aussehen könnte, 
bei obengenannten Code.

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Hallo Huber,

> aSma>> schrieb:
>> Schrittmotoren müssen mit einer Rampe angesteuert werden. Ist die
>> Startfrequenz zu hoch, dann kommt der Motor aus dem Takt, verliert
>> Schritte oder macht Geräusche und dreht sich einfach nicht.
>
> Da ich das ganze neben bei auch mit einem Arduino testen will. Weil ich
> mich da einfach leichter tue Sachen zu durchblicken. Jetzt dachte ich,
> ich mache mir auf dem Arduino mal etwas mit einem Timer.

Für Arduino gibt es die Accelstepper.lib:
http://www.schrittmotor-blog.de/ansteuern-von-schrittmotoren-mit-arduino/
Du kannst dir die Sourcen der Lib ja ansehen, nachdem du den Motor am 
Laufen hast. Den ULN würde ich aber so bald wie möglich in die Ecke 
werfen. Da sind ja selbst schlechte Motor-Shields besser geeignet, so 
lange man sich von den angepriesenen Maximalströmen fern hält.

Mit freundlichen Grüßen
Thorsten Ostermann