Einfacher Bohrautomat

Hallo.

Ich heiße Daniel, bin 49 Jahre alt und Feinwerkmechaniker.

Ich bin gerade dabei, einen kleinen Bohrautomat zu bauen. Es soll ein Kunststoffgehäuse eingelegt und ein Loch gesenkt werden. Auf Tastendruck fährt eine Bohrspindel im Eilgang ca. 50mm nach unten, schaltet in den Bearbeitungsvorschub und fährt noch mal ca.4mm weiter runter zum senken. Dort verweilt er für ca. 0,1 Sekunden und fährt im Eilgang wieder hoch auf Parkposition.

Vorhandenes Material:

Motor: Nema 23 5A/2Nm ClosedLoop mit 1000PPR

Treiber: CL57T-V41

Netzteil: 24V/400W

Arduino UNO R3

Taster, kapazitiver Sensor NPN, Not-Aus-Schalter

Vorhandene Programierkenntnisse:

KEINE :frowning:

Mir fehlt leider die Zeit um mich richtig in die Materie einzuarbeiten deswegen bin ich auf eure Hilfe angewiesen. Meine Erste Vorrichtung habe ich auch mit Schrittmotoren gemacht, allerdings mit Relais und oberen und unteren Endschaltern. Jetzt brauch ich es viel genauer.

Ich bekomme den Motor zum schnellen runterfahren und umschalten in den Arbeitsvorschub und natürlich auch wieder hoch.

Was ich gar nicht hinbekomme ist folgendes: Der Automat soll beim Einschalten erst langsam nach oben fahren auf den berührungslosen Sensor und dann wieder eine Umdrehung nach unten. Das ist dann immer die definierte Nulllage der Spindel.

Hier soll der Arduino auf den Tastendruck warten um zu bohren.

/* Bohrzyklus mit Motor Nema23 5A-2Nm Closed Loop 1000PPR, 
   und Treiber CL57T-V41 mit 24V-400W Netzteil, 
   Arduino Uno R3.*/

// Deffinition Pins und Schritte pro Umdrehung:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 1600

void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  // Festlegen der Drehrichtung im Uhrzeigersinn:
  digitalWrite(dirPin, HIGH);

  // Bohrspindel Eilgang 10 Umdrehungen runter:
  for (int i = 0; i < 10 * stepsPerRevolution; i++) {
    // Nachfolgend 10 Umdrehungen runter:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(40);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(40);
  }

  delay(10);

  // Set the spinning direction clockwise:
  digitalWrite(dirPin, HIGH);

  // Bohrspindel Vorschub 2 Umdrehungen runter:
  for (int i = 0; i < 1.5 * stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(800);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(800);
  }
  // Verweilzeit am Bohrgrund:
  delay(10);

  // Set the spinning direction counterclockwise:
  digitalWrite(dirPin, LOW);
  // Bohren beendet:
  // Bohrspindel Eilgang 11.5 Umdrehungen hoch:
  for (int i = 0; i < 11.5 * stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(40);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(40);
  }

  delay(2500);
}

Das ist nicht mein Code sondern zusammengesucht und auf meine Bedürfnisse zum Testen umgeschrieben. Ist mein erster Beitrag hier und ich hoffe, das ich nicht alles falsch gemacht habe. Vielen Dank schon im vorraus für die Hilfe und Unterstützung.

Dann zeige uns doch mal Deinen Sketch, den Du bisher hast.
Stelle ihn in Codetags hier ein. Wie das geht, steht hier.

Gruß Tommy

Ich musste erst mal schauen wie das ging mit den Code. Aber ich hatte die Funktion beim rumprobieren im IDE schon gesehen...
Das mit dem loop habe ich schon nicht wegbekommen. Er dreht da seine Endlosschleife.

So ganz wirst Du da nicht drumrum kommen, auch wenn wir dir gerne dabei helfen.
Was Du brauchst ist ein endlicher Automat bzw eine Schrittkette als einfache Form davon.
Und der erste Schritt zur Realisierung ist, genau aufzuschreiben welche Schritte nacheinander ablaufen müssen - und auch, was den Übergang zum nächsten Schritt auslösen soll.

Hallo und vielen Dank schon mal. Ich will und werde mich da einarbeiten. Allerdings brauche ich hierbei ein schnelles Ergebnis. Bin ich kein Fan von, ist aber leider so. Ich will eigendlich immer wissen, was die Geräte warum machen.
Also:

  • Maschine einschalten

  • Bohrspindel (Kugelumlaufspindel 4mm Steigung) fährt langsam hoch auf den Sensor.
    Von dort wieder eine Umdrehung nach unten. Das soll den immer gleichbleibenden Nullpunkt darstellen, von der ich meine Entfernung zum bohren festlege.

  • Mit einem Tastendruck beginnt die Maschine an zu bohren und fährt wieder zurück auf Startposition.

  • Das referenzieren soll nur bein einschalten statfinden.
    Ist das so komplett oder wird noch was benötigt?

Der einfache Weg: LinuxCNC + ein bischen G-Code.
Der für M$-User einfache Weg: GRBL + ein Laptop + UGS + ein bischen G-Code

... oder MobaTools nehmen und ein bischen Programmieren :slight_smile:

Dann kannst du die Referenzfahrt doch im setup() machen.

Danke für die Antwort. Bringt mich leider auch nicht weiter.
G-Code programiere ich unter anderem auf der Arbeit. Das bringt mir hier nichts.
Aber geil wäre es.

Und wie mache ich das? Ich habe Null Plan. Ich weiß nicht einmal wie ich anfangen soll.
Das ist Motor verfahren und Sensor abfragen..... Bahnhof....

Du brauchst einen Eingang für deinen Sensor am oberen Anschlag, in deiner Notation (Beispiel):

#define sensorPin 8

In setup():
Den setzt du als Eingang, abhängig davon, ob er aktiv auf LOW oder HIGH schaltet:

pinMode(sensorPin, INPUT_PULLUP); // low aktiv
pinMode(sensorPin, INPUT); // high aktiv

Dann Richtung nach oben einstellen und in einer Schleife langsam hochfahren (das wäre analog zu der Senkung mit jeweils 800 Mikrosekunden). Dabei immer den Sensor abfragen (digitalRead(sensorPin) und bei Auslösen anhalten, Richtung umkehren und die eine Umdrehung wieder runterfahren.

Oh ha, gut. Das muss aber alles noch innerhalb von "void setup" stehen oder ablaufen?
Dann brauche ich noch ein Stopbit oder Befehl.
Super, da bekomme ich doch langsam wieder ein Lächeln ins Gesicht. Auch wenn mir der Schädel brummt :laughing:

Jawoll!

Da ich keine vergleichbare Hardware zur Verfügung habe, ist es schwer, das runterzuschreiben und getestet abzuliefern. Also unter Vorbehalt hier Dein Sketch etwas erweitert (er kompiliert, ob er das tut was Du brauchst, weiß ich nicht). Habe auch noch einen Taster für den Start der Prozedur spendiert.

Ein Versuch...
// https://forum.arduino.cc/t/einfacher-bohrautomat/1317614

/* Bohrzyklus mit Motor Nema23 5A-2Nm Closed Loop 1000PPR, 
   und Treiber CL57T-V41 mit 24V-400W Netzteil, 
   Arduino Uno R3.*/

// Definition Pins und Schritte pro Umdrehung:
#define dirPin 2
#define stepPin 3
#define sensorPin 8 // <<< hier den für den Sensor verwendeten Pin eintragen
#define startPin 9  // <<< hier den für den Start-Taster verwendeten Pin eintragen
#define stepsPerRevolution 1600

void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(sensorPin, INPUT_PULLUP); // <<< wir nehmen mal aktiv LOW an
  pinMode(startPin, INPUT_PULLUP);  // <<< wir nehmen auch hier aktiv LOW an
  
  // <<<
  // Richtung HOCH habe ich von unten geklaut
  digitalWrite(dirPin, LOW);
  
  // fahre aufwärts bis der Sensor (Endschalter) auslöst
  while (digitalRead(sensorPin)) {  // <<< HIGH heißt: Sensor (noch) nicht aktiv
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(800);  // <<< die lange Wartezeit bedeuted "langsam"
    digitalWrite(stepPin, LOW);
    delayMicroseconds(800);
  }
  // jetzt sollte die Spindel bei aktiviertem Endschalter oben stehen  
  // fahre eine Umdrehung nach unten
  digitalWrite(dirPin, HIGH);
  for (int i = 0; i < stepsPerRevolution; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(800);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(800);
  }
}

void loop() {

  if (!digitalRead(startPin)) { // <<< LOW bedeutet: Taster aktiviert, deshalb Verneinung durch !
    // Festlegen der Drehrichtung im Uhrzeigersinn:
    digitalWrite(dirPin, HIGH);
  
    // Bohrspindel Eilgang 10 Umdrehungen runter:
    for (int i = 0; i < 10 * stepsPerRevolution; i++) {
      // Nachfolgend 10 Umdrehungen runter:
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(40);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(40);
    }
  
    delay(10);
  
    // Set the spinning direction clockwise:
    digitalWrite(dirPin, HIGH);
  
    // Bohrspindel Vorschub 2 Umdrehungen runter:
    for (int i = 0; i < 1.5 * stepsPerRevolution; i++) {
      // These four lines result in 1 step:
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(800);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(800);
    }
    // Verweilzeit am Bohrgrund:
    delay(10);
  
    // Set the spinning direction counterclockwise:
    digitalWrite(dirPin, LOW);
    // Bohren beendet:
    // Bohrspindel Eilgang 11.5 Umdrehungen hoch:
    for (int i = 0; i < 11.5 * stepsPerRevolution; i++) {
      // These four lines result in 1 step:
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(40);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(40);
    }
  }
  
  // <<< 
  // Das delay kann entfallen, weil die ganze Prozedur komplett abgearbeitet wird
  // bevor der Taster das nächste Mal abgefragt wird.
  // Das ist von der Programmstruktur her gesehen übrigens ganz und gar unschön.
  // Es kann nichts anderes quasi-parallel bearbeitet werden (z.B. eine Statusanzeige)
  // delay(2500);
}

P.S.: Liebe Kollegen, verhaut mich bitte nicht für den Sketch. Ich habe versucht, die Anforderungen des TO minimal invasiv einzuarbeiten. Das kann man viel besser machen.

2 Likes

Ohhh wow. Da hat aber einer Gas gegeben....Vielen Dank.
Dann werde ich mich morgen dran machen und ein paar Kabel krimpen.
Ich hoffe das ich das Teil nicht durch Kurzschluß sprenge... :sweat_smile:
Das wird ein Spaß haben sie gesagt..
Ich melde mich morgen wieder.
Vielen Dank

Ich ziehe meinen Hut. Macht genau was es soll. Habe es jetzt nur mit Kabelbrücken versucht. Aber er läuft rückwärts bis man den Pin für Sensor schließt und läuft vorwärts eine Umdrehung und bleibt stehen. Pin für Start gebrückt und er macht einen Bohrzyklus und das so oft ich will. Einfach geil.
Wieso ist das von der Struktur her unschön und warum kann es nicht mehr machen(was es nicht soll)?
Wie kann ich dir was in die Kaffekasse schmeissen?
Vielen vielen Dank

Danke für die Rückmeldung; freut mich wenn es funktioniert.

Die Pins für Sensor und Start schalten nach GND, sonst funktioniert es nicht. "Schließt" ist noch i.O., "gebrückt" ist - hmm - unüblich.

Irgendwann kommt der Punkt, wo Du eine Aufgabe lösen willst, die quasi-parallele Verarbeitung erfordert. Dann merkst Du schnell, dass delay() keine gute Idee ist (egal ob Mikro oder nicht). Während der Wartezeit steht Dein Programm einfach auf der Stelle.
Wir empfehlen zur Ansteuerung der Schrittmotoren die MobaTools - eine Library, die Du über die IDE laden kannst. Da erfolgt die Ansteuerung blockadefrei im Hintergrund.

Dein Uno langweilt sich momentan mit den zwei Inputs und dem Schrittmotor etwas. Eine schnell/langsam blinkende LED, Farbe abhängig von der Fahrtrichtung, als Anzeige?

Und dann gibt es da noch Kleinigkeiten wie z.B. der Mehrfachcode für den Schrittmotor (Auslagern in Funktion), das #define (reine Textersetzung durch den Präprozessor, stattdessen bietet C++ constexpr ).

Kaffeekasse: Habe ich keine, werde ich auch keine haben und ist hier auch weder üblich noch angebracht. "Lernen durch Abgucken" ist okay.

Das ist noch wesentlich zu grob. Da musst Du die Schritte, die der Prozessor nacheinander ausführen muß noch wesentlich detaillierter beschreiben.

@wno158 hat dir im Prinzip schon eine Schrittkette gezeigt, die alle notwendigen Schritte enthält. Nur - wie er selbst ja auch sagt - ist das einfach 'gerade herunterprogrammiert' mit blockierenden delay(). Da langweilt sich der Prozesser eigentlich nur. Aber wenn das für dich so funktioniert, ist es erstmal ok.
Solltest Du im Laufe der Zeit doch noch Wünsche haben, was der Arduino noch zusätzlich machen könnte, dann musst Du lernen, wie man so eine Schrittkette 'blockadefrei' realisiert. Das ist das, was @wno158 mit

meinte :wink:

Hallo und noch mal herzlichen Dank an Euch.
Ich habe mich für die Lösung entschieden, weil mir die am einfachsten erschien, mit dem bestmöglichen Ergebniss.
Ich habe mich jetzt ca. sechs Stunden mit dem Thema befasst. Das ist gar nichts im Vergleich zu dem, was Ihr schon drauf habt oder die Zeit die Ihr investiert habt.
Ich werde dran bleiben da man noch viele schöne Projekte damit verwirklichen kann. Da bin ich aber noch weit entfernt von.
So einen Einsteigersatz zum probieren sollte ich mir zulegen. Es hakt ja schon an den Basics.
Ich werde jetzt erst mal den Sensor mit einem Potentialfreien Relais anschließen und schauen ob das so funktioniert.
Bis dahin nocheinmal Danke und Allen ein schönes Wochenende
und seid gesegnet.

Kannst du davon einen Link zum Datenblatt posten?
Dann kann man nachschauen was der für eine Versorgungsspannung der braucht
und ob der kapazitive Näherungssensor wirklich einen NPN-Openkollektor-Ausgang hat.

Wenn man im Datenblatt den Sensortyp ermitteln kann, dann kann man auch sagen wie man den direkt an den Arduino anschließen kann.

Ich möchte trotzdem noch einen anderen Vorschlag machen:

Wenn der Einsatz eines alten PCs oder alten Laptops kein Problem darstellt dann könntest du auch einen Arduino zusammen mit der Software ESTLCAM verwenden.

ESTLCAM kostet 49 Euro. Das ist für die Leistungsfähigkeit des Programms ein unschlabares Preis/Leistungsverhältnis.

ESLTCAM kann: direkt die Steuerungssoftware auf einen Arduino aufspielen.

Man kann in ESTLCAM eine 2D-DXF-Zeichnung laden und dann mit der Maus und recht intuitiv zu bedienendem Programm CNC-Bohr und Fräsprogramme erstellen lassen.
Das CNC-Programm zum Senken wäre damit in 5 Minuten erstellt.

Moin, der Sensor hat eine Betriebsspannung von 6-36V und ist ein NPN. Habe es direkt ausprobiert, da reicht aber die Spannung nicht. Mit dem Relais hat es sofort funktioniert.

Das wäre schon zu viel des guten. Das gibt ein Senk-Bohrautomat der die nächsten vier Jahre nix anderes macht wie hoch und runter zu fahren.... :joy:
Für weitere Vorrichtungen ist das aber nicht verkehrt, das mal gehört zu haben.
Vielen Dank dafür.

Ein eindeutig besseres Ergebnis erziehst Du wenn Du dich mit dem was @MicroBahner dir empfiehlt auseinandersetzt.
Und ein Eilgang auf dem Stepper ohne Beschleunigung mag erstmal Funktionieren aber ist auch keine Lösung auf Dauer.