Vismach ist eine Reihe von Python-Funktionen, mit denen Modelle von Maschinen erstellt und animiert werden können. Vismach zeigt das Modell in einem 3D-Ansichtsfenster an und die Modellteile werden animiert, wenn sich die Werte der zugehörigen HAL-Pins ändern.

Vismach zeigt das Modell in einem 3D-Viewport an

Das Vismach Ansichtsfenster (engl. viewport view) kann wie folgt manipuliert werden:

  • zoom by scroll wheel or right button drag,

  • pan by left button drag,

  • rotate by middle-button drag or shift-drag.

Ein Vismach-Modell hat die Form eines Python-Skripts und kann die Standard-Python-Syntax verwenden. Das bedeutet, dass es mehr als eine Möglichkeit gibt, das Skript zu erstellen, aber in den Beispielen in diesem Dokument werde ich die einfachste und grundlegendste davon verwenden.

Die grundlegende Reihenfolge bei der Erstellung des Vismach-Modells ist

  • Erstellen von HAL-Pins zur Steuerung der Bewegung.

  • Erstellen der Werkstücke (engl. parts).

  • Definiere, wie sie sich bewegen.

  • In Bewegungsgruppen zusammenstellen.

1. Starten des Skripts

Zum Testen ist es nützlich, die #!/usr/bin/env python3 anzugeben, damit die Datei als Skript ausgeführt werden kann. Als Erstes müssen die erforderlichen Bibliotheken importiert werden.

#!/usr/bin/env python3

from vismach import *
import hal
import math
import sys

2. Erstellen der HAL-Pins.

HAL-Pins werden mit der normalen Python-Bibliothek "hal" erstellt und sind nicht spezifisch für Vismach. Weitere Einzelheiten finden Sie im Abschnitt Erstellen von Nicht-Echtzeit Komponenten in Python. Es sollte eine Komponente mit einem Namen erstellt werden, der mit dem Namen der Skriptdatei übereinstimmt, und dann werden die HAL-Pins zu dieser Komponente hinzugefügt. Sie werden mit ihrem Komponenten-Handle und Kurznamen referenziert, wenn sie zur Animation des Vismach-Modells verwendet werden.

c = hal.component("samplegui")
c.newpin("joint0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()

Erzeugt die HAL-Pins samplegui.joint0 und samplegui.joint1. Beim Laden des Vismach-Modells mit loadusr -W samplegui teilt die Funktion c.ready() loadusr mit, dass es bereit ist.

3. Erstellen von Teilen

Am einfachsten ist es wahrscheinlich, die Geometrie in einem CAD-Paket zu erstellen und mit den Funktionen AsciiSTL() oder AsciiOBJ() in das Modellskript zu importieren. Beide Funktionen können eines von zwei benannten Argumenten annehmen, entweder einen Dateinamen oder Rohdaten:

  • Teil = AsciiSTL(Dateiname="path/to/file.stl")
    Teil = AsciiSTL(data="solid part1 facet normal ….")
    Teil = AsciiOBJ(Dateiname="Pfad/Zu/Datei.obj")
    Teil = AsciiOBJ(data="v 0.123 0.234 0.345 1.0 …")`
    Die Teile werden im Vismach-Raum an denselben Stellen erstellt, an denen sie sich im STL- oder OBJ-Raum befinden. Das bedeutet, dass es möglich sein kann, das Modell im CAD-Paket zusammenzusetzen.

Alternativ können Teile innerhalb des Modellskripts aus einer Reihe von Form-Primitiven erstellt werden. Viele Formen werden am Ursprung erstellt und müssen nach der Erstellung an die gewünschte Stelle verschoben werden:

  • cylinder = CylinderX(x1, r1, x2, r2) + cylinder = CylinderY(y1, r1, y2, r2) + cylinder = CylinderZ(z1, r1, z2, r2)
    Erzeugt einen (optional verjüngten) Zylinder auf der angegebenen Achse mit den angegebenen Radien an den angegebenen Punkten auf der Achse.

  • sphere = Sphere(x, y, z, r)`
    Erzeugt eine Kugel mit Radius r bei (x,y,z)

  • triangle = TriangleXY(x1, y1, x2, y2, x3, y3, z1, z2) + triangle = TriangleXZ(x1, z1, x2, z2, x3, z3, y1, y2) + triangle = TriangleYZ(y1, z1, y2, z2, y3, z3, x1, x2)
    Erzeugt eine dreieckige Platte zwischen Ebenen, die durch die letzten beiden Werte parallel zur angegebenen Ebene definiert sind, wobei die Eckpunkte durch die drei Koordinatenpaare gegeben sind.

  • Bogen = ArcX(x1, x2, r1, r2, a1, a2)
    Erstellt eine Bogenform.

  • box = Box(x1, y1, z1, x2, y2, z2)
    Erzeugt ein rechteckiges Prisma mit gegenüberliegenden Ecken an den angegebenen Positionen und Kanten parallel zu den XYZ-Achsen.

  • box = BoxCentered(xw, yw, zw)
    Erzeugt eine xw mal yw mal zw Box, die auf den Ursprung zentriert ist.

  • box = BoxCenteredXY(xw, yw, z)
    Erzeugt eine Box mit der Breite xw / yw und der Höhe z.

Zusammengesetzte Teile können durch Zusammensetzen dieser Primitive entweder zur Erstellungszeit oder nachträglich mittels Collection() erstellt werden:

part1 = Collection([Sphere(100,100,100,50), CylinderX(100,40,150,30)])
part2 = Box(50,40,75,100,75,100)
part3 = Collection([part2, TriangleXY(10,10,20,10,15,20,100,101)])
part4 = Collection([part1, part2])

4. Bewegliche Teile

Teile müssen möglicherweise im Vismach-Raum verschoben werden, um das Modell zusammenzusetzen. Sie müssen möglicherweise auch verschoben werden, um die Animation zu erstellen, da die Rotationsachse der Animation am Ursprung erstellt wird (sich aber mit dem Teil bewegt):

  • Teil1 = Translate([Teil1], x, y, z)
    Verschiebe Teil1 um die angegebenen Abstände in x, y und z.

  • Teil1 = Rotate([Teil1], theta, x, y, z)`
    Dreht das Teil um den Winkel theta um eine Achse zwischen dem Ursprung und x, y, z.

5. Animieren von Teilen

Um das Modell zu animieren (gesteuert durch die Werte der HAL-Pins) gibt es die beiden Funktionen "HalTranslate" und "HalRotate". Damit sich Teile in einer Baugruppe bewegen können, müssen ihre HAL-Bewegungen definiert werden, bevor sie mit dem Befehl "Collection" zusammengesetzt werden. Die Rotationsachse und der Translationsvektor bewegen sich mit dem Teil, wenn es vom Vismach-Skript während des Zusammenbaus des Modells bewegt wird, oder wenn es sich als Reaktion auf die HAL-Pins bewegt, während das Modell animiert wird:

  • part = HalTranslate([part], comp, "hal_pin", xs, ys, zs)
    Die Funktionsargumente sind:

    • zuerst eine Sammlung/ein Teil, die vorher im Skript erstellt werden kann, oder an dieser Stelle erstellt werden kann, wenn dies bevorzugt wird, zB part1 = HalTranslate([Box(....)], ...).

    • Die HAL-Komponente ist das nächste Argument, d.h. das Objekt, das durch den Befehl comp = hal.component(...) zurückgegeben wird. Danach folgt der Name der HAL-Komponente, welche die Bewegung animieren soll. Dieser muss mit einem bestehenden HAL-Pin übereinstimmen, der Teil der zuvor im Skript erstellten HAL-Komponente ist.

    • Dann folgen Sie den X, Y, Z-Skalen.
      Bei einer kartesischen Maschine, die im Maßstab 1:1 erstellt wurde, wäre dies normalerweise 1,0,0 für eine Bewegung in positiver X-Richtung.
      Wenn die STL-Datei jedoch in cm und die Maschine in Zoll erstellt wurde, kann dies an dieser Stelle durch die Verwendung von 0,3937 (1cm /2.54in) als Maßstab korrigiert werden.

  • part = HalRotate([part], comp, "hal_pin", angle_scale, x, y, z)
    Dieser Befehl ähnelt in seiner Funktionsweise HalTranslate, außer dass es normalerweise notwendig ist, das Teil zuerst zum Ursprung zu bewegen, um die Achse zu definieren.

    • Die Drehachse verläuft vom Ursprungspunkt zu dem durch (x,y,z) definierten Punkt.
      Wenn das Teil vom Ursprung an seinen richtigen Ort zurückbewegt wird, kann man davon ausgehen, dass die Drehachse im Teil "eingebettet" bleibt.

    • Drehwinkel werden in Grad angegeben. Für ein Drehgelenk mit einer Skalierung von 0-1 müssten Sie also eine Winkelskala von 360 verwenden.

6. Zusammenbau des Modells.

Damit sich die Teile gemeinsam bewegen können, müssen sie mit dem Befehl Collection() zusammengefügt werden. Es ist wichtig, die Teile zusammenzufügen und ihre Bewegungen in der richtigen Reihenfolge zu definieren. Um zum Beispiel eine Fräsmaschine mit beweglichem Kopf, einer rotierenden Spindel und einer animierten Zugstange zu erstellen, würden Sie dies tun:

  • Erstellen Sie den Hauptteil des Kopfes.

  • Erstellen Sie die Spindel im Ursprung.

  • Definieren Sie die Drehung.

  • Bewegen Sie den Kopf zur Spindel oder die Spindel zum Kopf.

  • Erstellen Sie die Zugstange (engl. draw bar).

  • Definieren Sie die Bewegung der Zugstange.

  • Bauen Sie die drei Teile zu einer Kopfeinheit zusammen.

  • Definieren Sie die Bewegung der Kopfeinheit.

In diesem Beispiel wird die Spindeldrehung durch die Drehung eines Satzes von Mitnehmern angezeigt:

#Drive dogs
dogs = Box(-6,-3,94,6,3,100)
dogs = Color([1,1,1,1],[dogs])
dogs = HalRotate([dogs],c,"spindle",360,0,0,1)
dogs = Translate([dogs],-1,49,0)

#Drawbar
draw = CylinderZ(120,3,125,3)
draw = Color([1,0,.5,1],[draw])
draw = Translate([draw],-1,49,0)
draw = HalTranslate([draw],c,"drawbar",0,0,1)

# head/spindle
head = AsciiSTL(filename="./head.stl")
head = Color([0.3,0.3,0.3,1],[head])
head = Translate([head],0,0,4)
head = Collection([head, tool, dogs, draw])
head = HalTranslate([head],c,"Z",0,0,0.1)

# base
base = AsciiSTL(filename="./base.stl")
base = Color([0.5,0.5,0.5,1],[base])
# mount head on it
base = Collection([head, base])

Schließlich muss eine einzige Sammlung aller Maschinenteile, Böden und Arbeiten (falls vorhanden) erstellt werden:

  • Für eine serial machine wird jedes neue Teil der Sammlung des vorherigen Teils hinzugefügt.

  • Bei einer Parallelmaschine kann es mehrere "Basis"-Teile geben.

So wird zum Beispiel in scaragui.py link3 zu link2, link2 zu link1 und link1 zu link0 hinzugefügt, so dass das endgültige Modell wie folgt erstellt wird:

model = Collection([link0, floor, table])

Bei einem VMC-Modell mit separaten Teilen, die sich auf dem Sockel bewegen, könnte dies der Fall sein:

model = Collection([base, saddle, head, carousel])

7. Weitere Funktionen

  • 'Teil = Farbe([Farbvorgabe], [Teil])`
    Legt die Anzeigefarbe des Teils fest. Beachten Sie, dass im Gegensatz zu den anderen Funktionen die Definition des Teils in diesem Fall an zweiter Stelle steht.
    Die Farbvorgabe besteht aus den drei RGB-Werten und einer Deckkraft. Zum Beispiel [1,0,0,0.5] für ein Rot mit 50% Deckkraft.

  • myhud = Hud()
    Erstellt eine Heads-up-Anzeige in der Vismach-GUI, um Elemente wie Achsenpositionen anzuzeigen.

  • part = Capture()
    Ich habe keine Ahnung, was das bewirkt! Aber es scheint wichtig für die Werkzeugspitzen-Visualisierung zu sein …

  • main(model, tooltip, work, size=10, hud=0, rotation_vectors=None, lat=0, lon=0)
    Dies ist der Befehl, der alles möglich macht, die Anzeige aufbaut usw.

    • model sollte eine Sammlung sein, die alle Maschinenteile enthält.

    • tooltip und work müssen durch Capture() erstellt werden, um ihre Bewegung im Backplot zu visualisieren.
      Siehe scaragui.py für ein Beispiel, wie man die Werkzeugspitze mit einem Werkzeug und das Werkzeug mit dem Modell verbindet.

    • Entweder rotation_vectors oder latitude/longitude können verwendet werden, um den ursprünglichen Blickwinkel zu bestimmen, und es ist ratsam, dies zu tun, da der standardmäßige anfängliche Blickwinkel eher wenig hilfreich ist, wenn man direkt über dem Kopf steht.

    • size legt die Ausdehnung des in der Ausgangsansicht dargestellten Volumens fest.

    • hud bezieht sich auf eine Head-up-Anzeige der Achsenpositionen.

8. Grundstruktur eines Vismach-Skripts.

#imports
from vismach import *
import hal
# Erstellen der HAL Komponenten and Pins
comp = hal.component("compname")
comp.newpin("pin_name", hal.HAL_FLOAT, hal.HAL_IN)
...
# Erstellen von floor, tool and work
floor = Box(-50, -50, -3, 50, 50, 0)
work = Capture()
tooltip = Capture()
...
# Build and assemble the model
part1 = Collection([Box(-6,-3,94,6,3,100)])
part1 = Color([1,1,1,1],[part1])
part1 = HalRotate([part1],comp,"pin_name",360,0,0,1)
part1 = Translate([dogs],-1,49,0)
...
# Erstellen des übergeordneten (engl. top-level) Modells
model = Collection([base, saddle, head, carousel])
# Start der Visualisierung
main(model, tooltip, work, 100, lat=-75, lon=215)