next topic »

[Reply #15 on:]

Hallo,

meine Grundschaltung sieht so aus:

http://www.pololu.com/picture/view/0J1640

VMOT + GND = Eingangsspannung
1A - 1B = Wicklung 1
2A - 2B = Wicklung 2
Brücke von 5 V nach VDD = Betriebsspannung des Treibers auf 5 Volt
Arduino GND mit Pololu GND verbinden
Blink-Sample-Scetch laden und Pin 13 an Step
DIR auf 5 Volt oder GND = Drehrichtung einstellen

der Schrittmotor macht jetzt ganze Schritte im Sekundentakt

das Delay verkleinern und Dein Motor wird schneller

Testbetrieb erfolgreich ??

Gruss

Kurti

[Reply #16 on:]

Hallo Kurti,
Das mit den Delays habe ich mir abgewöhnt. Das Lämt alle anderen Prozesse die Du in deinem Programm noch so betreieben willst. Besser man benutzt andere Zeitfunktionen. Ich will ja eine Drehachse mit einer anderen Synchron laufen lassen. Daher messe ich zunächst die Drehgeschwindigkeit der ersten Achse, Multipliziere diese mit einem Übersetzungsverhältnis, rechne diese in eine Frequenz eines Rechteksignals um und gebe diese auf den Output.
Die ansteuerung des Poolus ist also eigentlich so ähnlich wie bei Dir, doch leider hat mein Pololu den NAchmittag icht überlebt schade, oder um es deftiger auszudrücken "STUHL". Das andere Wort mit "Sch" macht die Bildung kaput.
Gruß
DrFlopp

[Reply #17 on:]

Hallo,

ich schrieb von einem Test.
Dazu habe ich Dir ein allseits bekanntes und sehr einfaches Programm empfohlen.
Damit soll natürlich keine Produktion laufen.

Wenn Du dann den Fehler in Deiner Konfiguration gefunden hast,
mußt Du natürlich ein richtiges Programm schreiben.

Gruss
Kurti

[Reply #18 on:]

Hallo Kurti,
ich habe den kleineren Pololu ohne die Stpannungaregler.
http://www.pololu.com/catalog/product/1182
Ich versorge den Pololu vom Arduino mit 5V und liefer über ein Labornetzteil den Motorstrom 12V. Ich habe aus Example " Stepper Motor Control - one revolution" Programm geladen, aus den vier Pinnbelegung zwei gelöscht und diese an Dir und Stepp geklemmt. Das hat funktioniert. Dann habe ich den Aufbau in den Nachbarraum getragen und an ein anderes Labornetzteil geklemmt. Der unterschied war erstes Netzteil 40A - zweites Netzteil 4A.
Ich habe mit dem OSCA die Signale gemessen, und war sehr erstaunt dass aus dem Stepper.h auf beiden Kanälen Rechtecksignale liegen.
Nach dem was Ihr schreibt und nach dem wie ich den Treiber verstanden habe war das großer Quatsch und reiner Zufall dass das funktioniert hat.
Da ich die Stepper.h nicht nachvollziehen kann, habe ich mir gedacht ich schreibe mir ein Programm, dass den Stepper so ansteuert wie ich glaube dass es richtig ist. Den Stepper-Pin mit einem Rechtecksignal und den Dir-und En-Pin jeweils mit einem konstanten High- oder Low-Pegel.
Der Rest meines Programms dient zur Auswertung der Drehzahl auf die ich meinen Stepper synchronisieren will. Hierzu habe ich auch noch ein kleines Problem, dazu komme ich später noch einmal.
Natürlich habe ich auch schon versuche gemacht mit konstanten Frequenzen

[Reply #19 on:]

Hallo,

Du glaubst, deine Hardware ist eventuell defekt.
Du möchtest allerdings anscheinend keine systematische Fehlersuche betreiben.

Viel Erfolg bei Deiner Methode.

Kurti
PS.: beruflich bin ich Programmierer und Inbetriebnehmer von Maschinen mit mehr als 20 Jahren Berufserfahrung,
bestimmt ist Deine Methode besser, funktiniert schließlich ohne 'Delay' !

[Reply #20 on:]

Hallo Kurti,
ich habe keine 20 Jahre Erfahung als Progarmmierer, und es liegt mir fern diese auch nur ansatzweise in Frage zustellen. Im Gegenteil ich bin Dir sehr dankbar für Deine Anregungen. Ich habe das mit dem Blink Programm getestet, und ich habe mein Programm auch noch einmal auf`s wesentliche vereinfacht. Beides hat nicht Funktioniert. Also werde ich mal einen neuen Treiber bestellen und hoffen das es damit geht. Kann das Problem vielleicht auch an dem Reglertyp liegen, denn im Gegensatz zu Dir habe ich ja keine Spannungsregler auf dem  Treiber.
Vielen Dank für Eure Hilfe
Gruß
DrFlopp


/*
Drehachsensteuerung
 
 */
int i;                     // Getriebeübersetzung
int s;                     // Sinunsfunktion
int R = 13;                // Rechteckausgang
int Dir = 12;                // Rechteckausgang
int En = 8;                // Rechteckausgang




void setup() {
 i=40;
 pinMode(R,OUTPUT);
 pinMode(En,OUTPUT);   //Enable Pin
 pinMode(Dir,OUTPUT);   //Direction Pin
 
 Serial.begin(9600);  // initialize the serial port:
 
}

void loop() {
 
  s=2*sin(millis()/100);
    Serial.println(s); 
  if (s<0){
    digitalWrite (R, LOW);
  }
   if (s>0)
   {
    digitalWrite (R, HIGH);
   }
  digitalWrite(En, HIGH);               // Enable Pololu
  digitalWrite(Dir, LOW);               // Direktion Pololu
 
}

[Reply #21 on:]

Hallo,
als erstes solltest Du den Fehler suchen:
http://www.pololu.com/picture/view/0J3360
microcontroller = Arduino
logic power supply = unnötig, 5 Volt vom Arduino nehmen
Motor anschließen
Spannung für Schrittmotor anschließen, Polarität beachten !!
DIR auf GND oder 5 Volt
STEP = Takteingang für Schritt

hast Du die Strombegrenzung für den Motor mal verstellt ?
Kontaktschwierigkeiten beim Poti ?, Strom zu niedrig ?

ist der Motor in Ordnung ?
haben die Windungen Durchgang ?

Wenn am Takteingang kein Signal liegt, liefert der Treiber an beiden Spulen 70 % des eingestellten Nennstroms
( Datenblatt beachten  http://www.pololu.com/file/0J450/a4988_DMOS_microstepping_driver_with_translator.pdf)
liegt an den Ausgängen Spannung an, fließt Strom ?

viel Erfolg beim Testen
Kurti

[Reply #22 on:]

Hallo Kurti,
ich habe mit dem Osca gemessen, am Stepp-Pin ligt ein 5V Rechtecksignal an, die Frequenz habe ich variiert zwischen 1 und 50 Hz. Am Dir-Pin habe ich einen HIGH-Pegel. An VDD liegen 5V an. Am Vmot-Pin liegen 12V jeweis zu GND gemessen. Aus den Motorausgängen kommen jedoch keine Signale. Der Motor hat gestern noch funktioniert (auch mit dem gleichen Treiber), ich habe aber zur Sicherheit noch zwei andere Motoren ausprobiert. Am Poti habe ich natürlich auch schon rumgedreht.
Ich gehe davon aus, etwas kaput gemacht zuhaben, SCHADE.
Neue Treiber sind bestellt.
Ich habe aber noch ein kleines Problem bei der Messung der Drehgeschwindigkeit (Speed) meiner Spindel.
Ich habe in mehr oder weniger unregelmäßigen Abständen viel zu große Werte, hier eine mess Reihe aufgenommen bei eine konstanten Drehzahl:

45.00
43.00
43.00
43.00
45.00
45.00
45.00
45.00
43.00
43.00
43.00
43.00
43.00
43.00
43.00
43.00
43.00
50.00
50.00
50.00
38.00
38.00
58.00
200.00
200.00
200.00
47.00
47.00
47.00
1000.00
1000.00
45.00
45.00
45.00
45.00
40.00
40.00
40.00
45.00
45.00
45.00
41.00
41.00
62.00
166.00
166.00
166.00
43.00
43.00
62.00
166.00
166.00
166.00
43.00
43.00
43.00
45.00
45.00
45.00
43.00
43.00
43.00
43.00
43.00
55.00
333.00
333.00
52.00
166.00
166.00
166.00
43.00
43.00
43.00
47.00
47.00
47.00
1000.00
1000.00
43.00
43.00
43.00
43.00
43.00


 Woran kann das liegen? Passt da etwas mit meinem Programm nicht oder spuckt mir die Serielleschnittstelle in die Suppe?

 
/*
Drehachsensteuerung
 
 */
int i;                        // Getriebeübersetzung
int s;                        // Sinunsfunktion
int R = 13;                // Rechteckausgang
int Dir = 9;                // Richtung
int En = 8;                 // Enable
double w;                  // Omega
float Speed;               // Spindeldrehzahl
unsigned long T1;        //Zeitstepel 1
unsigned long T2;        //Zeitstepel 2

// Encoder Interruptports
#define A 2      //Belegung der Encoderkanale A

void setup() {
 i=40;
 pinMode(R,OUTPUT);
 pinMode(En,OUTPUT);   //Enable Pin
 pinMode(Dir,OUTPUT);   //Direction Pin
 
 Serial.begin(9600);  // initialize the serial port:
 
  attachInterrupt(0,CHAInt,RISING);                // Interrupt 0 führt CHAInt aus mit wechslende Flanken
  pinMode(2,INPUT);                               // Pin2 als Input
  digitalWrite(2,HIGH);                            // Interne Pull Ups benutzt
}

void loop() {

  Speed= 1000/(T2-T1);                 //Spindeldrehzahl
  //Serial.println(Speed);
  Serial.println(s); 
  // Rechtecksignal
  w= (Speed*36*4)/(16*200*i);
  s=5*sin(w*millis()*1000);
  if (s<0){
    digitalWrite (R, LOW);
  }
   if (s>0){
    digitalWrite (R, HIGH);
  }
  digitalWrite(En, LOW);               // Enable Pololu
  digitalWrite(Dir, LOW);               // Direktion Pololu
 
}
void CHAInt ()
{
  int Aread=0;

  Aread=digitalRead(A);

  if (Aread==HIGH){
    T1 = T2;
    T2 = millis();
   
  }
}

[Reply #23 on:]

Hallo Leute,
ich habe das Problem mit der Drehzahl nun weiter eingekreist. Ich habe die Interrupt-Bedingung umgestellt und mit RISING bekomme ich bei Drehzahlen von bis zu 180 RPM recht zuverlässige Werte. 
Der Lochdurchmesser (4mm) in der Encoderscheibe ist wesentlich kleiner als der Lochabstand (11mm), dadurch scheint es zu Aussetzern in der Flankenerkennung zu kommen. Evtl. spielen auch noch Aliaseffekt eine Rolle.
Vielleicht hat jemand eine bessere Lösung, ich würde mich freuen diese Ausprobieren zu können.

Viele Grüße
DrFlopp

[Reply #24 on:]

Du musst deine Interrupts auf das wesentliche beschränken die Arudino Funktion millis() braucht schon etwas Zeit. Ganz übertieben dargestellt dein Interrupt wird ausgelöst => Springen zur interupt funktion in der interrupt Funktion was tun => in die Funktion millis() springen warten auf return und dann raus aus dem interrupt. Also das ding muss kürzer werden.

[Reply #25 on:]

Wenn portabilitaet auf andere AVR chips nicht wichtig ist, dann sollte digitalRead() auch ersetzt werden.

So etwa in der art:

Code:

if( PIND & _BV(PD2) ){
    T1 = T2;
// usw.
}

[Reply #26 on:]

Hallo Leute,
vielen Dank für eure Hilfe. Ich bin nicht so fitt im C-Programmieren, das ich den Code von madworm nachvollziehen kann, könntet Ihr den vielleicht für kommentieren.

Wenn ich Dani richtig verstanden habe kann ich schon viel erreichen wenn ich die millis() aus dem Interrupt heraus in die Loop schiebe.
...
    T2 = millis();

}
void CHAInt ()
{
  int Aread=0;

  Aread=digitalRead(A);

  if (Aread==HIGH){
    T1 = T2; 
  }
}

Vielen Dank für Eure Hilfe es ist immer sehr hilfreich mit Euch zu diskutieren

Gruß
Philipp

[Reply #27 on:]

Ich bin davon ausgegangen, dass du einen 168/368 chip hast.

Der 'digital 2' pin in arduino lingo ist auf 'PORTD' des chips und hat den namen 'PD2'.

http://www.arduino.cc/playground/Learning/PortManipulation

Nachdem dieser pin in gewoehnlicher weise als eingang gesetzt worden ist (was laufzeittechnisch egal ist, da es nur 1x passiert), kann der status des gesamten PORTD (8bit breit) ueber das register 'PINB' abgefragt werden.

_BV(...) ist ein makro, welches eine bit-maske generiert. _BV(2) entspricht z.b. (1<<2), was wiederum 00000100 ist. Und so weiter.

Code:

PINB & _BV(PD2)

Berechnet ein bit-weises logischen UND zwischen dem PIN register und der bitmaske.

Code:

PINB     00001000
_BV(PD2) 00010000

Hier gibt es keine gemeinsamen bits, also ist das ergebnis NULL. Waere das entsprechende bit in PINB gesetzt, kaeme eine 1 heraus.

Folglich ist:

Code:

if( PINB & _BV(PD2) ) {
  // blah
}

i.d.r. aequivalent zu:

Code:

if( digitalRead(2) ) {
  // blah
}

Ausnahme: man muss sich selbst darum kuemmern evtl. laufendes PWM auf manchen pins vorher abzudrehen. Dieser luxus entfaellt, dafuer ist es erheblich schneller.

[Reply #28 on:]

Hallo madworm,
ich habe einen Atmega 328P Prozessor.
Es tut mir leid, als Maschinenbauer tue ich mich manchmal sehr schwer, abstrakte Erklärungen für informationstechnische Dinge zu verstehen.
Habe ich das richtig verstanden?
Die if-Abfrage ist ein Ersatz für die Interrupt-Funktion. Da man direkt auf die Register zugreift ist das Programm deutlich schneller als eine Interrupt-Funktion.

An welcher Stelle würdest Du denn T2 besetzen?

Gruß
DrFlopp

[Reply #29 on:]

So ich habe den Vorschlag von madworm jetzt ausprobiert.
das funktioniert bei einer Drehzahl von bis zu 90 RPM recht gut, bei höheren Drehzahlen funktioniert es nicht. Das Problem scheint tatsächlich die millis() Funktion zu sein. Ich habe versucht diese vor die Interruptfunktion zu schreiben, doch das brachte auch keine Verbesserung. Gibt es bei der Zeitfunktion noch Optimierungspotential?

/*
 Drehachsensteuerung
 */
int i;                     // Getriebeübersetzung
int s;                     // Sinunsfunktion
int PD2 = 2;
int R = 13;                // Rechteckausgang
int Dir = 9;                // Rechteckausgang
int En = 8;                // Rechteckausgang
double w;                  // Omega
float Speed;               // Spindeldrehzahl
unsigned long T1;          //Zeitstepel 1
unsigned long T2;          //Zeitstepel 2

// Encoder Interruptports
#define A 2      //Belegung der Encoderkanale A

void setup() {
  i=40;
  pinMode(R,OUTPUT);
  pinMode(En,OUTPUT);   //Enable Pin
  pinMode(Dir,OUTPUT);   //Direction Pin

  Serial.begin(9600);  // initialize the serial port:

  attachInterrupt(0,CHAInt, RISING);//HIGH);                // Interrupt 0 führt CHAInt aus mit wechslende Flanken
  pinMode(PD2,INPUT);                               // Pin2 als Input
  digitalWrite(PD2,HIGH);                            // Interne Pull Ups benutzt
}

void loop() {

  Speed= 1000/(T2-T1);                  //Spindeldrehzahl
  //Serial.println(Speed);
  Serial.println(Speed); 
  // Rechtecksignal für Stepper
  w= (Speed*36*4)/(16*200*i);
  s=5*sin(w*millis()*1000);
  if (s<0){
    digitalWrite (R, LOW);
  }
  if (s>0){
    digitalWrite (R, HIGH);
  }
  digitalWrite(En, LOW);               // Enable Pololu
  digitalWrite(Dir, LOW);               // Direktion Pololu
  T2 = millis();
}
void CHAInt ()
{
  if( PIND & _BV(PD2) )
  {
    T1 = T2;
  }
}