Python — mein persönlicher Vergleich verschiedener IDEs für Python

IDEs für Python

Auf der Python Wiki-Seite IntegratedDevelopmentEnvironments findet man fast alles was es zum Thema Python IDE zu wissen gibt. Für mich sind folgende 4 IDEs interessant:

Installation und erste Schritte mit den verschieden IDEs:

IDLE: Die Python IDE

Installieren braucht man die IDLE nicht, da sie automatisch mit Python mit installiert wird.
Bei Ubuntu 12.04 ist Python3 schon vorinstalliert.
Bei Mac OS X mit homebrew die aktuelle Python Version installiert warden. Dazu sind die beiden brew Befehlen nötig:

brew install python3
brew linkapps

Zuerst wird Python 3.3.2 installiert und dann die Anwendungen in den Programm-Ordner verlinkt. Eventuell muss die Tcl/Tk Installation erneuert wären, da sonst Fehler bei der Benutzung von tkinter auftreten können, nähere Information findet man auf der Seite IDLE and tkinter with Tcl/Tk on Mac OS X. Wichtig ist, dass danach Python3 neu installiert werden muss, da die Links auf da Tcl/Tk Framework erstellt werden.

Es ist nun möglich die IDLE als interaktive Python-Shell zu benutzen. Mit „File — New Window“ kann eine Texteditor Fenster geöffnet werden. Das fertige Python-Script kann mit der Taste „F5“ in den Namesraum der IDLE geladen werden und auf Element so zugegriffen werden.
IDLE als Entwicklungumgebung nutzen
Zurück zur Übersicht

Eclipse mit dem Plugin PyDev

Um das PyDev-Plugin in Eclipse zu installieren, muss unter „Help — Install new Software“ die PyDev Quellen http://pydev.org/updates eingetragen werden.
PyDev Installationsquellen
Ist das Plugin installiert, so kann unter „New Project — PyDev Project“ ein neues Pythonprojekt gestartet werden. Die Standard-Darstellung (Java Entwicklung) von Eclipse wechselt dann automatisch in die PyDev-Darstellung.
Eclipse mit dem Plugin PyDev
Zurück zur Übersicht

gEdit als Python IDE

Gedit stellt den Standard-Editor der Ubuntu Distribution dar, es ist also in gewisser Weise natürlich Gedit auch als Python-Entwicklungswerkzeug zu benutzen. Leider müssen die Python-Plugins zusätzliche Quellen eingetragen werden, damit die Plugins unter Gedit zur Verfügung stehen. In den folgenden Links findet man alle nötigen Informationen:
Gedit as a Python IDE?
Gedit BC Developer Plugins
Zurück zur Übersicht

Vi als Python IDE

Im Blog-Artikel Turning Vim into a modern Python IDE
Zurück zur Übersicht von John Anderson wird erklärt wie der Texteditor vi in eine Python-IDE verwandelt werden kann. Da ich vi/vim für fast alle Konfigurationsarbeiten unter
Mac OSX oder Ubuntu/Debian benutze ist die Vorstellen vi für die Entwicklung von Programmen unter Python für mich sehr spannend. Sobald ich die nötige Zeit habe vi in eine Python IDE zu verwandeln, poste ich meine Erfahrungen hier. Bis dahin verweise ich auf den Artikel von John Anderson.

Raspberry Pi — Erste Eindrücke

Endlich ist es so weit, nach mehreren Monaten Wartezeit ist endlich mein Raspberry Pi angekommen.

Bevor es los geht muss man noch auf einer SD-Karte ein Image des Betriebsystems auf die SD-Karte
kopieren. Dazu lädt man von der Seite Raspberry Pi Downloads das gewünschte Image herunter. Ich habe mich für Debian “squeeze” entschieden.

Um die SD-Karte vorzubreiten sind unter OS X folgende Schritte nötig:bash-3.2# diskutil list
/dev/disk0
#: TYPE NAME SIZE IDENTIFIER
0: GUID_partition_scheme *160.0 GB disk0
1: EFI 209.7 MB disk0s1
2: Apple_HFS Macintosh HD 159.2 GB disk0s2
3: Apple_Boot Recovery HD 650.0 MB disk0s3
/dev/disk1
#: TYPE NAME SIZE IDENTIFIER
0: Apple_partition_scheme *10.8 GB disk1
1: Apple_partition_map 32.3 KB disk1s1
2: Apple_HFSX wolfgang.wolff 10.8 GB disk1s2
/dev/disk3
#: TYPE NAME SIZE IDENTIFIER
0: FDisk_partition_scheme *4.0 GB disk3
1: DOS_FAT_32 NO NAME 4.0 GB disk3s1

Die SD-Karte ist unter der Gerätedatei /dev/disk3 abgelegt. Mittels des bash-Kommandos dd kann man nun dieses Image auf die SD-Karte (low-level) kopieren.bash-3.2# sudo dd bs=1m if=debian6-19-04-2012.img of=/dev/rdisk3
7862272+0 records in
7862272+0 records out
4025483264 bytes transferred in 550.712361 secs (7309593 bytes/sec)

Danach muss die SD-Karte in den Raspberry Pi eingesteckt werden und es kann los gehen.

gEDA — Installation und erste Schritte auf Mac OS X 10.8.2

Vorbereitung und Installation, Update der Homebrew Installation

Eine Anleitung zur Installation findet sich unter Installation.
Die Installation erfolgt (wenn alle Abhängigkeiten erfüllt sind) mit dem Befehl:

ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)"

Wenn schon eine Homebrew Installation vorhanden ist, so muss sie unter Umständen upgedatet werden,
dazu sind folgende Befehle nützlich:

brew update
brew doctor
brew missing

Je nach Ausgabe werden die entsprechenden Pakete oder Abhängigkeiten installiert.

Installation der Programme

Die Installation erfolgt mit Hilfe von brew:

brew install geda-gaf
brew install gerbv

Näheres zur Installation findet sich EDA Resources.

Installation von pcb (Probleme mit einer veralteten Library)

brew install pcb

Fehlermeldung nach dem öffnen

mac:~ macbook$ pcb
dyld: Library not loaded: /usr/local/lib/libpangox-1.0.0.dylib
Referenced from: /usr/local/lib/libgtkglext-x11-1.0.0.0.0.dylib
Reason: Incompatible library version: libgtkglext-x11-1.0.0.0.0.dylib requires version 3001.0.0 or later, but libpangox-1.0.0.dylib provides version 1.0.0
Trace/BPT trap: 5


Installation von xgsch2pcb (Probleme mit dem Python Module dbus)

brew create http://geda.seul.org/dist/geda-xgsch2pcb-0.1.3.tar.gz

geda apps for mac os x

Dateien herunterladen geda-osx-launcher-apps.zip


defaults write org.gpleda.gschem path /usr/local/Cellar/geda-gaf/1.6.2/bin/gschem
defaults write org.gpleda.gerbv path /usr/local/Cellar/gerbv/2.6.0/bin/gerbv
defaults write org.gpleda.pcb path /usr/local/Cellar/pcb/20110908/bin/pcb

DIY — MCGBot Engine Treibersoftware (Teil 1) Theorie

Schrittmotor Treiber: Grundlagen zur Eigenentwicklung

Zunächst einmal ist es um einiges einfacher mit dem Motor Shield von Ladyada zwei Schrittmotoren zu steuern. Der einzige Nachteil ist, dass das Motor Shield so viel kann und deshalb sehr viele digitale Pin verwendet. Für den ersten Prototyp werde ich das Shield von Ladyada und die beiden zugehörigen Bibliotheken (AFmotor und AccelStepper) verwenden. Die beiden Bibliotheken sind gut durchdacht und sehr gut dokumentiert.

Ich habe mich ein letzter Zeit mit der Steuerung von Schrittmotoren befasst und möchte daher die Grundzüge einer eigenen Bibliothek zur Steuerung von zwei Schrittmotoren vorstellen. Mein Startpunkt war der Blog-Eintrag S-Curve for EasyDriver v3 Stepper Motor Driver von Chris E. Er stellt einen Sketch vor, der eine Schrittmotor eine feste Anzahl von Schritten sich drehen lässt. Dabei aber zuerst eine vorgegebene Zeitspanne beschleunigt, die erreichte Geschwindigkeit hält und dann eine vorgegebene Zeitspanne den Motor abbremst. Eigentlich genau das, was man für ein Fahrzeug haben möchte.

Ich habe das Shield S-Curve for EasyDriver v3 Stepper Motor Driver verwendet. Aber man kann auch auf der Grundlage des A3967 Microstepping Driver und einem Breadboard sein eigenes Motorshield zusammenbauen.

Von den Zeitschritten zur Anzahl der Schritte

Als erste Aufgabe soll der Bot ein Stück Weg gerade aus fahren. Dabei soll er zuerst beschleunigen bis zu einer Vorgegebenen maximalen Geschwindigkeit, diese eine bestimmte Zeit beibehalten und dann abbremsen. Da sich die Schrittmotoren bei jedem Puls um einen festen Winkel  $\Delta \theta = \frac{360}{n}$ weiter drehen. Wird die Winkelgeschwindigkeit \phi = \frac{\Delta \theta}{\Delta t} nur durch die Wartezeit  $\Delta t zwischen zwei Pulsen beeinflusst. Wenn  $\Delta t größer wird ist die Winkelgeschwindigkeit kleiner und umgekehrt.

<br /> \begin{tikzpicture}[scale=2]</p> <p>% Include tikz into local preamble<br /> [+preamble]<br />      \usepackage{tikz}<br /> [/preamble]<br />   %\draw[style=help lines] (0,0) grid (7,4);<br />   % dt(t) function<br />   \draw[blue, line width=2] (0,3) -- (2,1);<br />   \draw[blue, line width=2] (2,1) -- (5,1);<br />   \draw[blue, line width=2] (5,1) -- (7,3);  </p> <p>  \draw[grey, dotted, line width=1] (2,3.1) -- (2,-0.1) node[below] {$t_1$};<br />   \draw[grey, dotted, line width=1] (5,3.1) -- (5,-0.1) node[below] {$t_2$};<br />   \draw[grey, dotted, line width=1] (7,3.1) -- (7,-0.1) node[below] {$t_{end}$}; </p> <p>  \draw[grey, dotted, line width=1] (7,3) -- (-0.1,3) node[left] {$\Delta t_{max}$};<br />   \draw[grey, dotted, line width=1] (7,1) -- (-0.1,1) node[left] {$\Delta t_{min}$}; </p> <p>  \draw[->]  (-0.2,0) -- (7.2,0) node[right] {\Large $t$};<br />   \draw[->]  (0,-0.2) -- (0,3.4) node[above] {\Large $\Delta t(t)$};</p> <p>  \node [above] at (1,2.6) {\Lage I};<br />   \node [above] at (3.5,2.6) {\Lage II};<br />   \node [above] at (6,2.6) {\Lage III};</p> <p>\end{tikzpicture}<br />
<br /> \begin{tikzpicture}[scale=2]</p> <p>% Include tikz into local preamble<br /> [+preamble]<br />      \usepackage{tikz}<br /> [/preamble]<br />   %\draw[style=help lines] (0,0) grid (7,4);<br />   % phi(t) function<br />   \draw[red, line width=2] (0,1) -- (2,3);<br />   \draw[red, line width=2] (2,3) -- (5,3);<br />   \draw[red, line width=2] (5,3) -- (7,1);  </p> <p>  \draw[grey, dotted, line width=1] (2,3.1) -- (2,-0.1) node[below] {$t_1$};<br />   \draw[grey, dotted, line width=1] (5,3.1) -- (5,-0.1) node[below] {$t_2$};<br />   \draw[grey, dotted, line width=1] (7,3.1) -- (7,-0.1) node[below] {$t_{end}$}; </p> <p>  \draw[grey, dotted, line width=1] (7,3) -- (-0.1,3) node[left] {$\phi_{max}$};<br />   \draw[grey, dotted, line width=1] (7,1) -- (-0.1,1) node[left] {$\phi_{min}$}; </p> <p>  \draw[->]  (-0.2,0) -- (7.2,0) node[right] {\Large $t$};<br />   \draw[->]  (0,-0.2) -- (0,3.4) node[above] {\Large $\phi(t)$};</p> <p>  \node [above] at (1,2.6) {\Lage I};<br />   \node [above] at (3.5,2.6) {\Lage II};<br />   \node [above] at (6,2.6) {\Lage III};</p> <p>\end{tikzpicture}<br />

Ziel: Berechnung der Schrittanzahl

Die Frage ist nun, welche Anzahl an einzelne Schritte führen die Schrittmotoren im Zeitintervall  $ \left[0,t_{end}\right] $ aus? Dann weiß man um auch welche Gesamtwinkel sich die Schrittmotoren gedreht haben und damit die Länge des zurückgelegten Weges.

Berechnung der Gesamtzeit  $t_N$

Da die Bereiche I und III die identische Anzahl von Schritten haben, genügt es nur Bereich III zu betrachten. Um das Problem einfach zu halten, betrachte ich die Funktion  $\Delta t(t) = a t$ . Damit erhält man die interativen Formel für den neuen Zeitpunkt  $t_{k+1}$ zu:

\begin{eqnarray*} t_{k+1} = t_k + dt  \end{eqnarray*} oder
\begin{eqnarray} t_{k+1} = (1+a) t_k \end{eqnarray} .
Der Ausdruck  $(1+a)$ kann als Propergator der Dynamik verstanden werden.
Der Zusammenhang ist in der Abbildung verdeutlicht.
<br /> \begin{tikzpicture}[scale=1]</p> <p>% Include tikz into local preamble<br /> [+preamble]<br />      \usepackage{tikz}<br /> [/preamble]<br />   %\draw[style=help lines] (0,0) grid (4,4);<br />   % dt(t) function<br />   \draw[blue, line width=2] (0,0) -- (3.7,4);    </p> <p>  \draw[grey, line width=1] (0.7,0.1) -- (0.7,-0.1) node[below] {$t_k$};<br />   \draw[grey, line width=1] (1.3,0.1) -- (1.3,-0.1) node[below] {$t_{k+2}$};<br />   \draw[grey, dotted, line width=1] (3.2,4.2) -- (3.2,-0.1) node[below] {$t_N$}; </p> <p>  \draw[->]  (-0.2,0) -- (4.2,0) node[right] {\Large $t$};<br />   \draw[->]  (0,-0.2) -- (0,4.4) node[above] {\Large $dt(t)$};</p> <p>\end{tikzpicture}<br />

Nun muss man von der interativen Darstellung der Dynamik zu einer expliziten Darstellung übergehen. Dazu schaut man sich die ersten Schritte der Dynamik an:

<br />         \begin{eqnarray*}<br />           t_{0} && \quad \intertext{gegeben} \\<br /> 	  t_{1} &=& (1+a)t_{0} \\<br /> 	  t_{2} &=& (1+a)t_{1} = (1+a)(1+a)t_0 = (1+a)^2 t_0<br /> 	\end{eqnarray*}<br />
Somit erhält man die Vermutung:
<br />         \begin{eqnarray}<br />           t_{k} = (1+a)t_{k-1} = \dots = (1+a)^k t_0<br />         \end{eqnarray}<br />

Beweis dieser Vermutung mit Hilfe der vollständigen Induktion:
Induktions Anfang:  $ k = 0 $ ist ok
Induktions Behauptung:  $ t_k = (1+a)^k t_0 $ sei richtig
Induktionsschritt:  $ k \to k+1 $
<br />         \begin{eqnarray*}<br />           t_{k+1} = (1+a)t_{k} = (1+a) (1+a)^k t_0 = (1+a)^{k+1}t_0<br />         \end{eqnarray*}<br />
Damit ist die Behauptung (2) bewiesen.

Berechnung der Gesamtzeit  $t_N$ nach  $N$ Schritten:
Die Gesamtzeit ergibt sich aus der Summe aller  $dt_k$ für  $k =1 ... N$.
<br />         \begin{eqnarray}<br />           t_N = \sum_{k=1}^N dt_k =  \sum_{k=1}^N a t_k = a \sum_{k=1}^N (1+a)^k t_0<br />         \end{eqnarray}<br />
Mit Hilfe der Formel
<br /> \begin{eqnarray}<br />     \sum_{k=1}^N q^k = \frac{q[q^N - 1]}{q-1} \qquad \intertext{f\"ur} \quad q > 0<br /> \end{eqnarray}<br />
erhält man den Ausdruck:
<br /> \begin{eqnarray}<br />    t_N = (a+1) [(a+1)^N -1] t_0<br /> \end{eqnarray}<br />

Berechnung der Anzahl der Schritte  $N$

Dazu muss man die Gleichung (5) nach der Anzahl der Gesamtschritte  $N$ auflösen:
<br /> \begin{eqnarray*}<br />    t_N $=$ (a+1) [(a+1)^N -1] t_0 \end{eqnarray*}<br />
Auslösen nach $(a+1)^N$ ergibt:
<br /> \begin{eqnarray*}<br />    (a+1)^N = \frac{t_N}{(a+1)t_0} +1<br /> \end{eqnarray*}<br />
Jetzt muss die Gleichung logarithmiert werden. Mit Hilfe der Formel  $log(q^N) = N log(q)$ erhält man:
<br /> \begin{eqnarray*}<br />    (a+1)^N &=& \frac{t_N}{(a+1)t_0} +1 \\<br />    N log(a+1) &=& log(\frac{t_N}{(a+1)t_0} +1).<br /> \end{eqnarray*}<br />
Diese Gleichung kann jetzt nach  $N$ aufgelöst werden. Und somit erhält man die
Formel für die Gesamtanzahl der Schritte im Bereich III:
<br /> \begin{eqnarray}<br />    N_{III} = \frac{log(\frac{t_N}{(a+1)t_0} +1)}{log(a+1)}<br /> \end{eqnarray}<br />
wobei  $t_N$ der Zeit entspricht in der die Schrittmotoren anbremsen (oder beschleunigen).
Die Anzahl der Schritte im Bereich II in welchem die Schrittmotoren mit konstanter Geschwindigkeit laufen ergibt sich zu:
<br /> \begin{eqnarray}<br />    N_{II} = \frac{t_{II}}{\Delta t{min}}.<br /> \end{eqnarray}<br />
Und somit die Gesamtanzahl der Schritte in den Bereichen I bis III:
<br /> \begin{eqnarray}<br />     N = \frac{log(\frac{t_I}{(a_{I}+1)t_0} +1)}{log(a_{I}+1)} +  \frac{t_{II}}{dt{min}} + \frac{log(\frac{t_{III}}{(a_{III}+1)t_0} +1)}{log(a_{III}+1)}<br /> \end{eqnarray}<br />
mit  $ a_i = \frac{dt_{max} - dt_{min}}{t_i} $.

Quellen:

  1. [Arduino]Stepper Motor + EasyDriver + Arduin
  2. S-Curve for EasyDriver v3 Stepper Motor Driver
  3. Datasheet of Dual stepper motor shield

DIY — Software für eine CNC-Maschine

Übersicht

Eventuell kann sie Software auf einem Nexus 7 mit Ubuntu 12.04 installiert werden.
Setting up your Nexus 7 with Ubuntu 12.04
Meine ersten Erfahrungen sind leider ernüchternd, ubuntu unity stürzt oft ab. Leider gibt es noch keine Treiber für OpenGL weshalb pycam nicht richtig funktioniert.

Installation von PyCAM auf Mac OS X 10.8

Es folgt eine kurze Anleitung, wie PyCAM auf Mac OS X 10.8 installiert wird.

  1. Download PyCAM und entpacken.
  2. /Applications/Utilities/Terminal.app ausführen
  3. Installation von Homebrew (eine ausführlichere Anleitung: Installing Homebrew on OS X Mountain Lion 10.8, Package Manager for Unix Tools )
  4. ruby <(curl -fsSkL raw.github.com/mxcl/homebrew/go)
    
  5. Compilieren und installieren von PyGTK
  6. /usr/local/bin/brew install pygtk
    
  7. Compilieren und installieren von PyOpenGL (Password ist notwendig)
  8.   sudo easy_install PyOpenGL
    
  9. Compilieren und installieren von PyGTKGLExt
  10.   /usr/local/bin/brew install pygtkglext
    
  11. PyCAM patchen
  12.   curl "http://goo.gl/U8hJ1" | patch -p0
    
  13. Eintrag in .bashrc erstellen
  14. echo "\nexport PYTHONPATH=/usr/local/lib/python2.7/site-packages" >> ~/.bashrc
    

Nun sollte es möglich sein pyCAM innerhalb des herunter geladenen und entpackten Verzeichnisses zu starten.

./pycam

Diese Anleitung geht davon aus, dass Mac OS X Mountain Lion im original Zustand nach der Installation ist. Wenn fink oder macport installiert sein sollte, ändern sich die Schritte entsprechen.

openSCAM