Steuern, Messen, Regeln mit dem PC. Ein praktischer Workshop

Inhaltsverzeichnis

1 Einführung
1.1 Die verwendete Hardware
1.1.1 Platine "Testaufbau V3SD"
1.2 Grundsätzliches zum Programmieren und zu VisualBasic
1.2.1 Das .NET-Framework
1.2.2 Installation
1.3 Die Entwicklungsumgebung
1.3.1 Projekte anlegen, speichern und öffnen
1.3.2 Programmcode eingeben
1.3.2.1 Regeln zur Syntax
1.3.3 Hello World! und MessageBox
1.3.4 Kommentare einfügen
1.3.5 Objektorientierte Programmierung
1.3.6 Debugging
1.3.6.1 Das Immediate Window
1.3.6.2 Die Error-Liste
1.3.7 Option Explicit und Option Strict

2 Ein- und Ausschalten von LED oder Lampen
2.1 Ressourcen einbinden
2.2 Die Programmoberfläche
2.3 Programmcode zur Ansteuerung des USB-Prozessors
2.3.1 Variablen und Datentypen
2.3.2 Chip anmelden und abmelden
2.3.2.1 Programm beenden
2.3.3 Digitale Ausgänge und Arrays
2.3.4 Gültigkeitsbereiche
2.4 Abschaltautomat, Blinker und Summer
2.4.1 Timing aus dem .NET-Framework
2.4.2 Die Do-Loop-Schleife
2.4.3 Bedingtes Ausführen von Codeabschnitten
2.4.3.1 Die IF-Anweisung
2.4.3.2 Sicherheitsabfragen
2.4.4 Timer mit Interrupt/Event
2.4.4.1 Verwendung des Timer-Control-Objektes
2.5 Externe Verbraucher schalten
2.5.1 Der Transistor als Schalter
2.5.1.1 Summer
2.5.2 Bitmanipulationen
2.5.2.1 Funktionen
2.5.2.2 Bit auf 1 setzen
2.5.2.3 Bit auf 0 setzen
2.5.2.4 Bit toggeln (umkehren)
2.5.2.5 Bits verschieben
2.5.2.6 Bitmanipulationsroutinen im Modul
2.5.3 Schalten von 230-V-Netz-Verbrauchern
2.5.3.1 Schalten mit Relais
2.5.3.2 Schalten per Funk
2.5.4 Zeitschaltuhr

3 Intermezzo: Projekt anlegen, Zusammenfassung

4 Steuern eines Motors
4.1 Emitterfolger
4.2 Digital-Analog-Umsetzer (DAU)
4.2.1 Parallele Wertvorgabe
4.2.2 Datenübergabe mit externem DAU
4.2.2.1 UShort zerlegen in High-Byte und Low-Byte
4.3 Serielle Busse
4.3.1 Der SPI-Bus
4.3.2 Der PC-Bus
4.4 Programmierung
4.4.1 Programmoberfläche und Entgegennahme des Eingabewertes
4.4.1.1 Casting
4.4.2 Konfiguration des DAU
4.4.3 Daten senden via SPI

5 Erfassen von Schalterzuständen und analogen Werten
5.1 Erfassen der Zustände von I/O-Ports
5.1.1 Portzustände lesen im Standardmodus
5.1.2 Portzustände lesen im Spezialmodus
5.1.3 Schalterabfrage
5.1.1.1 Code "Bit abfragen"
5.2 Analogwerte erfassen mit serieller Datenübertragung
5.2.1 Analog-Digital-Wandlung
5.2.1.1 Temperaturmessung

6 Regelung
6.1 Analoge Regelung
6.1.1 Linear-Netzteil
6.1.2 Unterschiedliche Stellglieder
6.2 Regelung in der Software

7 SD-Karte

8 Anhang
8.1 Windows Specials
8.1.1 Zwischenablage nutzen
8.1.2 Beenden von laufenden Prozessen
8.1.3 Ein Programm mit Administratorrechten versehen
8.2 Ergänzungen zu Funktionen
8.3 Ergänzungen zur Steuern des Programmablaufs
8.3.1 Fallunterscheidungen
8.3.2 Schleife mit fest vorgegebener Zahl der Durchläufe
8.3.3 Vorzeitiger Abbruch einer Schleife, Prozedur oder Funktion
8.3.4 Sprünge
8.3.5 Fehlerbehandlung während der Laufzeit
8.3.5.1 Laufzeitfehler während der Programmentwicklung
8.3.5.2 Laufzeitfehler während der Programmnutzung
8.4 Ergänzungen zum USB-Prozessor "IO-Warrior56"
8.5 Mikrocontroller-Programm

Literatur

1 Einführung

Szenario: Auf einem PC erscheint eine Oberfläche mit Buttons, die man anklicken kann oder mit Feldern in denen man einen Wert eintragen kann. Der Computer ist mit einem Interface verbunden an dem verschiedene elektrische Verbraucher angeschlossen sind. Klickt man auf einen Button wird ein Verbraucher z.B. ein- oder ausgeschaltet.

Damit ist schon klar welche Ausrüstung benötigt wird:

- ein Standard-PC
- ein Programm mit dem man Oberflächen erzeugen (programmieren) kann
- eine Interface-Elektronik (Karte) die über eine PC-Schnittstelle (USB) mit dem PC verbunden ist
- Geräte (Verbraucher) die gesteuert werden

An Hilfsmitteln sollte ein Multimeter (Spannungsmesser) zur Verfügung stehen. Standard-PCs mit USB-Schnittstelle (USB = Universal Serial Bus; Details dazu siehe² ) sind allgegenwärtig.

Für das Programmieren wird im Rahmen dieses Buches VisualBasic eingesetzt. Diese weit verbreitete Programmiersprache bietet die Vorteile der schnellen Erlernbarkeit und der leichten Lesbarkeit des erzeugten Codes.

Das Ein- und Ausschalten von Verbrauchern oder auch das kontinuierliche Ansteuern von Verbrauchern, zählt zunächst zum Steuern mit Hilfe des Computers. Sollen die Ausgaben des Computers sich in Abhängigkeit von externen Größen ändern, dann spricht man vom Regeln (Bild 1.1).

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.1: Ein Regelkreis mit PC als Regler (Quelle:² ).

Zugriffe vom PC auf eine Hardware werden heute fast ausschließlich über die USB-Schnittstelle realisiert.

Zwischenzeitlich gibt es verschiedene Bausteine, die bereits die Verwaltung des USB-Protokolls übernehmen und somit als Vermittler zwischen PC und Hardware fungieren. Dadurch hat sich die Anbindung von Hardware erheblich vereinfacht.

Die USB-Schnittstelle liefert gleichzeitig eine Spannung von 5V, die bis 100 mA belastbar ist (im Hochstrommodus sogar mit bis zu 500 mA). Diese kann als Versorgungsspannung für angeschlossene Elektronik dienen.

In diesem Buch geht es um hardwarenahe Programmierung. Das bedeutet, dass unmittelbar mit der Ausführung eines Befehls im Programm eine Aktion in der angeschlossenen Hardware ausgelöst wird.

Vorliegend wird der Hardware-Zugriff über den Baustein IO-Warrior56 (deutsch: "IO-Krieger56") der deutschen Firma "Code Mercenaries" (deutsch: "Code-Söldner") gezeigt. Der USB-Chip (Cyrix-Prozessor auf dem IO-Warrior56-Modul) erfaßt die Signale per USB und vermittelt zwischen der Außenwelt. Er kann Steuersignale ausgeben, Daten an den PC übergeben oder vom PC empfangen und weiterleiten.

Den IO-Warrior56 gibt es als einzelnes Chip im winzigen SMD-Gehäuse und als Modul. Beim Modul handelt es sich um eine Platine mit den Abmessungen 33 x 26 mm, auf der der Chip aufgelötet ist. Das Modul passt in normale Steckleisten mit 2,54-mm-Raster. Es lässt sich also auch per Handarbeit gut verarbeiten. Bild 1.2 zeigt die Unterseite des Moduls. Es ist zu erkennen, dass neben dem Chip selbst noch zwei SMD-Widerstände und zwei SMD-Kondensatoren auf der Platine verbaut sind. Die beiden SMD-Widerstände haben einen Wert von 24 Ω und liegen in Reihe zu den USB-Datenleitungen D+ und D- (weitere Informationen zur USB-Schnittstelle findet man auch in ² ). Im Bild 1.3 sieht man das Modul auf einer Experimentierplatine. Im Bild 1.4 ist die Anschaltung des Chips an die USB-Schnittstelle dargestellt. Wie bereits erläutert sind die beiden Widerstände und die beiden Kondensatoren bereits auf dem Modul enthalten.

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.2: Die Unterseite des IO-Warrior56- Moduls.

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.3: Das IO-Warrior56-Modul auf der Experimentierplatine „Testaufbau V1“. An der rechten Seite ist der USB-Anschluss (USB-BBuchse) zu erkennen.

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.4: Anschluss des IO-Warrior56 an die USB-Schnittstelle.

Der IO-Warrior56 verfügt über insgesamt 56 Anschlüsse. Vier davon gehören zum USB-Anschluss (+5V, Masse, +Data und -Data). Es werden die Betriebsarten "Normal” und "Special” unterschieden.

1.1 Die verwendete Hardware

1.1.1 Platine "Testaufbau V3SD"

Die Interface-Karte ist, wie gesagt, für den Betrieb mit USB-Bus ausgelegt. Man kann mit ihr Spannungen und Ströme erfassen oder vorgeben oder Schaltvorgänge auslösen. Die hier verwendete Interface-Karte ist im Bild 1.5 zu sehen. Das zugehörige Schaltbild findet man in Bild 1.6. Das Bild 1.7 zeigt das Platinenlayout. Es ist nicht erforderlich bereits jetzt alle Zusammenhänge zu verstehen oder das Schaltbild vollständig lesen zu können. Alle notwendigen Details werden erklärt, wenn sie konkret für ein Projekt benötigt werden.

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.5: PC-Interface-Karte „ Testaufbau V3 “ mit USB-Anbindung (Oberseite).

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.6: Schaltbild der PC-Interface-Karte mit USB-Anbindung „ Testaufbau V3SD“.

Abbildung in dieser Leseprobe nicht enthalten

Bild 1.7: Platinenlayout der Oberseite (blau) und der Unterseite (rot).

1.2 Grundsätzliches zum Programmieren und zu VisualBasic

Stark vereinfacht ist Programmieren nichts anderes als das Aufschreiben einer Folge von Befehlen, die der Computer abarbeiten muss. Ziel ist es, in Abhängigkeit von bestimmten Eingangsinformationen ein bestimmtes Resultat - eine Ausgabeinformation - zu erhalten. Da der Computer aus Elektronikbausteinen (Hardware) besteht, geht es im Grund darum, mit dem Programm diese Hardware zu steuern. Der Computerkern, die CPU (Central Processing Unit) kann einfachste mathematische Berechnungen vornehmen oder Daten zwischen verschiedenen Teilen der Hardware verschieben. Alleine für sich ist die CPU aber nicht einmal in der Lage, eine Datei von einer Festplatte zu lesen. Es gibt zahlreiche elementare Aufgaben wie das Interagieren mit Massenspeicher, Arbeitsspeicher, Tastatur und Monitor, die die CPU bei jedem Programm erfüllen muss. Würde man ein Programm schreiben, dass alle diese elementaren Aufgaben berücksichtigt, dann würde es die meiste Zeit nur mit diesen Dingen verbringen und nur ein winziger Teil der Zeit verbliebe für den tatsächlichen Zweck des Programms. Das gilt für die Programmausführung, aber auch für die Zeit die für die Erstellung des Programms - also die Programmierung aufgewendet werden muss.

Aus dieser Notlage heraus sind die Betriebssysteme entstanden. Sie bieten allgemeine Funktionalität, die unmittelbar auf die Computerhardware aufsetzt. Die Betriebssysteme sind selbst Computerprogramme, die die ganzen Einzelheiten der Speicherverwaltung, Massenspeichereingabe/-ausgabe und andere Aufgaben der unteren Ebene handhaben. Dadurch müssen andere Programme sich nicht mehr um die Details der unteren Ebene kümmern. Soll z.B. eine Datei geöffnet werden, dann kann ein Programm das Betriebssystem beauftragen, diese Funktion durchzuführen. Um Details beim Hardwarezugriff muss man sich als Programmierer also nicht kümmern.

Um auf die ganze Funktionalität zuzugreifen, die das Betriebssystem bietet, verwendet man das sogenannte Application Programming Interface (API). Die API repräsentiert die gesamte exponierte Betriebssystemfunktionalität, die man in selbst geschriebenen Programmen verwenden kann. Damit wird der Programmierer, der mit einer sogenannten "höheren" Programmiersprache programmiert, stark entlastet. Er muss sich nicht um die generischen Operationen des Computers kümmern; er kann sich auf den eigentlichen Zweck seines Programmes konzentrieren.

Konkret bedeutet das für den VisualBasic Programmierer, dass er in der Lage ist, Computerprogramme zu schreiben um bestimmte Aufgaben zu erledigen, ohne etwas darüber wissen zu müssen, wie Windows Bilder auf dem Monitor zeichnet, Dateien speichert oder auf dem Drucker etwas ausdruckt.

Der Begriff "höhere Sprache" ist noch zu klären. Nur mit der Maschinensprache (bzw. mit Assembler) kann man unmittelbar dem Prozessor Anweisungen geben. Diese Sprache kann die CPU ohne weitere Hilfe verstehen. Deshalb nennt man diese Sprachen "maschinennahe Sprachen". Die Programmierung mit dieser Sprache ist aber sehr umständlich und aufwändig, weil die Anweisungen in Form von Zahlen angegeben werden. Der Computer versteht zwar ohne Umwege was gemeint ist, aber es ist schwierig, sich richtig auszudrücken. Ihr Einsatz ist deshalb nur in Ausnahmefällen sinnvoll. Zum Beispiel bei der Programmierung eines Mikrocontrollers.

Bei den höheren Programmiersprachen handelt es sich um Sprachen, die es erlauben, mit logisch durchschaubaren, lesbaren Befehlen schreiben zu können. Diese Sprachen nutzen eben die Funktionen des Betriebssystems. Code, den man in einer höheren Sprache geschrieben hat, muss erst in Maschinensprache übersetzt werden. Diesen Vorgang nennt man "Kompilieren". Die Programme, die diese Übersetzung vornehmen, heißen Compiler. Ursprünglich bestanden die höheren Programmiersprachen nur aus dem Compiler. Man schrieb den Code mit einem Editor, kompilierte ihn und testete das Programm.

Später kamen sogenannte Interpreter hinzu. Dabei handelt es sich um einen speziellen Texteditor, der in der Lage ist, den Befehlscode der Hochsprache sukzessive zu kompilieren und ausführen zu lassen. Man kann damit ein Programm aus dem Editor heraus testen. Diesen Vorgang, die befehlsweise Ausführung des Codes, nennt man Parsen. Wenn das Programm im Interpreter funktioniert, kommt der nächste Schritt und der Code wird zu einer ausführbaren Datei kompiliert (es entsteht eine Datei mit der Erweiterung ".exe").

Im Zuge der Verbesserung der Programmiersprachen wurde die integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) eingeführt. Der Sinn einer IDE ist es, die Arbeitsschritte des Bearbeitens, der Fehlerbehebung und des Kompilierens in der Softwareentwicklung in einer einzelnen Schnittstelle für den Programmierer zusammenzufassen. Eine IDE beinhaltet deshalb einen Interpreter mit Programmeditor, einen Compiler und andere Funktionen die dem Programmierer helfen. Dabei kann eine IDE verschiedene höhere Sprachen unterstützen.

Der nächste Schritt in der Entwicklung der Programmiersprachen war die Erschaffung der "visuellen Sprachen". Diese Sprachen werden visuell genannt, weil die Programmierung von einer selbst erstellten grafischen Oberfläche ausgeht. Eine solche Sprache bietet die Fähigkeit, Schaltflächen, Text und andere Elemente auf einem Bildschirm zu platzieren, um eine Benutzeroberfläche (GUI, Graphical User Interface) zu erzeugen.

[...]