Posted on

netpp für Windows

Kurze Einführung zur Installation von netpp unter Windows:

  1. Laden Sie den offiziellen Installer Python 2.7 (32 bit) herunter und führen Sie ihn aus. Wählen Sie die Option install for all users, da sonst der netpp-Installer allenfalls das Python-Verzeichnis nicht findet.
  2. Ebenfalls herunterladen und ausführen:
    netpp for Windows

    netpp for windows 32 bit installer

  3. Starten Sie den Beispiel-Server via Start Menu->netpp->Run example server. Eine Warnung kann erscheinen und Sie auffordern, die Blockierung des Netzwerk-Dienstes explizit aufzuheben. Nach Freigabe ist der Netpp-Dienst zum Empfang von Anfragen bereit.
  4. Starten Sie die IDLE-Umgebung via Start Menu->Python 2.x->IDLE. Mehr Details siehe unten…

Falls der Python-Installer nicht ausgeführt wurde, wird der netpp-Installationsprozess eine Warnung ausgeben, aber dennoch fortfahren.

Erste Schritte

Wenn IDLE gestartet ist, versuchen Sie zunächst, das netpp-Modul zu importieren. Dann bauen Sie eine Verbindung zum lokalen Beispiel-Server über die connect()-Methode auf.

Das .sync()-Kommando erzeugt einen lokalen Baum aus Eigenschaften mit einem Ursprungs-Knoten ‚r‘. Wenn Sie ein Gerät das erste Mal ansteuern, wird es auf alle verfügbaren Eigenschaften hin abgefragt, d.h. der gesamte Eigenschaften-Baum traversiert. Das kann — je nach Verbindung — etwas Zeit in Anspruch nehmen. Sobald die Abfrage beendet ist, wird die Baumstruktur in einem lokalen Cache gespeichert und nur erneut angefragt, wenn sich die Eigenschaften auf dem Zielgerät geändert haben.

Beachten Sie auch den Hinweis auf der Konsole: ‚Using PWD for storage‘. Wenn kein spezifisches Cache-Verzeichnis eingerichtet wurde, wird die Cache-Datei zum Gerät im momentanen Arbeitsverzeichnis abgelegt, was u.U. nicht erwünscht ist. Um das zu verhindern, richten Sie im Home-Verzeichnis (C:\Users\name) eine Verzeichnisstruktur .netpp\.cache ein (vorangestellten Punkt beachten!).

Die Power-Shell

Zum Kommando-Zugriff auf ein Gerät existieren zwei Optionen:

  • master: Einfache Kommandozeilenanwendung zum schnellen Zugriff
  • netpp-cli: Interaktiver Client

Öffnen Sie die Power-Shell (oder cmd.exe) und wechseln Sie in das netpp-Verzeichnis, in dem die Programme liegen, typischerweise:

cd c:\Program Files (x86)\section5\netpp\bin

Das Programm master.exe ist das oben gelistete einfache Kommandozeilentool. Ohne Argumente ausgeführt, gibt es die verfügbaren ‚Hubs‘ aus. Hubs sind in der netpp-Terminologie die virtuellen Verteiler, an denen Geräte verbunden sein können. Wenn der Beispielserver von oben gestartet ist und freigegeben ist, wird er in der Liste aufgeführt. Versuchen Sie, ihn anzusprechen (ersetzen Sie entsprechend die IP-Adresse):

.\master TCP:192.168.56.1

Dabei werden bei Erfolg die verfügbaren Eigenschaften (‚Properties‘) ausgegeben.

Ähnlich arbeitet netpp-cli, jedoch auf der Basis einer Sitzung:

.\netpp-cli TCP:192.168.56.1

Tippen Sie ? nach dem Prompt um die verfügbaren Properties abzufragen. Die Abfrage eines einzelnen Property geschieht durch die Eingabe des Namens, z.B. Container.Test. Wenn Sie einen Wert setzen wollen, geben Sie ihn als zusätzliches Argument an.

Weitere Resourcen:

LabVIEW wrapper basierend auf OpenG LabPython
Documentation (englisch)
Posted on

Hardwaredesign und CI/Cloud computing — Open source

Automatisches Testen und Verifizieren von Software ist spätestens mit dem Schlagwort „CI“ – Continuous Integration zum Standard für grössere Softwareprojekte geworden. Bei aller möglichen Überflutung mit derartigen Reizwörtern darf man hier kurz innehalten und nachfragen: Was ist das genau? Bringt mir das was?

Ein paar Aspekte für den klassischen innovativen Entwickler zusammengefasst:

  1. Man wird älter und kann/will sich nicht mehr alles merken
  2. Man hat beim allgemeinen Preiskampf weniger Zeit für ausführliche Dokumentation
  3. Die Bibliothek oder das Sammelsurium an möglichst (!) wiederverwartbarem Sourcecode ist angewachsen und der kontiuierliche Unterhalt wird immer aufwendiger
  4. Implementiere ich etwas Neues, mache ich vielleicht etwas Altes kaputt

Diverse Technologien zur Virtualisierung von Komponenten (Docker, Virtuelle Maschinen, Linux Container, …) lösen das Problem insofern, dass sich Bausteine aus Projekt A nicht Baustellen aus Projekt (oder gar Problem) B in die Quere kommen (und umgekehrt). Trotzdem möchte man möglichst viele Gemeinsamkeiten abdecken. Also ergibt sich eine klassische NxM-Komplexität: N Bausteine müssen gegen M Konfigurationen/Varianten getestet werden.

Nichts leichter als das: Systeme aus der Opensource-Szene wie Tinderbox oder der Nachfolger buildbot, oder auch teilkommerzielle Dienste wie Travis CI sind beim Testen von Software soweit behilflich, dass für alle Beteiligten, sei es OpenSource oder proprietär/Closed Source, ein Produkt aus der automatisierten Pipeline ploppt, welches – zumindest im Idealfall – gegen eine Menge Fehlerszenarien und Konfigurationen automatisch getestet worden ist.

Test-Szenarien

Gegen was muss denn jetzt typischerweise getestet werden? Nehmen wir an, unsere Software bietet eine Funktionalität einer Bibliothek, d.h. ein Nutzer soll Funktionen aufrufen können. Generell bietet sich der Ansatz einer Bibliothek aus Erfahrung immer an, mit dem Fokus auf:

  • Wiederverwertbarkeit von Code und Algorithmen
  • Optimale Interoperabilität
  • Optimale Abdeckung vieler Anwendungsfälle und Szenarien

Der Aufruf einer Funktion bedingt immer: Eingabe-Daten haben eine mehr oder minder sinnvolle Ausgabe zur Folge, oder gar einen Absturz oder eine Endlos-Schleife. Standard-Strategie ist bei uns, diese Funktionen mit einem virtuellen ‚Adapter‘ so zum umwickeln (‚wrappen‘), dass sie aus der mächtigen Scriptsprache Python aufgerufen und gegen Szenarien oder Messdaten getestet werden können.

So weit ist das alles mit erträglichem Aufwand für Software implementierbar.

Testen von Hardware

Das Testen von Hardware ist eindeutig kniffliger. Hier lässt sich a priori nicht einfach ein Script schreiben, typischerweise geht es um sogenannte parallel auftretende ‚Test-Vektoren‘. Vereinfacht: Angenommen, wir haben einen (virtuellen) Chip, der 16 Eingänge und 16 Ausgänge besitzt. Rhetorische Frage: Kann der Chip mit allen möglichen Eingangssignalen sinnvolle Ausgangssignale erzeugen, so dass alle Zustände definiert sind?

Da die Eingänge unterschiedliche Funktion haben, wie z.B. Takteingänge, reicht eine statische Analyse niemals aus, und die Testszenarien müssen im Grunde genommen immer auf die Funktion der Ein/Ausgänge zurechtgeschnitten werden. Geht auch alles, allerdings mit erheblich höherem Aufwand als für die Software. Wenn alle möglichen Zustände und Sequenzen irgendwie abgefangen werden müssen, um entweder in einem OK oder ERROR-Status zu enden, wird das Problem je nach Komplexität nicht mehr handhabbar, bzw. reicht ein einziger PC nicht dazu aus.

Dazu kommt, dass die Simulationstools, die solche Fehlerszenarien durchspielen können, noch nicht allzulange auf mehreren Rechnern ohne Kostenexplosion verteilbar sind. D.h. für die „Cloud“ ist das für den einfachen Anwender oder die Kleinfirma keine legale Option. Es muss also auf OpenSource zurückgegriffen werden, was aber weitere Risiken mit sich bringt: Opensource ist, spätestens nach dem Download, nicht mehr kostenfrei und es gibt – ohne einen vorliegenden Supportvertrag – keine Garantie für gewünschte Funktionalität.

Der Paradigmenwechsel

Wie schon vor vielen Jahren die Gnu Compiler Collection (GCC) teure, proprietäre Compilerlösungen abgelöst hat, und bei allen Unkenrufen zum Trotz die Nummer Eins beim Übersetzen von Sourcecode für andere Architekturen geworden ist, zeichnet sich auch in der Hardware-Welt ein Paradigmenwechsel ab. Wird sind eigentlich an dem Punkt, wo jeder mit entsprechend Know-How in der Lage ist, sich sein eigenes Computerdesign zu entwerfen und es auch zu testen, ohne dass es an Geld für entsprechende Werkzeuge mangelt. Die Übergänge zwischen Software- und Hardware (in der akademischen Welt oft noch klar getrennt) werden fliessender, gefragt sind robuste Lösungen, Gesetzgeber pochen mehr auf Garantie und Haftung — auch bei kleinen innovativ-agilen Entwicklern.

Wie löst sich diese gordische Knoten?

Dazu liesse sich ein Buch schreiben. Aber warum nicht gleiches mit Gleichem vergelten: In der Opensource-Welt hört man schon mal den Spruch: Read the source, Luke.

Also möchte ich schliesslich auf das OpenSource-Konzept ‚MaSoCist‘ verweisen, was wiederum auf einem Sammelsurium an existierenden OpenSource-Tools aufbaut, seien genannt:

  • Der gcc GNU compiler
  • GHDL – ein OpenSource VHDL Simulator
  • Linux, GNU Make
  • … und eine Handvoll Software-Tools aus dem eigenen Hause

Als Sourcecode-Hoster wurde github ausgewählt, so findet sich entsprechend das Code-Repository unter

https://github.com/hackfin/masocist

Kurzumriss MaSoCist

Der MaSoCist ist im Grunde genommen eine komplexe Anleitung und Regelsammung um Hardware zu bauen. Dazu gehört a priori die Simulation derselbigen. Bei dieser Art der Entwicklung muss man sich dabei auf sehr viele Dinge verlassen, insbesondere darauf, dass:

  • Die OpenSource-Werkzeuge (die teilweise gebaut werden) korrekt funktionieren
  • Die Abhängigkeiten von externen Werkzeugen und Bibliotheken stimmen

Das heisst, wir müssen unsere Tools auch laufend gegentesten, denn irgend jemand könnte im Laufe der Entwicklung etwas beschädigen.

So ist der MaSoCist nicht nur ein Baukasten für Hardware, er testet sich zudem selbst, dank einiger Dienste, die die OpenSource-Welt für uns bereitstellt.

Was baue ich jetzt genau mit dem MaSoCist?

Grob lässt sich das wie folgt auflisten:

  • Es wird ein virtueller (oder auch für FPGA synthetisierbarer) Mikroprozessor gebaut
  • Es wird die zugehörige Peripherie (UART, I2C, …) gebaut
  • Es wird die Test-Firmware für eine gewisse Plattform übersetzt und als ROM-Datei in die Simulation integriert
  • Das Ganze lässt sich wie ein Linux-Kernel konfigurieren, d.h. CPU core, Anzahl und Art der Interfaces lassen sich entsprechend der Möglichkeiten, die die mitgelieferten Style-Sheets bieten, auswählen.
  • Schliesslich: Die virtuelle Architektur wird mit externen Stimuli per sog. Co-Simulation auf korrekte Funktion getestet

Optional erstellt der MaSoCist auch die komplette Systemdokumentation aller Register, usw. Natürlich muss manuell die passende Dokumentation zum ‚Chip‘ erstellt werden.

Simulationsszenarien

Mehrere Ansätze sind hier gängig:

  • Simulation eines Hardware-Designs ohne CPU gegen externe Software, Daten, oder Stimuli (UART-Eingaben, ..)
  • Simulation des Gesamtsystems mit der innewohnenden Firmware und CPU, allenfalls ohne externe Stimuli

Der MaSoCist nutzt hierbei die Möglichkeiten, die GHDL bietet, um entweder eine Simulation mit statischen/fixen Testmustern zu stimulieren (wie aus einer VHDL-Testbench heraus) oder die dynamischen Ansätze der Co-Simulation über unsere ghdlex Bibliothek. Hierbei können einfache Kommandozeilenaufrufe oder ein Python-Script die Simulation ansteuern und auf Herz und Nieren (in der Cloud) testen.

Wie beginne ich?

Am besten mit einem Docker Container. Das hat den Vorteil, dass keine Software  – ausser allenfalls dem Docker-Dienst oder einer virtuellen Linux-Maschine – installiert werden muss.

Das ganze kann auch komplett im Browser ablaufen.

Die Details dazu finden Sie hier. Viel Spass!