Ansteuerung einer Schrittmotor-Achse mit Siemens SIMATIC S7-300 SPS: Unterschied zwischen den Versionen
K (→Schaltung) |
|||
(37 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 9: | Zeile 9: | ||
Projektdateien: [[Datei:CNCS7300 Siemens SPS CNC.zip]] | Projektdateien: [[Datei:CNCS7300 Siemens SPS CNC.zip]] | ||
Abschlusspräsentation: [[Datei:CNCS7300 Abschlusspräsentation SPS Siemens.pptx]] | Abschlusspräsentation: [[Datei:CNCS7300 Abschlusspräsentation SPS Siemens.pptx]] | ||
[[Datei:Sps steuerung cpu313c.jpg|mini|800px|right|CPU313C auf Hutschiene | [[Datei:Sps steuerung cpu313c.jpg|mini|800px|right|CPU313C auf Hutschiene]] | ||
= Einleitung = | = Einleitung = | ||
Zeile 57: | Zeile 58: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 V-Modell.png|400px|thumb|left| V-Modell | | [[Datei:CNCS7300 V-Modell.png|400px|thumb|left| V-Modell]] | ||
[[Datei:CNCS7300 Abschlusspräsentation SPS Siemens.pptx]] | |||
|} | |} | ||
Zeile 73: | Zeile 75: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Funktionaler-Systementwurf.PNG|800px|thumb|left|Funktionaler Systementwurf | | [[Datei:CNCS7300 Funktionaler-Systementwurf.PNG|800px|thumb|left|Funktionaler Systementwurf]] | ||
[[Datei:S7300 Funktionaler-Systementwurf.pptx]] | |||
|} | |} | ||
Zeile 83: | Zeile 86: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Technischer-Systementwurf.PNG|800px|thumb|left|Technischer Systementwurf | | [[Datei:CNCS7300 Technischer-Systementwurf.PNG|800px|thumb|left|Technischer Systementwurf]] | ||
[[Datei:S7300 Technischer-Systementwurf.pptx]] | |||
|} | |} | ||
Zeile 95: | Zeile 99: | ||
* SIEMENS Hutschiene | * SIEMENS Hutschiene | ||
* SIMATIC PS307 [https://asset.conrad.com/media10/add/160267/c1/-/de/000513201DS01/datenblatt-513201-siemens-simatic-ps307-24-v5-a-hutschienen-netzteil-din-rail-24-vdc-5-a-120-w-1-x.pdf Datenblatt] | * SPS-Netzteil SIMATIC PS307 [https://asset.conrad.com/media10/add/160267/c1/-/de/000513201DS01/datenblatt-513201-siemens-simatic-ps307-24-v5-a-hutschienen-netzteil-din-rail-24-vdc-5-a-120-w-1-x.pdf Datenblatt] | ||
* SIMATIC S7-300-CPU313C SVN-Download: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Siemens%20SIMATIC/s7300_cpu_31xc_and_cpu_31x_operating_instructions_de-DE_de-DE.pdf Datenblatt] | * Speicherprogrammierbare Steuerung SIMATIC S7-300-CPU313C SVN-Download: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Siemens%20SIMATIC/s7300_cpu_31xc_and_cpu_31x_operating_instructions_de-DE_de-DE.pdf Datenblatt] | ||
* SIMATIC CP340 SVN-Download: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Siemens%20SIMATIC/s7300_cp340_manual_de_de-DE.pdf Datenblatt] | * Kommunikationsmodul SIMATIC CP340 SVN-Download: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Siemens%20SIMATIC/s7300_cp340_manual_de_de-DE.pdf Datenblatt] | ||
* GeckoDrive G201x SVN: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Gecko%20Drive/ Datenblätter] | * Schrittmotortreiber GeckoDrive G201x SVN: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Gecko%20Drive/ Datenblätter] | ||
* Igus NEMA 23 [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Igus%20Antriebe/ Datenblätter] | * Schrittmotor Igus NEMA 23 [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Allgemein/Literatur/Igus%20Antriebe/ Datenblätter] | ||
* Leitung 25-polig | * Leitung 25-polig | ||
* Stecker Sub-D 25-polig | * Stecker Sub-D 25-polig | ||
Zeile 120: | Zeile 124: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Programmablaufplan.PNG|800px|thumb|left|Programmablaufplan | | [[Datei:CNCS7300 Programmablaufplan.PNG|800px|thumb|left|Programmablaufplan]] | ||
[[Datei:S7300 Programmablaufplan.pptx]] | |||
|} | |} | ||
Zeile 134: | Zeile 139: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 ErstellungProjektTIAPortal 1.PNG|800px|thumb|left|Neues Projekt erstellen | | [[Datei:CNCS7300 ErstellungProjektTIAPortal 1.PNG|800px|thumb|left|Neues Projekt erstellen]] | ||
|- | |- | ||
| [[Datei:CNCS7300 ErstellungProjektTIAPortal 2.PNG|800px|thumb|left|Erste Schritte]] | | [[Datei:CNCS7300 ErstellungProjektTIAPortal 2.PNG|800px|thumb|left|Erste Schritte]] | ||
Zeile 143: | Zeile 148: | ||
===Anlegen und Parametrieren von Hardware=== | ===Anlegen und Parametrieren von Hardware=== | ||
Im Projekt wird in der „Projektnavigation“ unter „Gerätekonfiguration“ die Hardware angezeigt ([[:Datei:CNCS7300 HardwareParametrierenundAnlegen.PNG|Abbildung CP340 Parameter]]). Mit der Anwahl einer Baugruppe, erscheint ein Eigenschaftsfenster. In diesem Projekt besteht die Hardwarekonfiguration aus der S7-300 PLC und dem CP340-Modul zur Kommunikation über RS-232. Im Reiter "Allgemein" ist das Kommunikationsprotokoll des Moduls zu parametrieren. Zu diesen Parametern gehören auch die E/A-Adressen. | Im Projekt wird in der „Projektnavigation“ unter „Gerätekonfiguration“ die Hardware angezeigt ([[:Datei:CNCS7300 HardwareParametrierenundAnlegen.PNG|Abbildung CP340 Parameter]]). Mit der Anwahl einer Baugruppe, erscheint ein Eigenschaftsfenster. In diesem Projekt besteht die Hardwarekonfiguration aus der S7-300 PLC und dem CP340-Modul zur Kommunikation über RS-232. Im Reiter "Allgemein" ist das Kommunikationsprotokoll des Moduls zu parametrieren. Zu diesen Parametern gehören auch die E/A-Adressen. Diese können über "Eigenschaften" -> "Allgemein" -> "E/A-Adressen", sowohl bei der SPS als auch beim Kommunikationsmodul, eingestellt werden. Folgende Abbildung verdeutlichen den Vorgang: | ||
{| class="wikitable" | |||
| [[Datei:S7300 E A Adressen CPU.PNG|800px|thumb|E/Adressen CPU]] | |||
| [[Datei:S7300 E A Adressen CM.PNG|800px|thumb|E/Adressen CM]] | |||
|} | |||
Hier wird der zu verwendende Speicherbereich der PLC ausgewählt. Die Empfangenen oder zu sendenden Daten werden in diesem Bereich gespeichert und/oder ausgelesen. Zu beachten ist, dass bei diesem Modul die Baudrate auf 9600 festgelegt ist und nicht verändert werden kann. Bei der Parametrierung der PLC ist zu erwähnen, dass die PLC zwei integrierte IO-Karten verbaut hat. Der PLC muss eine IP-Adresse gegeben werden und den IO-Karten muss genau wie dem CP 340 Modul ein Speicherbereich zugeordnet werden. | Hier wird der zu verwendende Speicherbereich der PLC ausgewählt. Die Empfangenen oder zu sendenden Daten werden in diesem Bereich gespeichert und/oder ausgelesen. Zu beachten ist, dass bei diesem Modul die Baudrate auf 9600 festgelegt ist und nicht verändert werden kann. Bei der Parametrierung der PLC ist zu erwähnen, dass die PLC zwei integrierte IO-Karten verbaut hat. Der PLC muss eine IP-Adresse gegeben werden und den IO-Karten muss genau wie dem CP 340 Modul ein Speicherbereich zugeordnet werden. | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 HardwareParametrierenundAnlegen.PNG|800px|thumb|left|CP340 Parameter | | [[Datei:CNCS7300 HardwareParametrierenundAnlegen.PNG|800px|thumb|left|CP340 Parameter]] | ||
|} | |} | ||
Zeile 161: | Zeile 171: | ||
Mittels der Referenzfahrt wird der Steuerung ein Referenzkoordinatenpunkt übermittelt, welcher die aktuellen Positionen der Achsen repräsentiert. Dieser muss zu Beginn jedes Fräsvorganges einmalig übermittelt werden um dem System seine Ursprungskoordinaten mitzuteilen. U repräsentiert hierbei die X-Achse, V die Y-Achse und W die Z-Achse. Die darauffolgenden Zahlen stehen für die Koordinaten der jeweiligen Achse in 1/100mm. | Mittels der Referenzfahrt wird der Steuerung ein Referenzkoordinatenpunkt übermittelt, welcher die aktuellen Positionen der Achsen repräsentiert. Dieser muss zu Beginn jedes Fräsvorganges einmalig übermittelt werden um dem System seine Ursprungskoordinaten mitzuteilen. U repräsentiert hierbei die X-Achse, V die Y-Achse und W die Z-Achse. Die darauffolgenden Zahlen stehen für die Koordinaten der jeweiligen Achse in 1/100mm. | ||
Über den Koordinatenpunkt wird der Steuerung die nächste Zielkoordinate übermittelt. X, Y und Z repräsentieren die jeweilige Achse, F steht für den Vorschub. | Über den Koordinatenpunkt wird der Steuerung die nächste Zielkoordinate übermittelt. X, Y und Z repräsentieren die jeweilige Achse, F steht für den Vorschub. Hier ist die Maßeinheit mm/min. | ||
Um die Kommunikation in der PLC einzurichten, muss die Funktion „P_RCV“ ([[:Datei:CNCS7300 CP340Kommunikation.PNG|Abbildung CP340 P_RCV-Funktion]]) im zyklischen Programm der PLC aufgerufen werden. Die Funktion benötigt zusätzlich einen Speicherbaustein „P_RCV_DB“ und einen Instanzfunktionsbaustein „P_RCV“. Die Beschaltung der Ein- und Ausgänge der Funktionsblöcke ist der Funktionsbeschreibung der Blöcke in der TIA-Portal Hilfe zu entnehmen: | Um die Kommunikation in der PLC einzurichten, muss die Funktion „P_RCV“ ([[:Datei:CNCS7300 CP340Kommunikation.PNG|Abbildung CP340 P_RCV-Funktion]]) im zyklischen Programm der PLC aufgerufen werden. Die Funktion benötigt zusätzlich einen Speicherbaustein „P_RCV_DB“ und einen Instanzfunktionsbaustein „P_RCV“. Die Beschaltung der Ein- und Ausgänge der Funktionsblöcke ist der Funktionsbeschreibung der Blöcke in der TIA-Portal Hilfe zu entnehmen: | ||
Zeile 188: | Zeile 198: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 CP340Kommunikation.PNG|800px|thumb|left|CP340 P_RCV-Funktion | | [[Datei:CNCS7300 CP340Kommunikation.PNG|800px|thumb|left|CP340 P_RCV-Funktion]] | ||
|} | |} | ||
===Test der Kommunikation mit HTerm=== | ===Test der Kommunikation mit HTerm=== | ||
Das Programm HTerm ist ein Programm zur seriellen Kommunikation. In diesem Fall zwischen dem RS232-Port eines PC und der Siemens SPS. Für eine funktionierende Kommunikation der beiden Teilnehmer müssen zunächst einige Parameter eingestellt werden | Das Programm HTerm ist ein Programm zur seriellen Kommunikation. In diesem Fall zwischen dem RS232-Port eines PC und der Siemens SPS. Für eine funktionierende Kommunikation der beiden Teilnehmer müssen zunächst einige Parameter eingestellt werden: | ||
Baudrate = 9600; | |||
Parität = Keine (None); | |||
Port = COM Port an dem das Kommunikationsmodul angeschlossen ist; | |||
Databits = 8; | |||
Stopbit = 1. | |||
Bei der Eingabe aber auch bei der Ausgabe der Daten wird sich aus der Auswahl von ASCII, hexadezimal, binär und dezimalem Code entschieden. | Bei der Eingabe aber auch bei der Ausgabe der Daten wird sich aus der Auswahl von ASCII, hexadezimal, binär und dezimalem Code entschieden. | ||
Zeile 198: | Zeile 219: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Hterm.png|600px|thumb|left|HTerm 0.8.1 GUI | | [[Datei:CNCS7300 Hterm.png|600px|thumb|left|HTerm 0.8.1 GUI]] | ||
|} | |} | ||
Zeile 221: | Zeile 242: | ||
<code> | <code> | ||
#Wenn das erste Zeichen der übergebenen Zeichenkette (Zeichen) den Char 'X' enthält, beginnt die Berechnung der Schritte und Delay-Zeiten. | |||
IF #Zeichen = 'X' THEN | IF #Zeichen = 'X' THEN | ||
#Das Schrittverhältnis wird mit der Formel Schrittverhätnis = Distanz / (360 / Schrittwinkel) * Treiberverhältnis errechnet und im globalen DB gespeichert. | |||
"Global".Schrittverhaeltnis := #Distanz / (360 / #Schrittwinkel) * #Treiberverhaeltnis; //0.033 | "Global".Schrittverhaeltnis := #Distanz / (360 / #Schrittwinkel) * #Treiberverhaeltnis; //0.033 | ||
#Die übergebene Zeichenketten für X-Richtung ("Global".Received_Data_Splitted[0]), Y-Richtung ("Global".Received_Data_Splitted[1]), Z-Richtung ("Global".Received_Data_Splitted[2]) und Vorschub | |||
("Global".Received_Data_Splitted[3]) werden von string zu integer konverteiert. | |||
"Global".approach[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]); | "Global".approach[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]); | ||
"Global".approach[1] := STRING_TO_INT("Global".Received_Data_Splitted[1]); | "Global".approach[1] := STRING_TO_INT("Global".Received_Data_Splitted[1]); | ||
Zeile 228: | Zeile 253: | ||
"Global".approach[3] := STRING_TO_INT("Global".Received_Data_Splitted[3]); | "Global".approach[3] := STRING_TO_INT("Global".Received_Data_Splitted[3]); | ||
#Die Anzahl der Schritte in die jeweilige Richtung wird mit Schritte = Referenzposition - anzufahrende Position / Schrittverhältnis errechnet | |||
"Global".X_steps := ("Global".refrences[0] - DINT_TO_REAL("Global".approach[0])) / "Global".Schrittverhaeltnis; | "Global".X_steps := ("Global".refrences[0] - DINT_TO_REAL("Global".approach[0])) / "Global".Schrittverhaeltnis; | ||
"Global".Y_steps := ("Global".refrences[1] - DINT_TO_REAL("Global".approach[1])) / "Global".Schrittverhaeltnis; | "Global".Y_steps := ("Global".refrences[1] - DINT_TO_REAL("Global".approach[1])) / "Global".Schrittverhaeltnis; | ||
"Global".Z_steps := ("Global".refrences[2] - DINT_TO_REAL("Global".approach[2])) / "Global".Schrittverhaeltnis; | "Global".Z_steps := ("Global".refrences[2] - DINT_TO_REAL("Global".approach[2])) / "Global".Schrittverhaeltnis; | ||
#Die errechnete Anzahl der Schritte wird mit der Funktion ABS in einen absoluten Wert konvertiert. | |||
"Global".X_steps_abs := ABS("Global".X_steps); | "Global".X_steps_abs := ABS("Global".X_steps); | ||
"Global".Y_steps_abs := ABS("Global".Y_steps); | "Global".Y_steps_abs := ABS("Global".Y_steps); | ||
"Global".Z_steps_abs := ABS("Global".Z_steps); | "Global".Z_steps_abs := ABS("Global".Z_steps); | ||
#Die Vorschubgeschwindigkeit wird mit Vorschubgeschwindigkeit = Vorschub / (Schrittverhältnis * 60) errechnet | |||
"Global".F_velocity := DINT_TO_REAL("Global".approach[3]) / ("Global".Schrittverhaeltnis * 60); | "Global".F_velocity := DINT_TO_REAL("Global".approach[3]) / ("Global".Schrittverhaeltnis * 60); | ||
#Die Zeichenketten für X-Richtung, Y-Richtung, Z-Richtung und Vorschub werden von integer zu real konverteiert. | |||
"Global".refrences[0] := DINT_TO_REAL("Global".approach[0]); | "Global".refrences[0] := DINT_TO_REAL("Global".approach[0]); | ||
"Global".refrences[1] := DINT_TO_REAL("Global".approach[1]); | "Global".refrences[1] := DINT_TO_REAL("Global".approach[1]); | ||
"Global".refrences[2] := DINT_TO_REAL("Global".approach[2]); | "Global".refrences[2] := DINT_TO_REAL("Global".approach[2]); | ||
#Errechnen der Länge des zu fahrenden Weges (Hypothenuse im dreidimensionalen Raum) | |||
"Global".hypothenuse := SQRT("Global".X_steps * "Global".X_steps | "Global".hypothenuse := SQRT("Global".X_steps * "Global".X_steps | ||
+ "Global".Y_steps * "Global".Y_steps | + "Global".Y_steps * "Global".Y_steps | ||
+ "Global".Z_steps * "Global".Z_steps); | + "Global".Z_steps * "Global".Z_steps); | ||
#Errechnen der Delay-Zeiten für die einzelnen Achsen mit Delay-Zeit = ((Schritte / Hypothenuse) * Vorschubgeschwindigkeit) * 2 * 0.1 | |||
"Global".Delay_X_Real := (("Global".X_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | "Global".Delay_X_Real := (("Global".X_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | ||
"Global".Delay_Y_Real := (("Global".Y_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | "Global".Delay_Y_Real := (("Global".Y_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | ||
"Global".Delay_Z_Real := (("Global".Z_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | "Global".Delay_Z_Real := (("Global".Z_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1; | ||
#Delay-Zeit für Konvertierung in Zeit vorher in absoluten Wert konvertieren | |||
"Global".Delay_X_Real := ABS("Global".Delay_X_Real); | "Global".Delay_X_Real := ABS("Global".Delay_X_Real); | ||
"Global".Delay_Y_Real := ABS("Global".Delay_Y_Real); | "Global".Delay_Y_Real := ABS("Global".Delay_Y_Real); | ||
"Global".Delay_Z_Real := ABS("Global".Delay_Z_Real); | "Global".Delay_Z_Real := ABS("Global".Delay_Z_Real); | ||
"Global".Delay_X_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_X_Real * 100) / 100); // * 100 / 100 to prevent dataloss | #Delay-Zeit von Real zu double und von double in Time konvertieren | ||
"Global".Delay_X_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_X_Real * 100) / 100); // * 100 / 100 to prevent dataloss!!! | |||
"Global".Delay_Y_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Y_Real * 100) / 100); | "Global".Delay_Y_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Y_Real * 100) / 100); | ||
"Global".Delay_Z_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Z_Real * 100) / 100); | "Global".Delay_Z_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Z_Real * 100) / 100); | ||
#Wenn das erste Zeichen der Zeichenkette der Char 'U' ist, schreibe die Zeichenketten in das Array für die Referenzwerte | |||
ELSIF #Zeichen = 'U' THEN | ELSIF #Zeichen = 'U' THEN | ||
"Global".refrences[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]); | "Global".refrences[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]); | ||
Zeile 317: | Zeile 351: | ||
Die berechnete Zykluszeit ergibt sich aus der Summe aller folgenden Einflussfaktoren: | Die berechnete Zykluszeit ergibt sich aus der Summe aller folgenden Einflussfaktoren: | ||
Zykluszeit_verzögert | Zykluszeit_verzögert <math>Z_v=(Z+A+B+K) \cdot 1,10</math> | ||
In dieser Formel ist A=0, weil im Versuchsaufbau der Baugruppenträger 0 nicht gebraucht wird. Der Faktor B wird mit 4 multipliziert, da man im Baugruppenträger 32 Bit(digitale Input und Output)= 4 Byte hat. | In dieser Formel ist A=0, weil im Versuchsaufbau der Baugruppenträger 0 nicht gebraucht wird. Der Faktor B wird mit 4 multipliziert, da man im Baugruppenträger 32 Bit(digitale Input und Output)= 4 Byte hat. | ||
Zeile 323: | Zeile 357: | ||
Daher lautet die Formel: | Daher lautet die Formel: | ||
Zykluszeit_verzögert : | Zykluszeit_verzögert :<math>Z_v =(Z+B+K) \cdot 1,10</math> | ||
<math>Z_v=(2ms+(4 \cdot 0,0043 ms)+100ms) \cdot 1,10 = 5,192 ms</math> | |||
Zeile 336: | Zeile 370: | ||
== Entwicklung der Optokoppler-Schaltung == | == Entwicklung der Optokoppler-Schaltung == | ||
Um die 24V Ausgangsspannung auf 5V zu skalieren wurde eine Optokopplerschaltung entwickelt. | Für die Eingangssignale der Schrittmotortreiber liegt ein LOW-Signal bei 0V Eingangsspannung und ein HIGH bei einer Eingangsspannung von 3,3 bis 5,5V vor. Die Ausgangssignale der SPS haben einen Ausgangsspannung von 24V. | ||
Um die 24V Ausgangsspannung auf 5V zu skalieren und die Treiber ansteuern zu können, wurde eine Optokopplerschaltung entwickelt. | |||
===Gehäuse=== | ===Gehäuse=== | ||
Zeile 344: | Zeile 379: | ||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Unterteil.png|thumb|400px|left| Unterteil | | [[Datei:CNCS7300 Unterteil.png|thumb|400px|left| Unterteil]] || [[Datei:CNCS7300 Deckel.png|thumb|400px|left| Deckel]] | ||
|} | |} | ||
Konstruktionsdateien: [[Datei:S7300 Gehäuse.zip]] | |||
In das Unterteil des Gehäuses wird die Platine mit der Optokoppler-Schaltung eingelegt. Vorne an dem Unterteil ist eine Aussparung für den 25-poligen D-Sub-Stecker gelassen worden. An der Seite des Unterteils finden sich drei weitere Aussparungen, durch diese führen die Kabel von und zur SPS. Der Deckel wird später mit vier Schrauben auf dem Unterteil befestigt. | In das Unterteil des Gehäuses wird die Platine mit der Optokoppler-Schaltung eingelegt. Vorne an dem Unterteil ist eine Aussparung für den 25-poligen D-Sub-Stecker gelassen worden. An der Seite des Unterteils finden sich drei weitere Aussparungen, durch diese führen die Kabel von und zur SPS. Der Deckel wird später mit vier Schrauben auf dem Unterteil befestigt. | ||
Der erste Schritt bei der Konstruktion des mechanischen Teils war es, sich für ein Fertigungsverfahren zur Erstellung des Gehäuses zu entscheiden. | |||
Es wurde sich für den [https://de.wikipedia.org/wiki/3D-Druck 3D-Druck] entschieden, dieser hat den Vorteil das Bauteile kostengünstig, schnell und einfach erstellt werden können, was sich für die Erstellung dieses Gehäuses bestens eignet. Durch den Aspekt der Schnelligkeit konnte innerhalb von einer Woche das Gehäuse konstruiert und gefertigt werden. | Es wurde sich für den [https://de.wikipedia.org/wiki/3D-Druck 3D-Druck] entschieden, dieser hat den Vorteil das Bauteile kostengünstig, schnell und einfach erstellt werden können, was sich für die Erstellung dieses Gehäuses bestens eignet. Durch den Aspekt der Schnelligkeit konnte innerhalb von einer Woche das Gehäuse konstruiert und gefertigt werden. | ||
Zeile 382: | Zeile 419: | ||
===Schaltung=== | ===Schaltung=== | ||
Diese Schaltung wurde entwickelt, um die Ausgangsspannung der SPS-Ausgänge von 24V auf 5V zu bringen. Dies geschieht aus dem Grund, das die Motortreiber ein HIGH-Signal von 3,3 bis 5,5V erfordern. | |||
Beim Entwickeln der Schaltung wurden Widerstände als Pullup-Widerstände eingesetzt. Beim Test mit einem Optokoppler funktionierte dies. Als die Schaltung mit 6 Optokopplern getestet wurde, lagen an den Ausgängen 3,07V an. Es wurde nicht bedacht, dass die Schaltung nun eine Parallelschaltung der Komponenten war und die Widerstände ihren "Pullup-Effekt" verloren haben. Mithilfe von Prof. Göbel ist es gelungen die Widerstände ihrer Funktion entsprechend neu zu platzieren. Folgende Abbildungen zeigen den Schaltplan, sowie die Aufgebaute Schaltung selbst: | |||
{| class="wikitable" | {| class="wikitable" | ||
| [[Datei:CNCS7300 Optokoppler-Schaltplan.PNG|thumb|400px|left| Optokoppler Schaltplan | | [[Datei:CNCS7300 Optokoppler-Schaltplan.PNG|thumb|400px|left| Optokoppler Schaltplan]] || [[Datei:CNCS7300 OptokopllerSchaltung.jpg|thumb|400px|left| Bild der Verdrahtung]] | ||
|} | |} | ||
[[Datei:S7300 Schaltplan Optokoppler.pptx]] | |||
=Komponententest= | =Komponententest= | ||
Mit HTerm ist die Kommunikation zur SPS getestet worden. Die | Mit HTerm ist die Kommunikation zur SPS getestet worden. Die Werte sind fehlerfrei in der SPS angekommen. Die Werte wurden mit der Überwachungsfunktion des TIA-Portals beobachtet. | ||
Die Übertragung der Ausgangssignale wurde mit einem Oszilloskop getestet. Bei einer Impulslänge von einer Millisekunde ist das Signal nicht immer 1 Millisekunde lang gewesen, sondern hat zwischen einer halben Millisekunde und zwei Millisekunden geschwankt. Dieser Effekt hat allerdings keinen Einfluss auf die Genauigkeit bei der Ansteuerung des Motors, da die Schrittmototreiber die Anzahl der Impulse verwertet und nicht die Länge der Impulse. Die Drehgeschwindigkeit des Motors ist dadurch allerdings beschränkt. | |||
{| class="wikitable" | |||
| [[Datei:S7300 Oszilloskop.jpg|800px|thumb|left|Signaltest mit Oszilloskop]] | |||
|} | |||
[[Datei:S7300 06 Komponententest.zip]] | |||
SVN-Ordner: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/06_Komponententest/ Komponententest] | SVN-Ordner: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/06_Komponententest/ Komponententest] | ||
Zeile 394: | Zeile 444: | ||
=Integrationstest= | =Integrationstest= | ||
Bei diesem Test sind über HTerm Strings an die SPS übertragen worden. Es ist der tatsächlich gefahrene Weg mit den eingegeben Daten verglichen worden. Die Berechnung wurde auf Basis dieser Daten angepasst. Videos und Bilder zu diesem Test sind hier zu finden: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/08_Abnahmetest/videos/ Bildmaterial] oder in den Projektdateien: [[Datei:CNCS7300 Siemens SPS CNC.zip]]. | Bei diesem Test sind über HTerm Strings an die SPS übertragen worden. Alle Daten sind erfolgreich übertragen worden. | ||
{| class="wikitable" | |||
| [[Datei:S7300 Test mit Hterm.jpg|800px|thumb|left|Verbindungstest über RS232 mit HTerm]] | |||
|} | |||
Im zweiten Schritt sind Werte für den zu fahrenden Weg eingetragen worden und damit eine Achse verfahren. Der Aufbau ist in der unteren Abbildung zu sehen. | |||
Ergebnis: Es ist der tatsächlich gefahrene Weg mit den eingegeben Daten verglichen worden. Die Berechnung wurde auf Basis dieser Daten angepasst, sodass der eingegebene Weg mit dem tatsächlich gefahrenem übereinstimmt. Videos und Bilder zu diesem Test sind hier zu finden: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/08_Abnahmetest/videos/ Bildmaterial] oder in den Projektdateien: [[Datei:CNCS7300 Siemens SPS CNC.zip]]. | |||
{| class="wikitable" | |||
| [[Datei:S7300 Verfahrtest.JPG|800px|thumb|left|Test der Fahrtweg-Berechnung und Ansteuerung des Schrittmotors über die SPS mit zwischengeschalteter Optokopllerschaltung]] | |||
|} | |||
SVN-Ordner: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/07_Integrationstest/ Integrationstest] | SVN-Ordner: [https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_SPS_siemens/07_Integrationstest/ Integrationstest] | ||
Zeile 425: | Zeile 486: | ||
= Weblinks und Literatur = | = Weblinks und Literatur = | ||
==== | ==== Weblinks ==== | ||
*[ | *[https://new.siemens.com/global/de/unternehmen/nachhaltigkeit/ausbildung/sce/lern-lehr-unterlagen.html Offizielle Selbstlernunterlagen für das TIA-Portal und SIMATIC Hardware] | ||
*[[Automatisierungssystem SPS SIMATIC S7-300|Automatisierungssystem SPS SIMATIC S7-300]] | |||
*[ | |||
*[[SIMATIC S7|SIMATIC S7]] | |||
*[ | |||
==== Literatur ==== | |||
→ zurück zur Übersicht: [[3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)]] | → zurück zur Übersicht: [[3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)]] |
Aktuelle Version vom 7. Februar 2020, 15:26 Uhr
Autoren: Pia Dommen; Luca Riering
→ zurück zur Übersicht: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)
Projektdateien: Datei:CNCS7300 Siemens SPS CNC.zip
Abschlusspräsentation: Datei:CNCS7300 Abschlusspräsentation SPS Siemens.pptx
Einleitung
Im Rahmen des Studiengangs Mechatronik der Hochschule Hamm-Lippstadt wird im 7. Fachsemester das Praktikum Produktionstechnik angeboten. Dieses Praktikum ist Teil des Moduls Global Production Engineering. In diesem Praktikum geht es um die Verwirklichung eines mechatronischen Produktionssystems (MPS) mittels Speicher Programmierbarer Steuerung (SPS), sowie der Ansteuerung von drei Schrittmotor-Achsen im Rahmen des Hauptprojektes "Aufbau einer 3-D-Bearbeitungsmaschine".
Das Thema Ansteuerung einer Schrittmotor-Achse mit Siemens SIMATIC S7-300-CPU313C ist ein Teilthemengebiet des Projekts 3-D-Bearbeitungsmaschine_(Projekt_des_Schwerpunkts_GPE_im_Studiengang_MTR).
Die Bearbeitungsreihenfolge in diesem Projekt lautet wie folgt:
1. Stefan Schweins und Jonas Rüschenschmidt (Step 7)
2. Hendrik Pabst und Ziad Abuelkhair (Step 7)
3. Pascal Siekmann und Gerhard Dick (Step 7)
4. Pia Dommen und Luca Riering (TIA Portal)
Aufgabenstellung
Die Aufgabe des Praktikums war es, eine 3-D Bearbeitungsmaschine zu konstruieren und drei Achsen mit verschiedener Steuerungshardware anzusteuern. Ebenfalls sollten Bearbeitungskoordinaten für Werkstücke übermittelt werden können.
Die Aufgabe bestand darin, die Ansteuerung einer Zahnriemenachse mit Schrittmotor durch den Einsatz von einer speicherprogrammierbaren Steuerung, kurz SPS, SIMATIC S7-CPU300-313C des Unternehmens Siemens zu realisieren. Zur Ansteuerung der Schrittmotoren kommen GeckoDrive-Schrittmotortreiber zum Einsatz.
Die Aufgabenstellung gliedert sich in folgende Teilaufgaben:
- Aufbau
- Einlesen und Einregeln der Soll-Position mittels RS232-Schnittstelle
- Hardwareanalyse und Hardwareaufbau sowie Hinzunahme von Pulldown-Widerständen für die Endschaltersteuerung
- Kabelfertigung
- Test der Ansteuerung
- Ausgabe eines digitalen Signals am Ausgang der SPS
- Leistungsstufe ansteuern
- Programmierung
- Test mit abgeschraubter Verfahreinheit
- Achsenansteuerung für mehrere Achsen duplizieren und einlesen einer definierten Stringfolge
- Test mit Steuerungsalgorithmus
- Kommunikation mit Matlab-Steuerungsalgorithmus testen
- Programmier-Review
- Dokumentation in SVN und Wiki nach dem V-Modell:
Anforderungsdefinition
Bei der Anforderungsdefinition wurde sich zunächst einmal in das Thema und in die Aufgabenstellung hereingearbeitet. Hierzu sind erste Informationen zu den einzelnen Komponenten gesammelt worden und erste Gedanken zu der Umsetzung wurden im Team besprochen. Auch sind in dieser Phase Absprachen mit dem Auftraggeber erfolgt und es wurde ein Budget festgelegt, über das in diesem Projekt verfügt werden kann.
Zusätzlich sind in dieser ersten Projektphase die Anforderungsliste und eine Einkaufsliste erstellt worden. Die Anforderungsliste wurde hier in Excel verschriftlicht und mit Terminen versehen, damit am Ende des Projektes überprüft werden kann, ob alle Punkte der Anforderungen eingehalten worden sind.
SVN-Download: Anforderungsliste
Funktionaler Systementwurf
Bei der Erstellung des funktionalen Systementwurfes ist eine grobe Funktion des Projektes festgelegt worden und diese wurde mittels eines Schaubildes veranschaulicht. Dieser Systementwurf ist zunächst lösungsneutral und stellt zunächst nur eine grobe Richtung dar.
SVN-Download: Funtionaler-Systementwurf.pptx
Technischer Systementwurf
In dem nächsten Schritt, bei der Erstellung des technischen Systementwurfes ist der funktionale Systementwurf dann überarbeitet worden und spezifiziert worden. Dieses Schaubild zeigt die Zerlegung des Systems in einzelne Funktionsbausteine und auch das Zusammenwirken der einzelnen Schnittstellen.
SVN-Download: Technischer-Systementwurf.pptx
Komponentenspezifikation
Nachdem die beiden Systementwürfe festgelegt worden sind, wird sich genauer mit den einzelnen Komponenten beschäftigt. Hierzu wird in Datenblättern der Hard-/Softwarekomponenten nachgeschlagen. Es wird sich auch in das Programm TIA-Portal eingearbeitet
Die verschiedenen Komponenten lauten:
- SIEMENS Hutschiene
- SPS-Netzteil SIMATIC PS307 Datenblatt
- Speicherprogrammierbare Steuerung SIMATIC S7-300-CPU313C SVN-Download: Datenblatt
- Kommunikationsmodul SIMATIC CP340 SVN-Download: Datenblatt
- Schrittmotortreiber GeckoDrive G201x SVN: Datenblätter
- Schrittmotor Igus NEMA 23 Datenblätter
- Leitung 25-polig
- Stecker Sub-D 25-polig
- Widerstände 1 kOhm
- Widerstände 10 kOhm
- Vishay Optokoppler Phototransistor CNY17-3 DIP-6 Transistor mit Basis DC Datenblatt
- Mean Well DR-15-5 Hutschienen-Netzteil (DIN-Rail) 5 V/DC 2.4 A 12 W 1 x Datenblatt
SVN-Download: Komponentenspezifikation.xlsx
Entwicklung
Wie eine Siemens SPS funktioniert wird in dem Artikel Automatisierungssystem SPS SIMATIC S7-300 genauer beschrieben. Im Folgenden wird der aktuelle Programmstatus näher erläutert. Das Programm ist unter diesem Link im SVN hinterlegt:
SVN-Ordner: SPS-Programm
Programmablaufplan
Zur Planung der zu programmierenden Software wurde zunächst ein Programmablaufplan erstellt. Dieser stellt die Funktionsweise des SPS-Programmes dar und ist für die weitere Verwendung im SVN hinterlegt.
SVN-Download: Programmablaufplan.pptx
Projektierung im TIA V15.1
Erstellung des Projektes im TIA-Portal V15.1
Nach dem unter „Neues Projekt erstellen“ ein Projekt angelegt wurde, öffnet sich das Fenster „Erste Schritte“. In diesem Fenster werden diverse Auswahlmöglichkeiten für den Beginn des Projektes angeboten. In den meisten Fällen ist es am sinnvollsten damit anzufangen die Hardware anzulegen und zu parametrieren. Mit „Ein Gerät konfigurieren“ öffnet sich die passende Oberfläche, „Geräte & Netze“. In diesem Fenster kann über die Beschreibung und die Artikel-Nummer die vorhandene Hardware ausgewählt und in der passenden Version dem Projekt hinzugefügt werden.
Die folgenden Bilder veranschaulichen das Vorgehen:
Anlegen und Parametrieren von Hardware
Im Projekt wird in der „Projektnavigation“ unter „Gerätekonfiguration“ die Hardware angezeigt (Abbildung CP340 Parameter). Mit der Anwahl einer Baugruppe, erscheint ein Eigenschaftsfenster. In diesem Projekt besteht die Hardwarekonfiguration aus der S7-300 PLC und dem CP340-Modul zur Kommunikation über RS-232. Im Reiter "Allgemein" ist das Kommunikationsprotokoll des Moduls zu parametrieren. Zu diesen Parametern gehören auch die E/A-Adressen. Diese können über "Eigenschaften" -> "Allgemein" -> "E/A-Adressen", sowohl bei der SPS als auch beim Kommunikationsmodul, eingestellt werden. Folgende Abbildung verdeutlichen den Vorgang:
Hier wird der zu verwendende Speicherbereich der PLC ausgewählt. Die Empfangenen oder zu sendenden Daten werden in diesem Bereich gespeichert und/oder ausgelesen. Zu beachten ist, dass bei diesem Modul die Baudrate auf 9600 festgelegt ist und nicht verändert werden kann. Bei der Parametrierung der PLC ist zu erwähnen, dass die PLC zwei integrierte IO-Karten verbaut hat. Der PLC muss eine IP-Adresse gegeben werden und den IO-Karten muss genau wie dem CP 340 Modul ein Speicherbereich zugeordnet werden.
Aufbau der Kommunikation mit dem CP 340 Kommunikationsmodul
Nachdem das Modul der Kommunikation entsprechend parametriert worden ist, muss die Kommunikation in der PLC angelegt werden. Das Modul CP340 ermöglicht eine serielle Kommunikation über einen RS232-Bus. Über diesen Bus werden die Koordinaten vom Steuerungsalgorithmus an die SPS übertragen. Die Datenübertragung erfolgt als String im ASCII-Format. Bei der Konfiguration ist darauf zu achten, dass in den Einstellungen des CP340-Moduls die Datenübertragung auf das ASCII-Format eingestellt ist. Außerdem unterstützt die CP340 nur eine Baudrate bis 9600 Baud. Darauf ist bei der Verbindung zu Kommunikationsteilnehmern zu achten.
Der übertragene String ist wie folgt aufgebaut:
- Referenzfahrt: U12345V12345W12345;
- Koordinatenpunkt: X12345Y12345Z12345F12345;
Mittels der Referenzfahrt wird der Steuerung ein Referenzkoordinatenpunkt übermittelt, welcher die aktuellen Positionen der Achsen repräsentiert. Dieser muss zu Beginn jedes Fräsvorganges einmalig übermittelt werden um dem System seine Ursprungskoordinaten mitzuteilen. U repräsentiert hierbei die X-Achse, V die Y-Achse und W die Z-Achse. Die darauffolgenden Zahlen stehen für die Koordinaten der jeweiligen Achse in 1/100mm. Über den Koordinatenpunkt wird der Steuerung die nächste Zielkoordinate übermittelt. X, Y und Z repräsentieren die jeweilige Achse, F steht für den Vorschub. Hier ist die Maßeinheit mm/min.
Um die Kommunikation in der PLC einzurichten, muss die Funktion „P_RCV“ (Abbildung CP340 P_RCV-Funktion) im zyklischen Programm der PLC aufgerufen werden. Die Funktion benötigt zusätzlich einen Speicherbaustein „P_RCV_DB“ und einen Instanzfunktionsbaustein „P_RCV“. Die Beschaltung der Ein- und Ausgänge der Funktionsblöcke ist der Funktionsbeschreibung der Blöcke in der TIA-Portal Hilfe zu entnehmen:
Kürzel | Begriff | Erklärung |
---|---|---|
EN_R | Freigabe für Daten lesen | / |
R | Auftragsabbruch | Laufender Auftrag wird abgebrochen. Empfang gesperrt. |
LADDR | Basisadresse des CP 340 | Die Basisadresse wird aus STEP 7 entnommen. |
DB_NO | Datenbausteinnummer | Empfangs-DB-Nr.: CPU-spezifisch, Null ist nicht erlaubt. |
DBB_NO | Datenbytenummer | 0 ≤ DBB_NO ≤ 8190 Empfangsdaten ab Datenbyte. |
NDR 1 | Auftrag fertig ohne Fehler, Daten übernommen | Parameter STATUS == 16#00. |
ERROR 1 | Auftrag abgebrochen mit Fehler | Parameter STATUS enthält die Fehlerinformation. |
LEN 1 | Länge des empfangenen Telegramms | 1 ≤ LEN ≤ 1024, Angabe in Anzahl Byte (Muss auch am Modul parametriert werden!). |
STATUS 1 | Spezifikation des Fehlers | Bei ERROR == 1 steht im Parameter STATUS die Fehlerinformation. |
Test der Kommunikation mit HTerm
Das Programm HTerm ist ein Programm zur seriellen Kommunikation. In diesem Fall zwischen dem RS232-Port eines PC und der Siemens SPS. Für eine funktionierende Kommunikation der beiden Teilnehmer müssen zunächst einige Parameter eingestellt werden:
Baudrate = 9600;
Parität = Keine (None);
Port = COM Port an dem das Kommunikationsmodul angeschlossen ist;
Databits = 8;
Stopbit = 1.
Bei der Eingabe aber auch bei der Ausgabe der Daten wird sich aus der Auswahl von ASCII, hexadezimal, binär und dezimalem Code entschieden.
Die nächste Abbildung zeigt die Oberfläche des Programmes.
Steuerung der Ausgänge
Zur Steuerung der Ausgänge müssen diese in den PLC-Variablen angelegt werden und der entsprechenden Adresse an den IO-Karten zugewiesen werden (siehe nächste Abbildung). Die Ausgänge können dann die wie Variablen in der Programmierung verwendet werden.
Programmierung
Die PLC arbeitet zyklisch einen Operationsbaustein ab, den OB1 („Main“-OB). In diesem OB müssen alle Funktionen aufgerufen werden, welche von der PLC abgearbeitet werden sollen. Funktionen die nicht im OB aufgerufen werden, haben keinerlei Auswirkung auf den Ablauf des Programms.
Um die CNC-Fräse zu programmieren, ist sich für die Programmiersprachen FUP (Funktionsplan) und SCL (Structured Control Language) entschieden worden.
Die Berechnung und Konvertierung der Werte zur Ansteuerung der Achsen ist in einer SCL-Funktion erfolgt. Das Pulsen und die Übertragung der Signale ist in einem Funktionsbaustein in FUP realisiert worden.
SCL-Funktion Calculate:
#Wenn das erste Zeichen der übergebenen Zeichenkette (Zeichen) den Char 'X' enthält, beginnt die Berechnung der Schritte und Delay-Zeiten.
IF #Zeichen = 'X' THEN
#Das Schrittverhältnis wird mit der Formel Schrittverhätnis = Distanz / (360 / Schrittwinkel) * Treiberverhältnis errechnet und im globalen DB gespeichert.
"Global".Schrittverhaeltnis := #Distanz / (360 / #Schrittwinkel) * #Treiberverhaeltnis; //0.033
#Die übergebene Zeichenketten für X-Richtung ("Global".Received_Data_Splitted[0]), Y-Richtung ("Global".Received_Data_Splitted[1]), Z-Richtung ("Global".Received_Data_Splitted[2]) und Vorschub
("Global".Received_Data_Splitted[3]) werden von string zu integer konverteiert.
"Global".approach[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]);
"Global".approach[1] := STRING_TO_INT("Global".Received_Data_Splitted[1]);
"Global".approach[2] := STRING_TO_INT("Global".Received_Data_Splitted[2]);
"Global".approach[3] := STRING_TO_INT("Global".Received_Data_Splitted[3]);
#Die Anzahl der Schritte in die jeweilige Richtung wird mit Schritte = Referenzposition - anzufahrende Position / Schrittverhältnis errechnet
"Global".X_steps := ("Global".refrences[0] - DINT_TO_REAL("Global".approach[0])) / "Global".Schrittverhaeltnis;
"Global".Y_steps := ("Global".refrences[1] - DINT_TO_REAL("Global".approach[1])) / "Global".Schrittverhaeltnis;
"Global".Z_steps := ("Global".refrences[2] - DINT_TO_REAL("Global".approach[2])) / "Global".Schrittverhaeltnis;
#Die errechnete Anzahl der Schritte wird mit der Funktion ABS in einen absoluten Wert konvertiert.
"Global".X_steps_abs := ABS("Global".X_steps);
"Global".Y_steps_abs := ABS("Global".Y_steps);
"Global".Z_steps_abs := ABS("Global".Z_steps);
#Die Vorschubgeschwindigkeit wird mit Vorschubgeschwindigkeit = Vorschub / (Schrittverhältnis * 60) errechnet
"Global".F_velocity := DINT_TO_REAL("Global".approach[3]) / ("Global".Schrittverhaeltnis * 60);
#Die Zeichenketten für X-Richtung, Y-Richtung, Z-Richtung und Vorschub werden von integer zu real konverteiert.
"Global".refrences[0] := DINT_TO_REAL("Global".approach[0]);
"Global".refrences[1] := DINT_TO_REAL("Global".approach[1]);
"Global".refrences[2] := DINT_TO_REAL("Global".approach[2]);
#Errechnen der Länge des zu fahrenden Weges (Hypothenuse im dreidimensionalen Raum)
"Global".hypothenuse := SQRT("Global".X_steps * "Global".X_steps
+ "Global".Y_steps * "Global".Y_steps
+ "Global".Z_steps * "Global".Z_steps);
#Errechnen der Delay-Zeiten für die einzelnen Achsen mit Delay-Zeit = ((Schritte / Hypothenuse) * Vorschubgeschwindigkeit) * 2 * 0.1
"Global".Delay_X_Real := (("Global".X_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1;
"Global".Delay_Y_Real := (("Global".Y_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1;
"Global".Delay_Z_Real := (("Global".Z_steps / "Global".hypothenuse) * "Global".F_velocity) * 2 * 0.1;
#Delay-Zeit für Konvertierung in Zeit vorher in absoluten Wert konvertieren
"Global".Delay_X_Real := ABS("Global".Delay_X_Real);
"Global".Delay_Y_Real := ABS("Global".Delay_Y_Real);
"Global".Delay_Z_Real := ABS("Global".Delay_Z_Real);
#Delay-Zeit von Real zu double und von double in Time konvertieren
"Global".Delay_X_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_X_Real * 100) / 100); // * 100 / 100 to prevent dataloss!!!
"Global".Delay_Y_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Y_Real * 100) / 100);
"Global".Delay_Z_Time := DINT_TO_TIME(REAL_TO_DINT("Global".Delay_Z_Real * 100) / 100);
#Wenn das erste Zeichen der Zeichenkette der Char 'U' ist, schreibe die Zeichenketten in das Array für die Referenzwerte
ELSIF #Zeichen = 'U' THEN
"Global".refrences[0] := STRING_TO_INT("Global".Received_Data_Splitted[0]);
"Global".refrences[1] := STRING_TO_INT("Global".Received_Data_Splitted[1]);
"Global".refrences[2] := STRING_TO_INT("Global".Received_Data_Splitted[2]);
END_IF;
FUP-Funktionsbaustein MotorControl:
MotorControl |
---|
Zykluszeit
Die Zykluszeit ist die Zeit, die das Betriebssystem für die Bearbeitung eines Programmdurchlaufes - d. h. eines OB 1-Durchlaufes - sowie aller in diesem Durchlauf untergebrachten Programmteile und Systemtätigkeiten. Diese Zeit wird überwacht.
Diese Verzögerung wird durch unterschiedliche Einflussfaktoren verursacht. Im Folgenden werden die Wichtigsten genannt:
- Grundlast (K)
- Anzahl Bytes im Baugruppenträger 0 (A)
- Anzahl Bytes im Baugruppenträger 1 bis 3 (B)
- Verlängerung der Anwenderprogramm - Bearbeitungszeit
Das Betriebssystem der CPU führt neben der eigentlichen Abarbeitung des Anwenderprogramms noch weitere zeitgleiche Prozesse durch (z. B. Timerverwaltung des Kernbetriebssystems). Diese Prozesse verlängern die Bearbeitungszeit des Anwenderprogramms. Daher muss bei der Berechnung der Zykluszeit mit dem Bearbeitungszeit-Faktor multipliziert werden. Für CPU313C beträgt dieser Faktor 1,10.
Im Folgenden sind die Einflussfaktoren, die für die Berechnung der Zykluszeit notwendig sind, aufgelistet:
Konstante | Anteile | CPU313C_Bearbeitungszeit |
---|---|---|
K | Grundlast | 100µS |
A | je Byte in Baugruppenträger 0 | 35µS |
B | je Byte in Baugruppenträger1 bis 3 | 43µs |
Die berechnete Zykluszeit ergibt sich aus der Summe aller folgenden Einflussfaktoren:
Zykluszeit_verzögert
In dieser Formel ist A=0, weil im Versuchsaufbau der Baugruppenträger 0 nicht gebraucht wird. Der Faktor B wird mit 4 multipliziert, da man im Baugruppenträger 32 Bit(digitale Input und Output)= 4 Byte hat.
Daher lautet die Formel:
Zykluszeit_verzögert :
Je nach Programmablauf kann die Zykluszeit variieren. Dies wird verursacht durch:
- bedingte Befehle
- bedingte Bausteinaufrufe
- unterschiedliche Programmpfade
- Schleifen usw.
Entwicklung der Optokoppler-Schaltung
Für die Eingangssignale der Schrittmotortreiber liegt ein LOW-Signal bei 0V Eingangsspannung und ein HIGH bei einer Eingangsspannung von 3,3 bis 5,5V vor. Die Ausgangssignale der SPS haben einen Ausgangsspannung von 24V. Um die 24V Ausgangsspannung auf 5V zu skalieren und die Treiber ansteuern zu können, wurde eine Optokopplerschaltung entwickelt.
Gehäuse
Eine der Anforderungen aus der Anforderungsliste stellt die Entwicklung eines Gehäuses für die Platine mit der Optokoppler-Schaltung dar. Hierzu wurde vor dem Konstruieren in dem CAD-Programm Siemens NX eine händische Skizze angefertigt. Dort wurden die Maße eingetragen und es wurden zunächst die Überlegungen gemacht, wie diese Bauteile aussehen könnten. Das Gehäuse besteht aus zwei Bauteilen: dem Unterteil und dem Deckel
Konstruktionsdateien: Datei:S7300 Gehäuse.zip
In das Unterteil des Gehäuses wird die Platine mit der Optokoppler-Schaltung eingelegt. Vorne an dem Unterteil ist eine Aussparung für den 25-poligen D-Sub-Stecker gelassen worden. An der Seite des Unterteils finden sich drei weitere Aussparungen, durch diese führen die Kabel von und zur SPS. Der Deckel wird später mit vier Schrauben auf dem Unterteil befestigt.
Der erste Schritt bei der Konstruktion des mechanischen Teils war es, sich für ein Fertigungsverfahren zur Erstellung des Gehäuses zu entscheiden.
Es wurde sich für den 3D-Druck entschieden, dieser hat den Vorteil das Bauteile kostengünstig, schnell und einfach erstellt werden können, was sich für die Erstellung dieses Gehäuses bestens eignet. Durch den Aspekt der Schnelligkeit konnte innerhalb von einer Woche das Gehäuse konstruiert und gefertigt werden.
Der verwendete 3D-Druck ist ein additives Fertigungsverfahren. Ein festes Material, Filament wird durch den Extruder aufgewärmt und auf das Druckbett aufgetragen. Dies geschieht Schicht für Schicht, durch diese schichtweise Herstellung können dreidimensionale Gegenstände gedruckt werden.
Nach Absprache mit der Firma Trilux dürfen die Bauteile auf dem 3D-Drucker der Firma gedruckt werden. Es musste sich im nächsten Schritt über das Filament informiert werden. Für das Gehäuse wird sich für das häufig verwendete ABS (Acrylnitril-Butadien-Styrol) entschieden, dieses hat die folgenden Eigenschaften (aus dem Datenblatt entnommen).
Die folgende Tabelle veranschaulicht einmal die wichtigsten Eigenschaften dieses Werkstoffes:
Acrylnitril-Butadien-Styrol (ABS) |
---|
hohe Zugfestigkeit von 1681,5 MPa |
hohe Oberflächenqualität |
hohe Druckgeschwindigkeit sind möglich |
geringe Biegefestigkeit 70,5 MPa |
gute Haftung am Druckbett |
geringes spezifisches Gewicht 1,10 g/cm³ |
niedrige Schmelztemperatur 225 - 245˚C |
Um nach dem 3D-Druck ein ansprechendes Ergebnis und maßhaltige Bauteile zu bekommen, ist die Schmelztemperatur wichtig, diese sollte unter 280°C liegen, da der 3D-Drucker nur bis zu dieser Temperatur das Material erhitzen kann. Für eine hohe Oberflächenqualität sollte ein Material ausgewählt werden, dass eine hohe Haftung am Druckbett hat. Denn ohne diese hohe Haftung würden die Teile zum einen nicht maßhaltig werden, da das Material „verrutscht“ und zum anderen würde die Oberfläche nicht ansprechend sein. Diese Eigenschaften beinhaltet das ABS, wodurch sich daher entschieden wurde. Ein weiteres Betrachtetes Filament war das PLA. Dieses Filament eignet sich jedoch nur eingeschränkt für das Gehäuse, da es elastischer ist und sich schlechter drucken lässt, durch eine schlechte Haftung auf dem Druckbett.
Schaltung
Diese Schaltung wurde entwickelt, um die Ausgangsspannung der SPS-Ausgänge von 24V auf 5V zu bringen. Dies geschieht aus dem Grund, das die Motortreiber ein HIGH-Signal von 3,3 bis 5,5V erfordern. Beim Entwickeln der Schaltung wurden Widerstände als Pullup-Widerstände eingesetzt. Beim Test mit einem Optokoppler funktionierte dies. Als die Schaltung mit 6 Optokopplern getestet wurde, lagen an den Ausgängen 3,07V an. Es wurde nicht bedacht, dass die Schaltung nun eine Parallelschaltung der Komponenten war und die Widerstände ihren "Pullup-Effekt" verloren haben. Mithilfe von Prof. Göbel ist es gelungen die Widerstände ihrer Funktion entsprechend neu zu platzieren. Folgende Abbildungen zeigen den Schaltplan, sowie die Aufgebaute Schaltung selbst:
Datei:S7300 Schaltplan Optokoppler.pptx
Komponententest
Mit HTerm ist die Kommunikation zur SPS getestet worden. Die Werte sind fehlerfrei in der SPS angekommen. Die Werte wurden mit der Überwachungsfunktion des TIA-Portals beobachtet. Die Übertragung der Ausgangssignale wurde mit einem Oszilloskop getestet. Bei einer Impulslänge von einer Millisekunde ist das Signal nicht immer 1 Millisekunde lang gewesen, sondern hat zwischen einer halben Millisekunde und zwei Millisekunden geschwankt. Dieser Effekt hat allerdings keinen Einfluss auf die Genauigkeit bei der Ansteuerung des Motors, da die Schrittmototreiber die Anzahl der Impulse verwertet und nicht die Länge der Impulse. Die Drehgeschwindigkeit des Motors ist dadurch allerdings beschränkt.
Datei:S7300 06 Komponententest.zip
SVN-Ordner: Komponententest
Integrationstest
Bei diesem Test sind über HTerm Strings an die SPS übertragen worden. Alle Daten sind erfolgreich übertragen worden.
Im zweiten Schritt sind Werte für den zu fahrenden Weg eingetragen worden und damit eine Achse verfahren. Der Aufbau ist in der unteren Abbildung zu sehen. Ergebnis: Es ist der tatsächlich gefahrene Weg mit den eingegeben Daten verglichen worden. Die Berechnung wurde auf Basis dieser Daten angepasst, sodass der eingegebene Weg mit dem tatsächlich gefahrenem übereinstimmt. Videos und Bilder zu diesem Test sind hier zu finden: Bildmaterial oder in den Projektdateien: Datei:CNCS7300 Siemens SPS CNC.zip.
SVN-Ordner: Integrationstest
Lessons Learned
- Programmierung einer SPS
- Dokumentation
- Projektplanung
- CAD-Konstruktion
- 3D-Druck
- Optokoppler (Elektrische Bauelemente)
Fazit, Zusammenfassung und Ausblick
Das Projekt Ansteuerung einer Schrittmotor-Achse mit Siemens SIMATIC S7-300 SPS stellte eine spannende Herausforderung dar und gewährte tiefen Einblick in die Entwicklung mechatronischer Systeme mit SPS-Steuerungen. Die Einarbeitung in die Siemens-Software und die Programmierung der SPS-Software erfordert gründliche Recherchen und intensive Einarbeitung in das Thema. Dabei sind nicht nur Programmierkenntnisse sondern auch Kenntnisse in der Elektrotechnik notwendig. Die Programmierumgebung TIA ist bietet vielfältige Möglichkeiten zur Programmierung von SPS-Steuerungen. Mit seinen vier, auf unterschiedliche Anwender zugeschnittenen Programmiersprachen, zielt TIA auf breites Feld von Entwicklern ab.
Projektdateien: Datei:CNCS7300 Siemens SPS CNC.zip
Im Rahmen des Praktikums erledigte Aufgaben:
- Realisierung und Test der seriellen Schnittstelle
- Programmablaufplan erstellen
- Einlesen und einregeln der Soll-Position
- einfacher Positionier-Algorithmus für eine Achse
- Positionier-Algorithmus für drei Achsen
- Erstellung des neuen Optokoppler-Schaltplans
- Fertigung der neuen Platine für Verbindung mit den weiteren Hardware-Komponenten über D-SUB 25-poliges Kabel
Was ist noch nicht fertig:
- Test der Funktionalität an der CNC
Weblinks und Literatur
Weblinks
Literatur
→ zurück zur Übersicht: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)