EPS in DXF umwandeln

Mittwoch, Mai 24, 2017 by crypti

Nachdem der Cutworks-Webshop inzwischen auch Kunststoff-Teile im Sortiment hat und nach Aussage unseres Kunststoff-Partners ein Großteil der Kunden mit EPS-Dateien arbeitet, habe ich mich mal im Netz umgeschaut, wie man ein EPS in ein DXF umwandeln kann, ohne das über einen Cloud-Service oder teure Zusatz-Software abbilden zu können.

Nach ziemlich langem Suchen bin ich auf ein Linux-Forum gestoßen, bei dem der entsprechende Blogger eine Umwandlung mit Hilfe von pstoedit durchführt.

WOW - ein Gratis-Tool auf der Linux-Kommandozeile, dass genau die Dinge macht die ich brauche - ich bin begeistert. Nachdem ich dann endlich wusste, wie das Tool heisst, konnte ich auf der sourceforge-Seite sogar eine Windows-Version herunterladen und installieren.

Die ersten Tests zeigten zwar, dass zwingend eine Installation von Ghostscript notwendig ist (die 32bit-Version - egal, ob pstoedit 64 oder 32 bit ist). Nach der Installation konnte ich mit dem folgenden Befehl eine EPS erfolgreich in eine DXF umwandeln:

pstoedit.exe -dt -f dxf:-polyaslines <Quelldatei>.eps <Zieldatei>.dxf 

Optional kann man mit -mm das Modell als mm umwandeln, standardmäßig wird sonst inch benutzt!

Das ganze lässt sich ziemlich leicht als Java-Service im Backend über ProcessBuilder bzw. Runtime.exec() aufrufen, so dass man schwupp die wupp - in kürzester Zeit auch EPS-Dateien lesen kann.

Nachtrag 25.05.2017:

Bei der Integration in Java führte die Ausführung von pstoedit immer dazu, dass nur der DXF-Header erzeugt wurde, nach dem Header brach die Generierung ab. Hintergrund ist, dass bei Aufruf von gswin32c in das Standard-Temp-Verzeichnis (C:\Users\%userName%\Appdata\LocalLow\Temp\2) geschrieben wird, welches als System-Account wohl nicht zur Verfügung steht. Daher führt der Ghostscript-Aufruf wohl zu einer leeren Datei.
Zur Behebung des Problems muss man den Tomcat-Dienst dann einfach als priviligierter Nutzer (z.B. Administrator) ausführen, anschließend funktioniert die Umwandlung ohne Probleme.

Docker - mounten von Netzwerkverzeichnissen

Donnerstag, März 16, 2017 by crypti

Für die Erstellung eines angepassten Yocto-Images für unsere Steuerung besteht die Idee, das auf einem Samba-Share vorhandene Git automatisch auszuchecken, zu bauen und in das FileSystem einzuspielen.
Für die Portabilität habe ich das Yocto-Build-System in einem Docker laufen.

Blauäugig wie ich bin, habe ich in die fstab des Docker-Containers einfach mal die entsprechenden Mountpoints angegeben und nach Installation des cifs-utils - Pakets versucht den SMB-Share mit mount.cifs /mountPoint entsprechend zu mounten. Egal was ich jedoch gemacht habe, immer kam :

mount error(1): Operation not permitted
Refer to the mount.cifs(8) manual page (e.g. man mount.cifs)

Trotz diversen chmod’s (in diversen Foren gelesen) habe ich es jedoch nicht geschafft, das mount zum Laufen zu bekommen, bis ich darauf aufmerksam wurde, dass Docker in der Standard-Einstellung so etwas verbietet.

Dazu benötigt man entweder erweiterte Privilegien im Container bzw. die SYS_ADMIN - Rolle. Leider geht das nur beim erzeugen eines Containers aus einem Image über den run-Befehl, ein bestehender Container kann leider nicht mit den Rechten ausgestattet werden.

Nachdem dann also aus meinem Container über:

docker commit -a "Carsten Schunk" -m "irgendeine Beschreibung" <docker-id> <image-name>

nach ca. 3 Stunden ein Image erstellt worden ist, konnte ich anschließend aus dem Image wiederum einen Docker-Container mit erweiterten Rechten erstellen:

docker run -it --cap-add SYS_ADMIN --privileged <image-name> /bin/bash

Mit diesen erweiterten Rechten konnte man dann auch ein cifs-Dateisystem mounten. Hier sollte aber darauf geachtet werden, in den Mount-Optionen ein nofail einzubauen, ansonsten kann es sein, dass der Start des Containers sehr lange bzw. endlos dauert. I.d.R. wird der mount beim Start erfolglos sein, aber nach einem attach kann man das ja manuell machen.

Muss man erst mal wissen …

Yocto im Docker-Image auf Manjaro

Donnerstag, August 4, 2016 by crypti

Wie bereits im vorigen Thread (Makulu Linux Tutorial) angekündigt, werde ich heute ein kleines Tutorial schreiben, wie man Yocto in einem Docker-Image unter Manjaro Linux zum laufen bekommt.

Grundsystem aktualisieren und Docker installieren

Als Basis nehme ich ein Manjaro Linux, das ich erst einmal mit:

sudo pacman -Sy

und

sudo pacman -Su

auf aktuellen Stand bringe.

Anschließend installiere ich docker mit:

sudo pacman -S docker

Dabei wird der eigentliche docker installiert d.h. client und server.

Update 04.09.2016

Da ich auf meinem neuen Notebook kein Manjaro zum laufen bekomme, hier noch kurz eine Anleitung,
wie man docker in Ubuntu 16.04 LTS installiert:

Erst einmal wird das Ubuntu aktualisiert:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

sollte dabei ein neuer Kernel installiert werden, macht am besten ein Reboot des Systems um den neuen Kernel zu aktivieren.

Anschließend können wir docker mit:

sudo apt-get install docker.io

installieren. Hier auf docker.io achten, da es auch das Paket docker gibt.

Weiter gehts, egal, ob Manjaro oder Ubuntu

Nach der Installation wird erst einmal der docker-Dämon aktiviert und gestartet:

sudo systemctl enable docker

und

sudo systemctl start docker

Damit docker unter Eurem Nutzer läuft, müsst ihr mit:

usermod -a -G docker <nutzername>

euch der Gruppe docker zuordnen. Solltet ihr das nicht machen, bekommt ihr bei Start von Docker immer folgende Meldung:

Cannot connect to the Docker daemon. Is the docker daemon running on this host?

Nach Zuordnung der Gruppe loggt ihr Euch entweder aus und neu ein, macht ein reboot oder könnt viel einfacher noch Euch die Gruppe quasi neu zuordnen:

newgrp docker

Docker ausprobieren

Nun könnt ihr den ersten docker-Befehl ausprobieren:

docker run hello-world

und wenn alles gut gelaufen ist, meldet sich Docker mit einer Willkommens-Nachricht.

Soviel erst mal zur grundsätzlichen Einrichtung. Nun geht es ans eingemachte - der Installation einer virtuellen Ubuntu-Umgebung unter Docker.

Grundsystem im Docker aufsetzen

Als basis für den Build nehme ich ubuntu 14.04. Im Github kann man sehen, dass ein “normales” Ubuntu-Image unter : ubuntu:14.04 abrufbar ist. Das wird dann gleich gepullt.

docker pull ubuntu:14.04

Nun kann mit:

docker run -it ubuntu:14.04 /bin/bash

eine bash im ubuntu-System geöffnet werden. In der Bash des Docker-Containers wird erst mal eine Aktualisierung von apt vorgenommen und die für den Build notwendigen Komponenten installiert:

 apt-get update
 apt-get upgrade
 apt-get install wget unzip make 
  g++ python git diffstat 
  texinfo gawk chrpath libsdl1.2-dev

Jetzt legen wir einen Nutzer an:

useradd -m -s /bin/bash -U smx6Dev -p test

und die verschiedenen Verzeichnisse für den Nutzer:

 mkdir /home/smx6Dev/Downloads
 mkdir /home/smx6Dev/build

Nach Anlegen der Verzeichnisse wird das Yocto-Image vom Kugelmann-Server geholt:

wget -O /home/smx6Dev/Downloads/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip http://public.kugelmann.com/yocto/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip

und entpackt:

unzip /home/smx6Dev/Downloads/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip -d /home/smx6Dev/Downloads

mit den beiden Befehlen:

tar -C /home/smx6Dev/build -xzf /home/smx6Dev/Downloads/sources-base.tar.gz 
 tar -C /home/smx6Dev/build -xzf /home/smx6Dev/Downloads/sources-meta-smx6.tar.gz

werden die Yocto-Sourcen entpackt. Bevor wir uns anmelden und die eigentlichen Yocto-Sachen machen, wird noch der owner umgestellt:

chown smx6Dev:smx6Dev -R /home/smx6Dev/build
 chown smx6Dev:smx6Dev /home/smx6Dev/Downloads

Wenn das getan ist, kann man sich als smx6Dev einloggen:

su - smx6Dev

Nun wechselt man ins build-Verzeichnis und ruft das setup-environment auf:

cd build
 source ./sources/meta-smx6/setup-environment ./build

auf. Last but not least kann dann mit:

bitbake smx6-image

das Bauen des Images angestoßen werden.

Um das ganze noch zu vereinfachen, habe ich ein Image gebaut. Die Einzelnen Schritte sind in dem folgenden Docker-File beschrieben. Falls ihr das benutzen wollt, benennt bitte die Datei in Dockerfile um (ohne txt!).

Wenn man den Docker-Container verlässt, kann man mit:

docker build -t yocto-build .

ausgeführt im Verzeichnis, wo das Dockerfile liegt, ein eigenes Image bauen. Das habe ich jedoch bereits gemacht und es in mein Dockhub-Repository hochgeladen.

Um es abzurufen, muss man sich erst einloggen (als crypti76):

docker login --username=crypti76

und kann dann mit:

docker run -it crypti76/smx6image:latest /bin/bash

das fertig vorbereitete image starten und die letzten Schritte (ab anmelden als smx6Dev) durchführen.