Geekly articles weekly

Wir stellen eine dreiachsige numerische Fräsmaschine her

Die Idee, eine Maschine mit den Händen zu Hause zu bauen, ist nicht neu. Jeder, der über die Implementierung solcher Geräte zu Hause nachdenkt, sollte sich von seinem Schöpfungsmotiv leiten lassen. Dies ist für mich notwendig, da ich von Natur aus nicht so viele gerade Hände habe, um gute, sogar mehr oder weniger insgesamt Teile herzustellen, und oft die Aufgabe besteht, genau das komplexe Teil herzustellen, mit dem die Maschine gut umgehen kann. Es gibt immer genug neue Ideen und Ideen für die Umsetzung, aber nicht viel Zeit.



Kurz über den Autor

4- , « », « », « ».

Spoiler

. , . , , , . . , - , .

Leistungsbeschreibung oder was am Ausgang zu erwarten ist


Die resultierende Fräsmaschine muss folgende Bedingungen erfüllen:

  • Haben Sie einen akzeptablen Arbeitsbereich
  • Haben Sie eine akzeptable Axialgeschwindigkeit
  • Holzteile mittlerer und hoher Härte verarbeiten. Idealerweise mit Aluminium umgehen

Die Hauptregel von Maschinen ist die Steifigkeit. Je höher die Steifigkeit der Maschine ist, desto weniger Vibrationen, Spiel, Absinken, Biegungen und andere Mängel beeinträchtigen die Qualität der bearbeiteten Rohlinge. Da die Maschine komplett zu Hause hergestellt wird, ist dies das einzige Material, das zu Hause wirklich in einer solchen Menge verarbeitet werden kann und aus dem das Maschinenbett hergestellt werden kann - ein Baum. Natürlich gibt es verschiedene Arten. Und aus Mangel an großem Kapital wird für den Studenten alles, was gefunden wird, zum Schaffen verwendet. Und dies ist im Wesentlichen ein Musterbrett mit einem Bohrer eines eher weichen Baumes. Es gibt zwar auch kleine Sperrholzplatten. Was reich ist, wird dann verwendet.

Es ist auch erwähnenswert, welche Steuerung der Maschine gestartet wird. Es gibt einen sehr alten Computer, dessen Ufer gerade für solche Zwecke ist. AMD Duron 1,2 GHz, RAM 768 MB, 64 MB Video Mem, Festplatte 20 GB. Einfach für diese Zwecke geeignet. Die Verwaltung erfolgt unter Linux CNC. Für Mach3 unter Win wollte man nicht intelligent arbeiten. Er braucht etwas mehr Ressourcen.

Entwicklung


Die Entwicklung der Maschine wird in mehrere Teile unterteilt.

  • Entwicklung einer Schrittmotorsteuerung
  • Entwicklung eines Schrittmotortreibers
  • Optisches Isolationsdesign
  • Entwicklung eines Ernährungsplans

Es sollte sofort gesagt werden, dass die Entwicklung des mechanischen Teils als solches fehlte, weil es nicht so viel Erfahrung gibt, um etwas zu entwickeln und zu antizipieren. Daher wurde die Entwicklung sofort in der Montagephase durchgeführt.

Entwicklung einer Schrittmotorsteuerung


Auf einem PIC-Mikrocontroller wird eine Schrittmotorsteuerung entwickelt. Warum? Erstens musste man endlich verstehen, wie Schrittmotoren funktionieren, zweitens war es interessanter, drittens kostete der gleiche fertige L297-Chip aus irgendeinem Grund etwas teuer, und als Ergebnis stellte sich heraus, dass er auf dem Mikrocontroller etwas billiger zusammengebaut wurde.



Als Kontrollmikrocontroller wurde PIC16F630 verwendet. Es hat ein Minimum an Peripherie und eine ausreichende Anzahl von Beinen zur Kontrolle. Port C dient zur direkten Ausgabe von Steuerimpulsen. Die Pins A1, A2 haben Eingangssignale DIR, STEP. Pin A2 ist im externen Interrupt-Modus aktiviert und DIR funktioniert wie ein normaler Eingangspin. Die Steuerung wird über Quarz mit 20 MHz gestartet.

Der Code wurde mit einer kleinen ASM-Einfügung in C geschrieben und auf dem CCS C-Compiler kompiliert.

#include <16f630.h>
#case  
#FUSES NOWDT                    
#FUSES NOMCLR                   
#FUSES HS                     
#FUSES PUT                    
#FUSES BROWNOUT 

#use delay(clock = 20 MHz)                                                                                                                         
#use fast_io(C)                                                     
#opt 9  
                                
#define DIR		PIN_A1                                                             
#define CLK		PIN_A2   
#define LED		PIN_A0                                
                                                                          
#zero_ram       
                             
//half step array     
const int steps[256] =    
{                 
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                         
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101                                                                                             
};                                                         
             
unsigned int8 nowStep = 0;        
                                                                                                                 
#INT_TIMER1                                                     
void LoadDrop_isr()      
{                                                                           
	output_c(0);              
}                                                                                                          
                                                                                                       
#INT_EXT                    
void clk_isr()
{                                    
   //input_state(DIR) ? nowStep++ : nowStep--;                                                 
  	#asm asis              
  	BTFSC  05.1 
  	INCF   nowStep,F         
  	BTFSS  05.1                                                      
  	DECF   nowStep,F    
  	#endasm             
                    
	output_c(steps[nowStep]);
	set_timer1(0);		
}                                       
                                                                                                                                                    
void main()                                                                                                                                  
{                            
	output_a(0);                         
	input_a();  
	        
	set_tris_c(0);                    
	output_c(0);  
	                           
	setup_comparator(NC_NC_NC_NC);                        
	setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);                       
	set_timer1(0);                                                          
	                          
	ext_int_edge(L_TO_H);    
	                                                          
	enable_interrupts(INT_TIMER1);             
	enable_interrupts(INT_EXT);                   
	enable_interrupts(GLOBAL);  
	                                                                    
	unsigned int16 blinkCounter = 0; 
	             
	MAIN_LOOP:                    
	                                  
		 if(!blinkCounter++)              
		 	output_toggle(LED);        
		 	                
	goto MAIN_LOOP;                                                                                                                                                      
}

Um den Code zu beschreiben, ist es einfacher, mit der Logik der Steuerung zu beginnen. Wenn die Steuerung startet, erfolgt die Erstkonfiguration des Bügeleisens und die Einbeziehung von Interrupts. Die Schrittnummer wird in der vorzeichenlosen 8-Bit-Variablen nowStep gespeichert und am Anfang ist die Nummer Null. Als nächstes wird der fortwährende Programmzyklus in MAIN_LOOP gestartet, in dem einfach die an Pin A0 angeschlossene LED blinkt. Wofür? Erstens ist klar, dass der Stein nicht gefroren ist, und zweitens Spezialeffekte! Pin A2 ist für einen externen Interrupt an einer aufsteigenden Flanke konfiguriert. Wenn ein Ereignis am Fuß aufgezeichnet wird, wird der Interrupt INT_EXT verarbeitet, in dem der nächste Schritt umgeschaltet wird. Um den nächsten Schritt anzuzeigen, erfolgt abhängig vom eingegebenen DIR ein Inkrementieren oder Dekrementieren des nowStep-Schrittzeigers.Dann wird aus dem Array von Schritten, die von der Position nowStep entfernt sind, eine neue Kombination des Schaltens der Motorwicklungen im Port angezeigt. Außerdem wird zu Beginn der Initialisierung des Mikrocontrollers der Timer 1 eingerichtet und gestartet. Dieser Timer setzt die Ausgangssignale zurück, um eine Überhitzung der Motoren zu verhindern. Der Timer setzt die Ausgangssignale ca. 100 ms nach dem Einstellen des Signals zurück. Dies ist eine rein vorsorgliche Maßnahme.

In der Simulation konnte eine CLK-Signalperiode von 15 μs erreicht werden, was einer Frequenz von 66 (6) KHz entspricht. Zum ersten Mal ist es nicht schlecht, ich denke jedoch, dass eine weitere Optimierung möglich ist.

Entwicklung eines Schrittmotortreibers


Es ist nicht nötig, weit zu gehen. Typisches Schema. Der Treiber basiert auf dem fertigen Treiber L298N.



Warum Widerstände R1 - R4? Ehrlich gesagt weiß ich es nicht. Zunächst geht die Dokumentation in Verbindung mit L297 an die Schaltung, die gesamte Kommunikation ohne Widerstände. Im Internet fand ich jedoch Schaltungen mit Widerständen auf den Leitungen. Ich habe mir das Blockdiagramm im Datenblatt des L298N angesehen. Alle INPUT-Zeilen gehen zum inversen Eingang AND-Element. Ohne Widerstände sollte nichts passieren. Aber ich habe mich entschlossen, es nicht zu riskieren und diesmal nur für den Fall des Einfügens. Es wird nicht viel schlimmer sein, die Steilheit der Front am Eingang wird fallen.

Der Rest des Schemas wiederholt den im Datenblatt angegebenen.

Optisches Isolationsdesign


Die Optokopplerplatine dient zum Schutz der Steuermaschine, in diesem Fall des Computers, vor dem Leistungsteil der Maschine. Wenn also etwas von der Seite der Maschine zu rauchen beginnt, raucht es nur bis zur Optokopplerplatine und minimiert Schäden.

Das Schema ist ziemlich groß, klicken Sie also, um die volle Größe zu sehen. Zunächst wurden 4N25-Optokoppler genommen. Denn ich dachte, dass jeder heutige Optokoppler 60 kHz dehnen würde. Aber tatsächlich, nein, sie haben es nicht gedehnt, sie hatten keine Zeit. Daher musste ich es durch 6N135 ersetzen, bei dem die Leistung viel höher ist (bis zu 2 MHz in Bezug auf das Datenblatt). Durch Stifte sind sie nicht direkt kompatibel, es war jedoch möglich, sie einzusetzen, ohne die gesamte Platine zu verändern. Ich habe kein neues Schema erstellt, ich denke, wer auch immer will, wird in der Lage sein, das Board selbst aufzuladen.





Wie es sein sollte, wird die Schaltungsleistung von der Maschinenseite und der Computerseite in zwei Teile geteilt. Auf der Computerseite erfolgt die Stromversorgung über das USB-Kabel. Dies ist der einzige Zweck. Von der Seite der Maschine befindet sich bereits ein Kabelbündel von 5 V.

Entwicklung eines Ernährungsplans


Da alles nicht in Monolithen, sondern in kleinen Blöcken durchgeführt wurde, mussten mehr Drähte als üblich für Strom und Signale getrennt werden. Um die Verkabelung zu vereinfachen, habe ich beschlossen, einen separaten kleinen Streifen mit Anschlüssen für die Stromverteilung auf den 12-V- und 5-V-Leitungen zu erstellen. Der Steckdosenleisten



enthält sechs Anschlüsse für 5-V- und 12-V-Leitungen sowie zwei separate Anschlüsse für den Anschluss von Kühlern.

Montage und Ergebnis


Da ich nicht von Anfang an mit dem Fotografieren begonnen habe und nicht geplant war, einen Artikel zu schreiben, fehlen viele Montageschritte, aber ich werde die zeigen, die es sind. Alle Fotos in diesem Abschnitt können angeklickt werden.

Schrittmotortreiber machen


Das Bild wurde mit LUT verschoben: Geätzt und verzinnt: Gebohrt: Versiegelt: Als nächstes musste der Erfolg für zwei weitere Achsen wiederholt werden:





















Herstellung von optischen Isolationsplatten




LUTom verschoben und mit einem Marker korrigiert:



Geätzt:





Gebeizt: Die



gesamte Elektronik zusammengebaut:







Maschinenmontage


Die Maschine wurde aus 10 mm dickem und 18 mm dickem Sperrholz montiert. Beim Zusammenbau wurden Möbelführungen verwendet, es war besser, zum ersten Mal nichts zu finden, und psychologisch war ich nicht bereit, mindestens die gleichen Metallecken zu bearbeiten.

Anfangs gab es eine solche Konstruktion:





Die erste Version der Z-Achse:



Aber so wie ich es jetzt verstehe, war es überhaupt nicht gut, alles ging herum, versetzt. Im Allgemeinen war von keiner Starrheit die Rede.
Ein weiterer Versuch folgte:





Währenddessen wurden die X- und Y-Achsen auf eine separate Plattform bewegt und in einen beweglichen Tisch verwandelt:



Es war bereits besser, aber immer noch sehr weit von etwas entfernt, das nicht taumelte. Als Ergebnis kam ich zu dieser Option:



Die Z-Achse zuckte und bog jedoch immer noch zu stark. Diesmal habe ich mich hingesetzt und gut nachgedacht und war bereits mit Design beschäftigt. Das Ergebnis war dieses Design:



Gleiche Aluminiumecken mit einem Regal von 25 mm und einer Dicke von 2 mm wurden als Führung verwendet. Ich konnte keinen Stahl finden. Sie wären um ein Vielfaches besser. Richtlinien für die industrielle Fertigung sind natürlich immer noch nicht vergleichbar.

Fahrwagen:





Neue Z-Achse zusammengebaut:





Ergebnis. Sie können feststellen, dass sich die zusammengebaute Achse und das Design insgesamt immer noch von der entworfenen Achse unterscheiden. Das Ausrichten und Zentrieren der Achse, wenn Sie nur einen Messschieber und eine Handbohrmaschine benötigen, ist jedoch eine ziemlich schwierige Aufgabe. Also musste ich meine Meinung ändern und unterwegs experimentieren:





Proben zum Fräsen:



Selbst bei so vielen, wenn es mir trotz eines so unvollkommenen Designs gelungen ist, etwas zu schaffen, das funktioniert, und das Ergebnis, von dem ich beeindruckt war.

Computer steuern


Die Steuerungssoftware für CNC-Maschinen muss auf Echtzeitsystemen arbeiten, um präzise synchronisierte Signale zu erzeugen. Daher ist Windows dafür nicht gut geeignet. Natürlich werden für den korrekten Betrieb Treiber geschrieben, die dieses Problem lösen, aber normalerweise sind mehr Ressourcen erforderlich, und die Stabilität eines solchen Systems ist geringer als bei Echtzeitsystemen.
Die Verarbeitung erfolgte unter Kontrolle von LinuxCNC. Installation und Konfiguration sollten keine großen Schwierigkeiten verursachen. Die Programmwebsite enthält bereits vorgefertigte Builds und Gourmetquellen. Es gibt verschiedene Installationsmethoden: auf einem bereits installierten System oder von Grund auf zusammen mit einem konfigurierten Betriebssystem. Ich entschied mich für die zweite Option, da ich nicht so viel Erfahrung mit Linux hatte und nicht genügend Zeit für den Patch-Prozess vorhanden war. Die zweite Option ist eine reguläre Debian-Distribution mit einem bereits installierten RTC-Kernel und LinuxCNC.

Nach der Installation muss die Achse der Maschinen angepasst werden: Signalzuordnung, Geschwindigkeit, Beschleunigung usw. Das Ergebnis ist eine Ausgabedatei zum Starten, die beim Start das Maschinensteuerungsprogramm selbst mit den angegebenen Parametern anzeigt.

Fazit


Aufgrund der geleisteten Arbeit bleiben viele Eindrücke sowie Fragen und Aufgaben zur Verbesserung der resultierenden Maschine übrig.

  1. Erhöhung der Spannung der Motoren von 12 V auf 24 V
  2. Stärken Sie das Design und bereiten Sie idealerweise ein neues Maschinendesign mit vorläufigem vollständigen Design vor
  3. Endschalter und Not-Aus-Taster hinzufügen
  4. Optimierung des Betriebs von Motorsteuerungen
  5. Bauen Sie die Elektronik der Maschine mit Ausnahme der Optokopplungsplatine wieder auf einer Platine zusammen
  6. Ersetzen Sie die Maschinenspindel durch die dem Zweck entsprechende. Das ist ein hochdrehender und leistungsstärkerer Motor als der derzeitige chinesische Graveur.
  7. Ersetzen Sie den Motor auf der Z-Achse, da der aktuelle Motor weniger leistungsstark und am stärksten belastet ist

Die resultierende Maschine hat eine Arbeitsfläche von mehr als 270 mm entlang der X- und Y-Achse und etwa 150 mm entlang der Z. Die Bewegungsgeschwindigkeit entlang der X- und Y-Achse beträgt mehr als 500 mm / s und entlang der Z 300 mm / s. Dies ist bei 12 V Betriebsspannung. Das ist die Hälfte ihrer Leistung. Es gibt Raum zum Wachsen.

Was mit Sicherheit gesagt werden kann - es hat sich gelohnt. Mindestens eine Aufgabe erledigt die Maschine jetzt gut: Schneidebretter. Sie können Ätzen und LUT vergessen. Schneidebretter haben natürlich ihre Nachteile, aber es ist besser, Alternativen zu haben als die einzige Option. Im Video wurde gezeigt, wie ein 3-mm-Fräser den Buchstaben M gefräst hat, möglicherweise mit einer geringen Vorschubgeschwindigkeit und 0,1-mm-Schichten, aber dies ist auch das Ergebnis.

Verbreiten Sie einige Quell- oder Leiterplatten sehen bisher nicht viel Sinn. Die Maschine war nicht für ernsthafte Belastungen geeignet oder ziemlich stabil und einzigartig. Dies ist jedoch nicht der letzte Versuch, etwas zu tun, und die nächste Iteration der Entwicklung wird vorbereitet, ich hoffe, eine bessere.

Source: https://habr.com/ru/post/de394537/

More articles:


All Articles