Leitfaden V1 2 - Technische Hochschule OWL · Beschreibung: SIMATIC NCM PC Manager starten und ein...

Siemens ERTEC 200 Development Kit

Leitfaden Autor: Dipl.-Ing. (FH) Christoph Rotter Datum: 17.01.2008 Revision: 1.2

Institut Industrial IT (inIT); Leitfaden: Siemens ERTEC 200 DevKit 2

Inhaltverzeichnis 1 Einleitung....................................................................................................................................... 3 2 Revisionshistorie.......................................................................................................................... 4 3 Erläuterungen zum Leitfaden ...................................................................................................... 5 4 Lieferumfang und benötigte Hard-/Software ............................................................................. 6 5 Übersicht ....................................................................................................................................... 7 6 Hardware einrichten ..................................................................................................................... 8

6.1 CP1616 einbauen.....................................................................................................8 6.2 EB200 in Betrieb nehmen.........................................................................................8 6.3 Verbindungen einrichten...........................................................................................9

7 PROFINET IO-Controller ............................................................................................................ 11 7.1 Linux-Systemvoraussetzung ..................................................................................11 7.2 Hardware-Voraussetzungen...................................................................................11 7.3 Linux-Grundkenntnisse für die Kommandozeile .....................................................12 7.4 Linux vorbereiten ....................................................................................................13 7.5 Linux Leitfaden .......................................................................................................14

8 PROFINET IO-Device .................................................................................................................. 23 8.1 Tornado 2.2 installieren ..........................................................................................23 8.2 Tornado 2.2 vorbereiten .........................................................................................26 8.3 Tornado 2.2 starten und Beispiel-Applikation generieren.......................................27 8.4 Tornado 2.2 – FTP-Server einstellen .....................................................................28 8.5 Tornado 2.2 – optional: Target-Server einstellen ...................................................30 8.6 Terminal einstellen und Bootparameter des EB200 ändern...................................33

9 Automatisierungssystem projektieren ..................................................................................... 36 9.1 NCM 5.4 installieren ...............................................................................................36 9.2 NCM 5.4 vorbereiten ..............................................................................................36 9.3 NCM 5.4 starten und Projekt konfigurieren.............................................................37

10 System in Betrieb nehmen......................................................................................................... 42 10.1 Checkliste ...............................................................................................................42 10.2 Device-Applikation..................................................................................................42 10.3 Controller-Applikation .............................................................................................43

11 Eigene Applikation erstellen...................................................................................................... 44 11.1 IO-Modul erstellen ..................................................................................................45 11.2 GSD-Datei für das EB200 erstellen........................................................................47 11.3 NCM-Projektierung erstellen...................................................................................55 11.4 Device Applikation erstellen ...................................................................................59 11.5 Controller Applikation erstellen...............................................................................70 11.6 Der Betrieb .............................................................................................................74


1 Einleitung Zum Kennen lernen eines Bussystems oder zur Entwicklung der Software von Feldgeräten hat sich die Benutzung von Evaluierungsboards bewährt. Für den Industrial Ethernet Standard PROFINET hat die Firma Siemens nun für den ERTEC200 ein Entwicklungspaket bereitgestellt. Auf Basis des Siemens ERTEC200 Development Kit (kurz DevKit) wurde im Institut Industrial IT1 der Fachhochschule Lippe und Höxter (www.init-owl.de) ein einfaches digitales IO-Device realisiert. Das Ergebnis ist dieser Leitfaden für Entwickler, durch den es möglich wird, innerhalb eines Tages ein eigenes PROFINET IO-Device zu entwickeln. Im folgenden Leitfaden wird zunächst das gesamte System installiert, wie es im DevKit geliefert wird. Das heißt, es wird ein Beispielprojekt mit PROFINET IRT-Kommunikation mit einem PROFINET IO-Controller und einem PROFINET IO-Device erstellt. Danach wird die Entwicklung eines eigenen PROFINET IO-Devices gezeigt sowie dessen Eingliederung in ein Automatisierungssystem. Sollten Ihnen Fehler auffallen oder Sie Probleme mit dem Leitfaden haben so senden Sie diese bitte an: [email protected] Die neueste Version von diesem Leitfaden ist verfügbar unter: www.init-owl.de/EB200-Leitfaden

1InIT (Institut Industrial IT): Wesentliche Innovationen im Maschinen- und Anlagenbau gehen von Informationstechnologien (IT) und der Automatisierungstechnik aus. Für dieses interdisziplinäre Wissensgebiet wurde Anfang 2007 das Forschungsinstitut Industrial IT der Fachhochschule Lippe und Höxter gegründet. Link: www.init-owl.de Link: www.fh-luh.de/fb5/


2 Revisionshistorie Revision Datum Beschreibung Autor 1.1 08.08.2007 Aktualisierung der Links Christoph Rotter

1.2 17.01.2008 Aktualisierung zu Suse Linux Distribution 9.2 (siehe Kapitel 7.1)

Christoph Rotter


3 Erläuterungen zum Leitfaden Im vorliegenden Leitfaden wird der nötige Ablauf Schritt für Schritt erläutert. Die Schritte sind wie folgt aufgebaut: Beispiel 1: Punkt 3: Linux Kernel konfigurieren und generieren (Kommandozeile) Schritt 1

Befehl 1: su Befehl 2: cd /home/user/cp1616

Beschreibung: Wechseln Sie zum Benutzer root mit dem Switch-User-Kommando. Root bedeutet, dass Sie Administratorrechte benötigen.

• Befehle sind Wort für Wort in eine Kommandozeile zu übertragen. Wird in der Kommandozeile gearbeitet, so wurde dies zuvor zum Beispiel in der Überschrift erwähnt und beschrieben wo und wie diese aufzurufen ist.

• Eine kurze Beschreibung erläutert die Befehle oder den Ablauf der in diesem Schritt vorgenommen wurden.

Beispiel 2: Schritt 2

Ablauf 1: SIMATIC NCM PC Manager starten Ablauf 2: NCM Manager Menüleiste: Datei->Neu Ablauf 3: Neues Projekt: Name: myRTsystem Ablauf 4: Neues Projekt: mit OK bestätigen

Beschreibung: SIMATIC NCM PC Manager starten und ein neues Projekt erstellen. Das Projekt zum Beispiel „myRTsystem“ nennen

• Ein Ablauf beschreibt die nötigen Schritte (Datei->Neu), markante Punkte werden Fett dargestellt. Kursiv dargestellter Text beschreibt den Ort an dem man sich befindet, zum Beispiel die Menüleiste oder das geöffnete Fenster.

• In manchen Fällen wird zusätzlich eine Abbildung zur Verdeutlichung des Ablaufs gezeigt. Die einzelnen Schritte werden in Abbildungen mit Kreisen und Pfeilen gekennzeichnet.

Beispiel 2: Schritt 3

Ablauf: Tornado 2.2 starten Ablauf: Tornado Menüleiste: Tools -> Target Server -> Configure

Beschreibung: Einen Target Server erstellen bzw. konfigurieren.


4 Lieferumfang und benötigte Hard-/Software Hardware:

• Evaluationboard EB200 (PROFINET IO-Device) mit Steckernetzteil • Kommunikationsprozessor CP1616 (PROFINET IO-Controller) • Ein Ethernetkabel • 10 ERTEC200 ASICs

Software:

• Software und Applikationsbeispiel des PROFINET IO-Protokollstack (CD: DK-ERTEC 200 PN IO V2.0)

• Projektierungssoftware SIMATIC NCM 5.4 (CD: SIMATIC NET CP1616-CP1604) • Tornado 2.2 Entwicklungsumgebung für das Echzeitbetriebssystem VxWorks (CD: Tornado

2.2.1/VxWorks 5.5.1) • Board Support Package (BSP) für das EB200 (CD: DK-ERTEC 200 PN IO V2.0) • GSD-Datei zur Integration des EB200 in SIMATIC NCM/Step7 HWCONFIG (CD: DK-ERTEC

200 PN IO V2.0) • Dokumentation zum Development-Kit (CD: Development Kit DK-16xx PN IO V2.0)

Nähere Beschreibungen zu den Komponenten die nicht im Lieferumfang enthalten sind, werden später näher beleuchtet. Nicht im Lieferumfang enthaltene Komponenten:

• Linux-PC (für die Einrichtung eines PROFINET IO-Controllers mit der CP1616) • Ethernetkabel zur Vernetzung des Systems • Serielles Kabel • XML-Editor (für die Erstellung einer GSD-Datei) • Bauteile zur Erstellung eines IO-Moduls (in diesem Leitfaden wird ein IO-Knoten mit LEDs und

Tastern realisiert, siehe Kapitel 11.1) • Ethernet Tap und Ethernet-Protokoll-Analysator (Zur Analyse des Ethernet-Verkehrs)


5 Übersicht Die folgende Abbildung vermittelt einen Überblick der Aufgaben dieses Leitfadens:


6 Hardware einrichten

6.1 CP1616 einbauen Der Kommunikationsprozessor CP1616 wird in einen Linux-PC eingebaut, welcher hierzu über einen freien PCI-Steckplatz verfügen muss. Optional: Der CP1616 besitzt eine Buchse zur Einspeisung einer externen Versorgungsspannung. Mit dieser Versorgungsspannung kann der integrierte Real-Time-Switch auch dann arbeiten, wenn der PC abgeschaltet ist.

6.2 EB200 in Betrieb nehmen Um das EB200 in Betrieb zu nehmen müssen zunächst die Jumpereinstellungen überprüft und das Steckernetzteil richtig eingestellt werden. Gehen Sie wie folgt vor: Schritt 1

Ablauf: Jumpereinstellungen überprüfen Beschreibung: Jumpereinstellungen X10 und X11 am EB200 überprüfen (sollten mit dem

Auslieferungszustand übereinstimmen):

serie

lle

Schn

ittst

elle

Deb

ug-

Sch

ittst

elle

Res

et-T

aste

r

Schritt 2

Ablauf 1: Spannungsschalter des Steckernetzteils auf 6 Volt einstellen Ablauf 2: Umpolkupplung + mit + verbinden (Hohlstecker: + innen) Beschreibung: Einstellungen für den Betrieb mit dem Steckernetzteil, welches dem DevKit

beiliegt, vornehmen. Bei korrektem Anschluss leuchten die LEDs an der Rückseite kurz auf.


6.3 Verbindungen einrichten Die IP-Adressen, welche hier für die einzelnen Geräte angegeben werden, gelten für den gesamten Leitfaden. Die Vergabe der IP-Adressen wird im späteren verlauf des Leitfadens vorgenommen. Bitte bauen Sie das System wie folgt auf:

Nr. IP-Adresse* Beschreibung 1.1 192.168.20.101 Port 1 an der CP1616 1.2 192.168.20.101 Port 2 bis 3 an der CP1616 2.1 192.168.20.102 Port 1 auf der Backplane des EB200 2.2 192.168.10.2 Debug-Schnittstelle des EB200 2.3 keine Serielle Schnittstelle 3.1 192.168.x.x PC mit Tornado 2.2 (mit FTP- und Target-Server) 3.2 192.168.10.1 PC mit NCM 5.4

3.3 keine COM-Schnittstelle des PCs (Baudrate: 115200, Datenbits: 8, Parität: keine, Stoppbit: 1)

*Standardsubnetzmaske verwenden: 255.255.255.0 Verbindungen: EB200 <-> CP1616 Bei der IRT-Kommunikation (welche in diesem Leitfaden zuerst eingerichtet wird) muss der Port 1des EB200 direkt mit dem Port 1 des CP1616 verbunden sein. Eine Analyse des IRT-Ethernet-Verkehrs ist nur über einen Ethernet-Tap möglich, damit die Verbindung nicht gestört wird!


CP1616 <-> PC Lediglich Während des Projektierens des Automatisierungssystems muss der PC (mit NCM 5.4) mit der CP1616 verbunden sein. Bei direkter Verbindung muss dies über ein gekreuztes Ethernet-Kabel geschehen.

Steckerbelegung RJ45 gekreuzt Pin 1 (RX+, weiss/grün) <-> Pin 3 (TX+, weiss/orange) Pin 2 (RX-, grün) <-> Pin 6 (TX-, orange) Pin 3 (TX+, weiss/orange) <-> Pin 1 (RX+, weiss/grün) Pin 6 (TX-, orange) <-> Pin 2 (RX-, grün)

EB200 <-> PC

• Das EB200 lädt den Programmcode über seine Debug-Schnittstelle. Wird diese direkt mit der Netzwerkkarte des PCs verbunden, so muss hier ein gekreuztes Ethernet-Kabel genutzt werden.

• Die serielle Verbindung wird mit einem Nullmodemkabel (TIA574 Stecker/Buchse, Pins 2 und 3 gekreuzt) hergestellt.

Optional: Ethernet Diagnose Oftmals ist die Analyse des Ethernet-Verkehrs sehr hilfreich, um zum Beispiel herauszufinden, welches Gerät nicht wie gewünscht funktioniert. Den Anfang in diesem Leitfaden macht ein Automatisierungssystem mit PROFINET IRT-Kommunikation. Zur Diagnose des IRT-Datenverkehrs darf lediglich ein Ethernet Tap genutzt werden, da somit die Kommunikation in keiner Weise gestört wird. Um den Verkehr aufzunehmen wird ein Netzwerkprotokollanalysator, wie zum Beispiel das frei nutzbare Wireshark (www.wireshark.org) benötigt.


7 PROFINET IO-Controller

7.1 Linux-Systemvoraussetzung In diesem Leitfaden wird die Suse Linux Distribution 9.2 mit der Kernelversion 2.6.10 (oder kleiner, jedoch nicht höher!) benötigt. Diese Distribution ist im Internet frei erhältlich, zum Beispiel als brennbares DVD-ISO unter diesem Link herunter zu laden: Aktualisierung vom 17.01.2008: Leider konnten keine aktuellen Links gefunden werden.

7.2 Hardware-Voraussetzungen Im Allgemeinen gilt, je schneller der PC, desto schneller geht das Kompilieren des Kernels. Das hier aufgesetzte System verfügte über einen 900MHz AMD Duron Prozessor und 128MB RAM. Das Kompilieren dauerte mit diesem System circa 2 Stunden. Der Leitfaden legt ein System mit Einzelprozessor und ohne Hyperthreading zugrunde. Interrupts Bei IRT-Betrieb muss ein ungeteilter Interrupt vorhanden sein. Ist keiner vorhanden, so kann im Bios ein ungenutztes Gerät, wie zum Beispiel ein Onboard-Soundchip deaktiviert werden.


7.3 Linux-Grundkenntnisse für die Kommandozeile Im Folgenden werden lediglich einige der wichtigsten Begriffe für die Benutzung der Linux-Kommandozeile erläutert:

STRG+ALT+F1 bis F7 Neben der grafischen, standardmäßig geladenen Oberfläche verfügt Linux über sechs Kommandozeilen. Sie gelangen auf die Kommandozeilen direkt mit:

STRG+ALT+F1 bis F6

Mit STRG+ALT+F7 kommen Sie wieder zurück auf die grafische Oberfläche.

init 3 Grafische Oberfläche wird deaktiviert

su Switch User, um in den Administratormodus zu wechseln:

cp [Quelle][Ziel] Eine Datei kopieren

cd [Ziel] Change directory, in einen anderen Ordner wechseln.

dir Alle Dateien im aktuellen Ordner anzeigen lassen

[Datei].tar Archive mit der Endung .tar sind reine Zusammenfassungen von Dateien. Es wird die Verzeichnisstruktur gespeichert, der Inhalt aber nicht komprimiert.

tar [Ziel] Dateien mit der Endung .tar entpacken.

[Datei].gz

Eine Datei mit der Endung "gz" steht für eine mit gzip komprimierte Datei. Es kann nur eine einzige Datei komprimiert werden.

[Datei].bz2 Die Handhabung einer Datei mit der Endung "bz2" verhält sich ähnlich wie bei einer "gz"-Endung. Der Vorteil von "bz2" sind die bedeutend kleineren Dateien.

bunzip2 [Ziel] Dateien mit der Endung .bz2 entpacken.

[Befehl] --help Mit dieser Option werden alle Informationen zu einem Befehl angezeigt, falls solche vorhanden sind.

tabulator-taste („tab“) In der Kommandozeile einen angefangenen Befehl oder Pfad versuchen zu vervollständigen.

make Führt Kommandos in Abhängigkeit von Bedingungen aus, um zum Beispiel in einem Projekt, das aus vielen verschiedenen Dateien mit Quellcode besteht, automatisiert alle Arbeitsschritte (Übersetzung, Linken, Dateien kopieren etc.) zu steuern


7.4 Linux vorbereiten Im Folgenden werden die ersten Schritte nach der Installation von Linux gezeigt. Standardmäßig sind nicht alle, für die folgenden Punkte benötigten Compiler installiert, daher gehen Sie bitte wie nachstehend vor: Schritt 1

Ablauf: Suse Linux 9.2 installieren

Beschreibung: Bitte die Suse Linux Distribution 9.2 gemäß dem Installationsassistenten (Standardinstallation) installieren (Dauer: ca. 1-2 Stunden).

Tipp: Während Linux installiert wird, könnten Sie bereits mit dem Kapitel 8 „PROFINET IO-Device“ beginnen.

Schritt 2

Ablauf: Startmenü -> System: Yast -> Software -> Software Installieren und Löschen

Beschreibung: Das Linux-Konfigurationswerkzeug Yast (siehe Abbildung) öffnen und ggf. Installations CDs/DVD bereithalten

Schritt 3

Ablauf: Suche nach gcc -> alles markieren und installieren (übernehmen)

Beschreibung: GNU-Compiler Collection vollständig installieren.

Schritt 4

Ablauf: Suche nach ncurses -> alles markieren und installieren (siehe Schritt 3)

Beschreibung: Bei ncurses handelt es sich um eine C-Programmbibliothek welche installiert werden muss.


7.5 Linux Leitfaden Nachdem das Linux vorbereitet wurde, kann nun mit der eigentlichen Installation des CP1616 begonnen werden. Folgende Punkte werden hier bearbeitet: Punkt 1: Dateien herunterladen................................................................................................... 14 Punkt 2: Dateien entpacken (Kommandozeile).......................................................................... 15 Punkt 3: Linux Kernel konfigurieren und generieren (Kommandozeile)................................. 16 Punkt 4: Linux Kernel installieren (Kommandozeile)................................................................ 17 Punkt 5: Echtzeiterweiterung RTAI konfigurieren und generieren (Kommandozeile)........... 19 Punkt 6: Prüfen, ob die Echtzeiterweiterung funktioniert (Kommandozeile) ......................... 20 Punkt 7: CP1616-Treiber installieren (Kommandozeile) ........................................................... 21 Punkt 8: CP1616-Controller Beispielprogramm starten (Kommandozeile) ............................ 22 Punkt 1: Dateien herunterladen Laden Sie folgende Dateien an eine beliebige Stelle (z.B.: Lokale Festplatte -> /home/user/cp1616) auf dem Linux-PC. Sie können diese Dateien auch komplett unter www.init-owl.de/EB200-Leitfaden herunterladen:

• linux-2.6.10.tar.bz2 (http://www.kernel.org/pub/linux/kernel/v2.6/), Linux-Kernel-Quellcode

• adeos-linux-2.6.10-i386-r12.patch (http://download.gna.org/adeos/patches/attic/v2.6/i386/), Kernel Patch ADEOS für die Echtzeiterweiterung

• rtai-3.2.tar.bz2 (http://download.gna.org/rtai/stable/v3/), RTAI-Echtzeiterweiterung-Quellcode

• host-2.0.0.49.6.tar.gz von der CD „Development Kit DK-16xx PN IO V2.0“, Linux-Treiber für

den CP1616

• Ordner CP1616_Controller_Application von der CD „DK-ERTEC 200 PN IO“, Beispielapplikation für den CP1616

Für den Überblick

• ADEOS (Adaptive Domain Environment for Operating Systems) arbeitet zwischen Betriebssystem und der Hardware. Es unterstützt einen flexiblen Zugriff auf Hardware-Ressourcen von verschiedenen Tasks eines Betriebssystems. Link: www.adeos.org

• RTAI (Real Time Application Interface) ist eine

Echtzeiterweiterung für Linux, welche einen Echtzeit-Kernel zwischen die Hardware und dem Linux-Kernel einfügt. Dieser übernimmt die Interrupt-Verwaltung des Prozessors. Das heißt, dass Software auf der Kernel-Ebene keine Interrupts mehr blockieren oder freigeben kann. Der Linux-Kernel selbst ist ebenfalls ein Echtzeit-Task, jedoch besitzt er die niedrigste Priorität. Link: www.rtai.org

Hardware

Kern

elU

ser

Echtzeit-Kernel (ADEOS)

Echtzeit-Task

Echtzeit-Task

LinuxProzesse Applikation

RTAI

Linux-Kernel

Hardware Interrupts

Scheduling

Scheduling


Punkt 2: Dateien entpacken (Kommandozeile) Nach dem Herunterladen aus dem Internet liegen die Dateien in gepackter Form vor. Gehen Sie wie folgt beschrieben vor, um die Dateien zu entpacken und an den Bestimmungsort zu kopieren. Schritt 1

Tastenkombination: STRG+ATL+F1

Beschreibung: In eine Kommandozeile wechseln, zum Beispiel, wie hier in die Kommandozeile 1. Danach mit Benutzernamen einloggen.

Schritt 2


Beschreibung: Wechseln Sie zum Benutzer root mit dem Switch-User-Kommando. Root bedeutet, dass Sie Administratorrechte benötigen. Danach wechseln Sie in den Ordner an dem sie die Dateien in Punkt 1 abgelegt haben (als Beispiel hier: /home/user/cp1616)

Schritt 3

Befehl 1: cp linux-2.6.10.tar.bz2 /usr/src Befehl 2: cp adeos-linux-2.6.10-i386-r12.patch /usr/src Befehl 3: cp rtai-3.2.tar.bz2 /usr/src Befehl 4: cd /usr/src

Beschreibung: Dateien nach /usr/src kopieren und dann in dieses Verzeichnis wechseln. Schritt 4

Befehl 1: bunzip2 linux-2.6.10.tar.bz2 Befehl 2: tar -xf linux-2.6.10.tar

Beschreibung: Entpacken Sie den Linux-Kernel-Quellcode. Schritt 5

Befehl 1: bunzip2 rtai-3.2.tar.bz2 Befehl 2: tar -xf rtai-3.2.tar

Beschreibung: Entpacken Sie den RTAI-Echtzeiterweiterung-Quellcode.


Punkt 3: Linux Kernel konfigurieren und generieren (Kommandozeile) Nachfolgend wird das Konfigurieren und Generieren bei einem Einzelprozessorsystem ohne Hyperthreading beschrieben. Schritt 1

Befehl 1: su Befehl 2: cd /usr/src/linux-2.6.10

Beschreibung: Falls nicht schon erfolgt, mit dem Switch-User-Kommando User wechseln um Administratorrechte zu bekommen. Wechseln Sie in das Verzeichnis /usr/src/linux-2.6.10

Schritt 2

Befehl: patch -p1 -i ../adeos-linux-2.6.10-i386-r12.patch

Beschreibung: Fügen Sie den Adeos-Patch in den Linux-Quellcode ein. Schritt 3

Befehl 1: cat /proc/config.gz | gunzip > .config Befehl 2: make oldconfig

Beschreibung: Übernehmen Sie die Kernel-Konfiguration vom laufenden Kernel. Akzeptieren Sie hierzu alle Vorgaben, indem Sie die Taste ENTER wiederholt drücken.

Schritt 4

Befehl: make menuconfig

Beschreibung: Konfigurieren Sie den Kernel um. Stellen Sie sicher, dass die folgenden Optionen richtig eingestellt sind (diese Einstellungen gelten für einen Einzelprozessorsystem ohne Hyperthreading):

Optionen Wert Loadable module support -> Module versioning support AUS Processor type and features -> Subarchitecture Type PC-compatible Processor type and features -> Processor family 586/K5/5x86/6x86/6x86MX Processor type and features -> Generic x86 support AUS Processor type and features -> Symmetric multi-processing support AUS Processor type and features -> Local APIC support on uniprocessor AUS Processor type and features -> Use register arguments AUS Adeos support -> Adeos support EIN Kernel hacking -> Compile the kernel with frame pointers AUS

Sichern Sie die Konfiguration vor dem Beenden auf die Frage Save the new kernel configuration? mit Yes. Schritt 5

Befehl: make clean bzImage modules

Beschreibung: Übersetzen Sie den Kernel (Dauer ca.: 1-2 Stunden). Schritt 6

Befehl: make modules_install

Beschreibung: Generieren der Kernel-Module


Punkt 4: Linux Kernel installieren (Kommandozeile) Nach dem Generieren des Kernel muss dieser installiert werden, damit er beim nächsten Neustart des Rechners geladen werden kann. Gehen Sie wie folgt beschrieben vor: Schritt 1

Befehl 1: su Befehl 2: cd /usr/src/linux-2.6.10

Beschreibung: Falls Sie nicht schon Administrator und in diesem Ordner sind: Wechseln Sie zum Benutzer root mit dem Switch-User-Kommando. Root bedeutet, dass Sie Administratorrechte benötigen. Dann in das Verzeichnis /usr/src/linux-2.6.10 wechseln.

Schritt 2

Befehl: cp ./arch/i386/boot/bzImage /boot/vmlinuz-2.6.10-adeos

Beschreibung: Kopieren des generierten Kernel in das Boot-Verzeichnis. Schritt 3

Befehl: cp ./System.map /boot/System.map-2.6.10-adeos

Beschreibung: Kopieren der Map-Datei in das Boot-Verzeichnis. Die Map-Datei dient dem Bootloader dazu, die Datenblöcke in dem der Kernel liegt zu finden.

Schritt 4

Befehl: ln -s /boot/System.map-2.6.10-adeos /boot/System.map

Beschreibung: Verbinden auf System.map. Die System.map ist die Beschreibung des Adressraums des PCs.

Schritt 5

Befehl: mkinitrd -k /boot/vmlinuz-2.6.10-adeos -i /boot/initrd-2.6.10-adeos

Beschreibung: Erstellen eines initial RAM-Disk-Image. Der Zweck einer solchen Disk ist, dem modularen Kernel Zugriff zu den Modulen zu gewähren, die zum booten benötigt werden, bevor der Kernel Zugriff auf das Gerät erhält, in dem die Module normalerweise abgelegt sind.


Schritt 6 Ablauf 1: Auf die grafische Oberfläche wechseln (mit STRG+ALT+F7) Ablauf 2: Startleiste -> System: Yast -> System -> Konfiguration des Bootloaders Ablauf 3: Konfiguration des Bootloaders: Konfigurationsdateien bearbeiten

Beschreibung: Auf die grafische Oberfläche wechseln und das Konfigurationswerkzeug Yast aufrufen.

Richten Sie einen neuen Eintrag im Bootloader-Menü ein (siehe Abbildung).

Fügen Sie dazu die folgenden Zeilen in der Datei /boot/grub/menu.lst ein.

Fett dargestellte müssen an Ihren PC angepasst werden. Bitte kopieren Sie einen bereits existierenden Eintrag als Vorlage und ändern diesen entsprechend:

title ADEOS kernel (hd0,1)/boot/vmlinuz-2.6.10-adeos root=/dev/hda2 vga=0x314 selinux=0 splash=silent resume=/dev/hda1 showopts initrd (hd0,1)/boot/initrd-2.6.10-adeos

Schritt 7

Ablauf 1: Eingaben mit OK bestätigen und Beenden Ablauf 2: PC Neustarten, Kommandozeilenbefehl: Init 0 oder halt

Beschreibung: Neue Konfiguration bestätigen und PC neu starten. Beim Hochfahren im Boot-Menü den Eintrag mit ADEOS.

Tipp: Falls sich hier ein Fehler eingeschlichen haben sollte, so können Sie ohne weiteres die alte Suse Linux Konfiguration starten und nochmals die letzten Schritte überprüfen.


Punkt 5: Echtzeiterweiterung RTAI konfigurieren und generieren (Kommandozeile) Nach der Installation des Kernel müssen die Module für die Echtzeiterweiterung für RTAI konfiguriert und generiert werden. Gehen Sie wie folgt beschrieben vor: Schritt 1

Tastenkombination: STRG+ALT+F1 Befehl 1: su Befehl 2: cd /usr/src

Beschreibung: Falls nicht schon erfolgt, wechseln Sie in einer Kommandozeile zum Benutzer root mit dem Switch-User-Kommando. Root bedeutet, dass Sie Administratorrechte benötigen. Dann in das Verzeichnis /usr/src wechseln.

Schritt 2

Befehl 1: mkdir rtai-build Befehl 2: cd rtai-build

Beschreibung: Verzeichnis rtai-build erstellen und hineinwechseln Schritt 3

Befehl: make -f ../rtai-3.2/makefile menuconfig

Beschreibung: Konfigurieren Sie RTAI. Gleichen Sie die Optionen von RTAI mit denen Ihres Linux-Kernel ab. Auf folgende Dinge ist zu achten:

• Der Pfad zum Linux-Quellcode muss korrekt eingestellt sein.

• Wenn Ihr Rechner auf SMP (Symmetrisches Multiprozessorsystem) eingestellt ist, muss auch RTAI so eingestellt werden.

• Bei SMP muss die Angabe der Anzahl der Prozessoren im Kernel mit der Angabe in RTAI übereinstimmen.

• Wenn Sie eine Hyperthreading-CPU verwenden und Hyperthreading im BIOS aktiviert ist, muss beim Kernel und bei RTAI die Option SMP gewählt werden (ein Prozessor mit Hyperthreading verhält sich wie zwei Prozessoren).

Optionen Wert General -> Linux source tree /usr/src/linux-2.6.10 Machine (x86) -> Number of CPUs AUS (0)

Sichern Sie die Konfiguration vor dem Beenden auf die Frage Do you wish to save your new configuration? mit Yes. Schritt 4

Befehl: make install

Beschreibung: Übersetzen und Installieren von RTAI.


Punkt 6: Prüfen, ob die Echtzeiterweiterung funktioniert (Kommandozeile) Die Prüfung, ob die in den Linux-Kernel eingebaute Echtzeiterweiterung funktioniert, basiert auf Latenzzeitmessungen des von RTAI mitgelieferten Beispielprogramms. Schritt 1

Befehl 1: cd /usr/realtime/testsuite/user/latency Befehl 2: ./run

Beschreibung: In den Ordner des bei RTAI mitgelieferten Testprogramms wechseln und dieses starten.

Erläuterung zum Testprogramm: Das Programm misst die Verzögerungszeiten (Latenzzeitmessung) in Nanosekunden und gibt sie kontinuierlich auf dem Bildschirm aus. Diese Zeiten dürfen sich nur gering ändern, wenn Sie die Systemlast erhöhen. Dies kann zum Beispiel durch schnelle Bewegungen der Computermaus und durch schnelle Tastatureingaben sowie bei Zugriffen auf die Festplatte oder andere Peripheriegeräte geschehen. Auch das Wechseln auf die grafische Oberfläche (STRG+ALT+F7) und das Öffnen von verschiedenen Programmen gleichzeitig erhöht die Systemlast. Die Änderungen der Latenzzeiten haben entscheidende Rückwirkungen auf die Funktion Ihres Anwenderprogramms. Die Latenzzeiten sollten nur wenige Mikrosekunden betragen. Vorgehensweise bei unzureichender Testerfüllung Bei großen Latenzzeitänderungen ist Ihre Systemkonfiguration für Echtzeitanwendungen nur bedingt oder gar nicht geeignet. Dies Betrifft vor allem den Betrieb von isochroner Real-Time (IRT). Versuchen Sie in diesem Fall die Optionen für den Kernel und RTAI zu ändern, zum Beispiel:

• Deaktivieren Sie die Unterstützung von ACPI. • Deaktivieren Sie die Unterstützung von APIC und APM. • Deaktivieren Sie die Unterstützung SMP bzw. Hyperthreading. • Deaktivieren Sie die Unterstützung von „Legacy Support for USB“ im BIOS. • Deaktivieren Sie die 3D-Beschleunigung (Grafische Oberfläche). • Deaktivieren Sie die Unterstützung aller nicht benötigter Optionen (USB, Sound-Karte, Modem

usw.). • Deaktivieren Sie die grafische Oberfläche mit dem Kommandozeilen-Befehl: init 3

Wenn diese Vorschläge nicht helfen, können Sie weitere Hilfe zum Beispiel von den Internet-Seiten der Hersteller erhalten:

• http://www.rtai.org • http://home.gna.org/adeos/


Punkt 7: CP1616-Treiber installieren (Kommandozeile) Der Treiber für den CP1616 wird wie folgt installiert. Hier wird die Datei host-2.0.0.49.6.tar.gz benötigt (siehe Punkt 1: Dateien herunterladen), welche bereits auf den PC geladen wurde (z.B.: Lokale Festplatte -> /home/user/cp1616) Schritt 1


Beschreibung: Falls nicht schon erfolgt, mit dem Switch-User-Kommando User wechseln um Administratorrechte zu bekommen. Wechseln sie in den Ordner, in dem die Datei host-2.0.0.49.6.tar.gz abgelegt wurde, hier zum Beispiel /home/user/cp1616.

Schritt 2

Befehl 1: tar -xzf host-2.0.0.49.6.tar.gz Befehl 2: cd host_linx

Beschreibung: Entpacken der Dateien und wechseln in den Ordner host_linx Schritt 3

Befehl: export RTAI=y

Beschreibung: Die Echtzeiterweiterung RTAI 3.2 nutzen für diesen Kernel nutzen. Schritt 4

Befehl: make

Beschreibung: Generieren des Treibers. Spätestens hier sieht man, ob die Echtzeiterweiterung erfolgreich installiert wurde.

Schritt 5

Befehl: make install

Beschreibung: Installation des Treibers, Schritt 6

Befehl: make load

Beschreibung: Laden und starten des Treibers. Schritt 7

Befehl: make autoload

Beschreibung: Den Treiber nach jedem Neustart des Computers automatisch starten lassen Schritt 8

Befehl 1: init 0 Ablauf: Neustarten und auf eine Kommandozeile wechseln (STRG+ALT+F1) Befehl 2: dmesg | grep cp16xx

Beschreibung: PC neu starten und im Bootmenü ADEOS wählen. Danach mit dmesg alle Meldungen betreffend des CP1616 ausgeben lassen. Hier sollte das erfolgreiche Laden des Treibers angezeigt werden. Werden allerdings Fehler angezeigt, so kann dies am Treiber an sich liegen oder an einem fehlenden Interr


Punkt 8: CP1616-Controller Beispielprogramm starten (Kommandozeile) Hier wird der Ordner CP1616_Controller_Application von der CD „DK-ERTEC 200 PN IO V2.0“ benötigt (siehe Punkt 1: Dateien herunterladen), welcher bereits auf den PC geladen wurde (z.B.: Lokale Festplatte -> /home/user/cp1616) Schritt 1

Befehl 1: su Befehl 2: cd /home/user/cp1616/CP1616_Controller_Application

Beschreibung: Falls nicht schon erfolgt, mit dem Switch-User-Kommando User wechseln um Administratorrechte zu bekommen. Wechseln sie in den Ordner, in dem sich die Controller Applikation befindet, hier zum Beispiel /home/user/cp1616/CP1616_Controller_Application.

Schritt 2

Befehl: make

Beschreibung: Applikation kompilieren. Für den Überblick

• Die Applikation könnte nun mit dem Befehl: ./cp1616_example_appl –i starten. Allerdings würde hieraus nur eine Fehlerausgabe resultieren, da noch keine entsprechende Projektierung der CP1616 stattfand. Dies folgt in einem der nächsten Kapitel.

• Während des Projektierens darf keine Controller-Applikation aktiv sein, da NCM diese nicht stoppen kann.


8 PROFINET IO-Device Zur Erstellung des PROFINET IO-Devices muss zuerst die Entwicklungsumgebung Tornado sowie die dazugehörigen Programme (FTP-, Target-Server, Terminal) auf einem Windows-PC installiert bzw. eingerichtet werden. Das EB200 muss über die serielle Schnittstelle entsprechend konfiguriert werden um das Anwenderbeispiel laden zu können. Dieses Kapitel erklärt die nötigen Schritte um das PROFINET IO-Device (EB200) zu erstellen.

8.1 Tornado 2.2 installieren Das DevKit enthält eine 30 Tage Evaluierungslizenz für die Entwicklungsumgebung Tornado, für das Echtzeitbetriebssystem VxWorks sowie für das Analyseprogramm WindView. Der Lizenzschlüssel muss über die Webseite der Firma WindView angefordert oder per Email angefordert werden. Diese Anforderung dauert laut WindRiver circa 5 bis 7 Werktage. Schritt 1

Alternative 1: Lizenzschlüssel online anfordern: http://www.windriver.com/alliances/eval-cd/. Alternative 2: Lizenzschlüssel per Email anfordern: [email protected] (für Europa)

Beschreibung: Install-Key und Lizenzschlüssel (FlexLm Key) anfordern Schritt 2

Ablauf 1: Tornado installieren Ablauf 2: License Management Auto/Manual Choice: Cancel -> Exit Setup

Beschreibung: Die Tornado 2.2.1/VxWorks 5.5.1 CD beinhaltet die Installationsroutine von Tornado. Bitte beim Installieren dem Installationsassistenten (Standardinstallation) folgen.

Da Sie bereits nach Schritt 1 über einen Lizenzschlüssel verfügen, benötigen sie das License Management nicht. In den nächsten Schritten wird dies manuell durchgeführt!

Schritt 3

Ablauf 1: Ordner …\Tornado2.2\.wind\license erstellen Ablauf 2: Datei …\Tornado2.2\.wind\license\WRSLicense.lic erstellen

Beschreibung: Erstellen Sie einen Ordner für Lizenzen. In diesem Tornado-Lizenzenordner eine Textdatei mit Endung .lic erstellen. Wenn der Ordner nicht vorhanden ist, muss dieser ebenfalls erstellt werden.


Schritt 4 Ablauf: FlexLm Key in die Datei WRSLicense.lic kopieren

Beschreibung: Den FlexLM Key in die Lizenzdatei WRSLicense.lic kopieren.

Schritt 5

Ablauf 1: Systemsteuerung -> System -> Erweitert -> Umgebungsvariablen Ablauf 2: Systemvariablen: Neu Ablauf 3: Name der Variablen: LM_LICENSE_FILE Ablauf 4: Wert der Variablen: (z.B.) C:\Tornado2.2\.wind\license\WRSLicense.lic Ablauf 5: Eingaben mit OK bestätigen

Beschreibung: In den Systemeigenschaften ihres MS Windows die Lizenzdatei als Variable erstellen, damit Tornado diese finden kann.

Abbildung kann vom Original abweichen!


Schritt 6 Ablauf: Tornado starten

Beschreibung: Ob die Lizenzierung erfolgreich war, erfahren Sie bereits wenn Tornado erfolgreich gestartet werden kann.

Für den Überblick Im Installationsumfang von Tornado befinden sich neben dem FTP-Server auch zwei HyperTerminal-Applets, welche einfach gestartet werden müssen um über die serielle Schnittstelle mit dem EB200 zu kommunizieren.

• FTP-Server

• Tornado Entwicklungsumgebung

• HyperTerminal-Applets


8.2 Tornado 2.2 vorbereiten Es müssen verschiedene Dateien von der CD DK-ERTEC 200 PN IO in die bestehende Tornadoinstallation eingefügt werden. Gehen sie wie folgt vor: Schritt 1

Ort auf CD: …\Wind_River\Tornado_PID_2.0_Eval Ablauf: Alle Ordner kopieren nach ...\Tornado2.2

Beschreibung: Die Ordner docs, host, man und target ins Tornado-Installationsverzeichnis kopieren.

Schritt 2

Ort auf CD: …\BSP Ablauf: Ordner ertec200sk kopieren nach ...\Tornado2.2\target\confg

Beschreibung: Das Board Support Package (BSP) ertec200sk der Tornado-Installation hinzufügen.

Schritt 3

Ort auf CD: …\ ZipDir Ablauf 1: Datei starterkit_pniodev_eb200.zip entpacken nach

…\ Tornado2.2\target\proj Ablauf 2: Alles in …\ Tornado2.2\target\proj markieren -> Rechtsklick -> Eigenschaften Ablauf 3: Schreibschutz der Dateien im Ordner …\ Tornado2.2\target\proj entfernen

Beschreibung: Die Beispielsourcen, Projektfiles und generierten PNIO-Objects dem Tornado-Projektordner hinzufügen. Wenn die Dateien von einer CD kopiert wurden, sind diese mit einem Schreibschutz versehen und können nicht in Tornado editiert werden. Der Schreibschutz muss also deaktiviert werden.


8.3 Tornado 2.2 starten und Beispiel-Applikation generieren Im Folgenden wird erklärt wie das in 8.2 eingefügte Projekt konfiguriert geladen und generiert wird. Schritt 1

Ablauf 1: Tornado starten Ablauf 2: Open Workspace: …\ Tornado2.2\target\proj/devkit_eb200.wsp öffnen

Beschreibung: Die Entwicklungsumgebung Tornado 2.2 starten und Workspace devkit_eb200.wsp öffnen

Schritt 2

Ablauf 1: Workspace:devkit_eb200: External Dependencies -> pniodev_cfg.h Ablauf 2: Eintrag: # define GSDML_V2_RT auf 0 setzen Ablauf 3: Eintrag: # define GSDML_V2_IRT auf 1 setzen

Beschreibung: In der Datei pniodev_cfg.h den Eintrag für die GSD-Dateien entsprechend ändern. Die GSD-Datei für das IRT-Projekt wählen.

Schritt 3

Ablauf: Tornado Menüleiste: Build -> Rebuild All

Beschreibung: Ein downloadfähiges Gesamtsystem für das EB200 erzeugen (Datei: (vxworks.stripped).


8.4 Tornado 2.2 – FTP-Server einstellen Zum Laden der PROFINET IO-Device Applikation auf das Development-Board EB200 muss ein FTP-Server installiert sein, der den Zugriff auf die Datei mit dem generierten Gesamtsystem (vxworks.stripped), bereitstellt. Im Installationsumfang von Tornado ist ein FTP-Server enthalten, welcher im Folgenden eingestellt wird: Schritt 1

Ablauf: Windows Startmenü: Programme ->Tornado 2.2 -> FTP Server

Beschreibung: Den FTP-Server aus dem Startmenüeintrag von Tornado starten. Schritt 2

Ablauf: FTP-Server Menüleiste: Security -> Users/rights..

Beschreibung: In das Menü zum einstellen der Benutzerrechte für den FTP-Server wechseln. Schritt 3

Ablauf 1: User / Rights Security Dialog: New User… -> User Name: eb200 Ablauf 2: User / Rights Security Dialog: Change Pass… -> New Password: eb200 Ablauf 3: User / Rights Security Dialog: Home Directory:

C:\TORNADO2.2\TARGET\PROJ\devkit_eb200\DEFAULT Ablauf 4: Eingaben mit Done bestätigen

Beschreibung: Neuen Benutzer „eb200“ erstellen und Passwort auf „eb200“ festlegen.

Ordner des in Tornado erzeugten Systems angeben, die Stelle an der sich die Datei (vxworks.stripped) befindet, welche auf das EB200 geladen werden soll (C:\TORNADO2.2\TARGET\PROJ\devkit_eb200\DEFAULT).


Schritt 4 Ablauf: Menüleiste: Security -> General..

Beschreibung: Vergleichen Sie Ihre die Einstellungen bitte mit dem folgenden Bild:

Schritt 5

Ablauf 1: Menüleiste: Security -> Host/net.. Ablauf 2: Host Security Settings: Host address: 192.168.10.1

Beschreibung: Vergleichen Sie Ihre die Einstellungen bitte mit dem folgenden Bild:

Schritt 6

Ablauf 1: Menüleiste: Logging -> Log Options.. Ablauf 2: Alles aktivieren

Beschreibung: Wenn hier alles Aktiviert ist, sieht man, wenn sich das EB200 die Datei vom FTP-Server runterläd.


8.5 Tornado 2.2 – optional: Target-Server einstellen Die folgenden Schritte erklären die Vorgehensweise um den Target-Server für dieses Projekt zu erstellen, zu konfigurieren und zu starten. Der Target-Server wird für zusätzliche Diagnosemöglichkeiten benötigt (Debugger, Simulator,…). Es wird hier lediglich gezeigt, wie dieser für dieses Projekt eingestellt werden muss und ist für den weiteren Verlauf nicht nötig. Der Target-Server kann auch nachträglich konfiguriert werden. Schritt 1

Ablauf 1: Tornado starten Ablauf 2: Tornado Menüleiste: Tools -> Target Server -> Configure

Beschreibung: Einen Target Server erstellen bzw. konfigurieren.

Schritt 2

Ablauf 1 Configure Server Descriptions: mit “New” neuen Target Server erstellen Ablauf 2: Configure Server Descriptions: Description: startdev Ablauf 3: Configure Server Descriptions: Add description to menu: aktivieren Ablauf 4: Configure Server Descriptions: Target Server Name: startdev Ablauf 5: Configure Server Descriptions: Target Name/IP Address: 192.168.10.2

Beschreibung: Vergleichen Sie die soeben getätigten Einstellungen bitte mit folgendem Bild:

hier Schritte 3-6


Schritt 3 Ablauf 1: Configure Server Descriptions: Target Server Properties: Backend Ablauf 2: Available Back Ends: wdbrpc

Beschreibung: Vergleichen Sie die Einstellungen bitte mit folgendem Bild und gleichen Sie wenn nötig an:

Schritt 4

Ablauf 1 Configure Server Descriptions: Target Server Properties: Core File and Symbols

Ablauf 2: File: …\tornado2.2\target\proj\devkit_eb200\default\vxWorks


Schritt 5

Ablauf 1 Configure Server Descriptions: Target Server Properties: Memory Cache Size Ablauf 2: Specify (K Bytes): 4096



Schritt 6 Ablauf 1 Configure Server Descriptions: Target Server Properties: Target Server File

System Ablauf 2: Root: …\tornado2.2\target\proj\devkit_eb200\default


Schritt 7 Ablauf 1 Tornado Menüleiste: Tools -> Target Server -> startdev

Beschreibung: Target Server „startdev“ starten.


8.6 Terminal einstellen und Bootparameter des EB200 ändern Zum ändern der Bootparameter und zum anschauen der Ausgaben des EB200 wird ein Terminal-Programm benötigt. Hier wird das HyperTerminal, welches in Windows integriert ist, empfohlen. Für dieses Terminalprogramm sind ist bereits Applets im Installationsumfang von Tornado enthalten (siehe 8.1). Schritt 1

Ablauf 1: Terminalprogramm starten z.B.: Start -> Ausführen: hypertrm Ablauf 2: Schnittstellenparameter einstellen

Beschreibung: Ein Terminalprogramm Ihrer Wahl oder eines der HyperTerminal-Applets von Tornado starten. Die folgenden Schnittstellenparameter nutzen:

Option Wert Port COM-Schnittstelle des PCs die verwendet werden soll Bits pro Sekunde 115200 Datenbits 8 Bit Parität keine Stoppbits 1 Bit Flusssteuerung keine

Schritt 2

Ablauf 1: EB200 starten Ablauf 2: Verbindung hestellen

Beschreibung: Das Entwicklungsboard EB200 starten (siehe 6.2) und physikalische Verbindung herstellen (siehe 6.3). Terminalverbindung starten.


Schritt 3 Ablauf: Terminal: beliebige Taste drücken

Beschreibung: Bei Aufforderung den automatischen Bootvorgang mit beliebiger Taste unterbrechen.

VxWorks System Boot Copyright 1984-2002 Wind River Systems, Inc. CPU: ERTEC200sk (Siemens A&D) Version: VxWorks5.5.1 BSP version: 1.2/0 Creation date: Apr 4 2006, 19:05:26 Press any key to stop auto-boot... 1 [VxWorks Boot]:

Schritt 4

Ablauf 1: Terminal: c Ablauf 2: Terminal: Parameter ändern (siehe Bild)

Beschreibung: Über die Eingabe „c“ die Bootparameter des EB200 editieren. Alle Parameterzeilen, die nicht geändert werden sollen, werden mit Return nicht geändert. Die Änderung der Parameterzeilen erfolgt direkt in der Zeile.

[VxWorks Boot]: c '.' = clear field; '-' = go to previous field; ^D = quit boot device : ifeast0 processor number : 0 host name : xena file name : vxworks vxworks.stripped inet on ethernet (e) : 192.168.0.9 192.168.10.2 inet on backplane (b): 192.168.20.102 host inet (h) : 192.168.0.66 192.168.10.1 gateway inet (g) : user (u) : boot eb200 ftp password (pw) (blank = use rsh): boot eb200 flags (f) : 0x0 0x8 target name (tn) : ertec200sk startup script (s) : other (o) : [VxWorks Boot]:


Schritt 5 Ablauf: Terminal: l oder Reset-Taster

Beschreibung: Bootdatei (vxworks.stripped) vom FTP-Server laden (Dauer ca.: 1,5 Minuten). Hierzu musste zuvor die Datei (vxworks.stripped) in Tornado generiert werden sowie der FTP-Server eingerichtet und gestartet worden sein!

Die Applikation startet automatisch nachdem die Datei (vxwoks.stripped) geladen wurde

Press any key to stop auto-boot... 0 auto-booting... boot device : ifeast unit number : 0 processor number : 0 host name : xena file name : vxworks.stripped inet on ethernet (e) : 192.168.10.2 inet on backplane (b): 192.168.20.102 host inet (h) : 192.168.10.1 user (u) : eb200 ftp password (pw) : eb200 flags (f) : 0x8 target name (tn) : ertec200sk Attached TCP/IP interface to ifeast0. Warning: no netmask specified. Attaching network interface lo0... done. Loading... 4507312

Für den Überblick

• Mit der Eingabe ? in der VxWorks-Kommandozeile des EB200 werden alle möglichen Befehle ausgegeben.

• Das Programm des EB200 muss nach jedem Neustart neu geladen werden, es muss also immer mindestens der FTP-Server aktiviert sein und gemäß Kapitel 6.3 eine Ethernet-Verbindung mit der Debug-Schnittstelle vorhanden sein.


9 Automatisierungssystem projektieren Um das Gesamtsystem in Betrieb nehmen zu können muss noch das im Lieferumfang enthaltene NCM 5.4 installiert werden und die entsprechenden Dateien, wie die GSD-Datei und Projekt des Anwenderbeispiels aufgespielt werden. Zuletzt muss das Projekt konfiguriert und geladen werden.

9.1 NCM 5.4 installieren In diesem Teil des Leitfadens wird die Installation des, auf IRT-Kommunikation basierenden Automatisierungssystems beschrieben. Schritt 1

Ablauf: Alte Step7- und NCM-Installationen entfernen

Beschreibung: Mit bisherigen Versionen von SIMATIC Step7 (<5.4) kann kein IRT-Projekt geladen werden. Leider müssen daher zur Vorbereitung der neuen NCM-Installation alle Step7-Installationen entfernt werden.

Schritt 2

Ablauf: NCM 5.4 installieren

Beschreibung: Die CD SIMATIC NET CP1616/CP1604 beinhaltet die Installationsroutine von NCM 5.4. Beim Installieren dem Installationsassistenten (Standardinstallation) folgen.

9.2 NCM 5.4 vorbereiten Es müssen verschiedene Dateien von der CD DK-ERTEC 200 PN IO V2.0 in die bestehende NCM-Installation eingefügt werden. Gehen sie wie folgt vor: Schritt 1

Ort auf CD: …\GSDML Ablauf: Datei GSDML-V2.0-Siemens-ERTEC200Devkit-20060410.xml kopieren nach

Ihr NCM-Installationsverzeichnis: …\SIMATIC.NCM\S7Data\GSD

Beschreibung: Die GSD-Datei des EB200 in das GSD-Verzeichnis von NCM kopieren. Schritt 2

Ort auf CD: …\GSDML Ablauf: Dateien GSDML_002A_ERTEC200DEVKitV10.bmp und

GSDML_002A_ERTEC200DEVKitV20.bmp kopieren nach Ihr NCM-Installationsverzeichnis: …\SIMATIC.NCM\S7Data\NSBMP

Beschreibung: Die zur GSD-Datei gehörigen Grafiken in das entsprechende Verzeichnis von NCM kopieren.

Schritt 3

Ort auf CD: …\NCM_PC Ablauf: Datei EB200_PNIO_NCM_PC.zip entpacken nach

Ihr NCM-Installationsverzeichnis: …\SIMATIC.NCM\S7proj

Beschreibung: Die Beispielprojektierung dem SIMATIC NCM-Projektordner hinzufügen.


9.3 NCM 5.4 starten und Projekt konfigurieren Im Folgenden wird die Ethernetverbindung zum projektieren des Automatisierungssystem eingestellt sowie das, dem DevKit beiliegende Beispielprojekt konfiguriert und geladen. Schritt 1

Ablauf 1: SIMATIC NCM PC Manager starten Ablauf 2: NCM Menüleiste: Extras -> PG/PC-Schnittstelle einstellen… Ablauf 3: PG/PC-Schnittstelle einstellen: Benutzte Schnittstellenparametrierung:

TCP/IP(Auto) -> (Netzwerkkarte mit der der CP1616 verbunden ist) wählen

Beschreibung: Nachdem Sie SIMATIC NCM PC Manager gestartet haben, müssen Sie die Schnittstellenparametrierung für die Verbindung mit dem PROFINET IO-Controller (CP1616) einstellen.

Schritt 2

Ablauf: NCM Menüleiste: Zielsystem -> Erreichbare Teilnehmer anzeigen

Beschreibung: Hier werden alle Teilnehmer angezeigt, welche sich gerade an der eingestellten Verbindung befinden.

Über die Objekteigenschaften können die Geräte anhand der MAC-Adresse identifiziert werden.

Zum projektieren muss lediglich die PC-Station mit der CP1616 erreichbar sein. Wenn allerdings alle Verbindungen richtig verknüpft sind (siehe 6.3) und das EB200 seine Applikation über den FTP-Server geladen hat, sollte auch dieses angezeigt werden.


Schritt 3 Ablauf 1: NCM Menüleiste: Datei->Öffnen Ablauf 2: Öffnen Projekt: Durchsuchen:

…\SIMATIC.NCM\S7Data\S7proj\EB200_PNIO_NCM_PC

Beschreibung: Das Projekt EB200_PNIO_NCM_PC öffnen

Schritt 4

Ablauf: SIMATIC NCM PC Konfig starten

Beschreibung: Öffnen Sie die Hardware Konfiguration des Projekts über einen Rechtsklick mit der Maus auf der Konfiguration der SIMATIC PC-Station.


Schritt 5 Ablauf 1: Rechtsklick auf das PN-IO-Objekt der PC-Station -> Objekteigenschaften… Ablauf 2: Eigenschaften – PN-IO: Eigenschaften Ablauf 3: Eigenschaften – Ethernet Schnittstelle PN-IO: IP-Adresse: 192.168.20.101 Ablauf 4: Mit OK bestätigen

Beschreibung: Ändern Sie die IP-Adresse des PROFINET IO-Controllers (siehe auch 6.3).


Schritt 6 Ablauf 1: Rechtsklick auf das EB200PNIO-Objekt -> Objekteigenschaften… Ablauf 2: Eigenschaften des Objekts : Gerätename: EB200PNIO Ablauf 3: Eigenschaften des Objekts: Ethernet… Ablauf 4: Eigenschaften – Ethernet Schnittstelle ERTEC-DEVkit: IP-Adresse:

192.168.20.102 Ablauf 5: Mit OK bestätigen

Beschreibung: Ändern Sie die IP-Adresse und Gerätename des PROFINET IO-Devices (siehe auch 6.3).

Schritt 7

Ablauf: CP1616 vorbereiten

Beschreibung: Um das Automatisierungssystem laden zu können, muss der CP1616 erreichbar und die Controller-Applikation deaktiviert sein.


Schritt 8 Ablauf 1: Menüleiste SIMATIC NCM PC Konfig: Zielsystem -> Laden in Baugruppe Ablauf 2: Teilnehmeradresse auswählen: Anzeigen oder Aktualisieren Ablauf 3: Erreichbare Teilnehmer: CP 1616 auswählen Ablauf 4: Mit OK bestätigen

Beschreibung: Laden Sie das System in die Baugruppen. Sollte der CP1616 unter den Erreichbaren Teilnehmern nicht angezeigt werden, so überprüfen Sie bitte die Verbindungen (siehe 6.3) und schauen Sie ob der Linux-PC mit dem CP1616 eingeschaltet ist.

Für den Überblick Wurden die letzten Schritte erfolgreich absolviert, so ist das Automatisierungssystem projektiert. Es ist keine Verbindung vom PC mit NCM zur PC-Station mit dem CP1616 mehr nötig. Zur Diagnose kann diese Verbindung dennoch hilfreich sein.


10 System in Betrieb nehmen Dieses Kapitel beinhaltet neben einer Checkliste aller nötigen Komponenten die zur Inbetriebnahme nötig sind, die kurze Beschreibungen der Controller- und Device-Applikation. Außerdem finden Sie hier ein Kapitel zur Problembehandlung.

10.1 Checkliste PROFINET IO-Controller:

• Linux-PC mit der CP1616 gestartet, • Treiber der CP1616 aktiviert (siehe 7.5 Punkt 5), • CP1616-Controller-Applikation aktiviert (siehe 10.3), • Verbindungen eingerichtet (siehe 6.3),

Vorsicht bei IRT-Kommunikation: der Port 1 EB200 muss an Port 1 des CP1616 angeschlossen werden (gemäß NCM-Projektierung). Die Verbindung darf nicht über ein Switch geleitet werden.

PROFINET IO-Device:

• FTP-Server aktiviert (siehe 8.4), • Terminalprogramm mit richtigen Schnittstellenparameter aktiviert (siehe 8.6), • EB200 aktiviert und Device-Applikation über den FTP-Server geladen.

Automatisierungssystem projektiert:

• IRT-Projekt in die Baugruppe geladen (siehe 9.3)

10.2 Device-Applikation Die Device-Applikation wird über ein Terminalprogramm gesteuert. Mit dieser Applikation sind verschiedene Aktionen ausführbar:

• Aktivieren/Deaktivieren des zyklischen Datenaustausches • Stecken und Ziehen eines Moduls • Stecken und Ziehen eines Submoduls • Senden eines Prozessalarms • Senden eines Diagnosealarms • Anzeige der aktuellen IO-Daten • sonstige Testfunktionen


10.3 Controller-Applikation Folgenden Schritt in der Linux-Kommandozeile im Ordner mit der CP1616 Beispielapplikation ausführen (siehe auch 7.5 Punkt 8) Schritt 1

Befehl: ./cp1616_example_appl -i

Beschreibung: Applikation starten. Die Option „-i“ immer bei einer IRT-Projektierung einbeziehen. Ansonsten „-i“ weglassen.

Der Programmablauf startet wenn Sie nach dem Start „s“ eingeben. Stoppen können sie den Ablauf mit „q“. Nachdem das EB200 (PROFINET IO-Device) richtig installiert wurde sollte man dies auf dem Bildschirm sehen, dazu später mehr! Die Controller Applikation reagiert auf Daten und Alarme vom EB200 lediglich mit einer Ausgabe auf dem Bildschirm. Für den Überblick Wird ein Fehlercode ausgegeben, so kann dessen Bedeutung in der Datei pnioerrx.h im Tornado Workspace nachgeschlagen werden.


11 Eigene Applikation erstellen In diesem Teil des Leitfadens wird eine einfache eigene Applikation erstellt. Ausgehend von einem einfachen IO-Knoten wird eine Modellierung dieses Knotens auf das Gerätemodell von PROFINET IO in seinen Aspekten (Slotmodell und Subslotmodell, zyklischer Datenaustausch) vorgenommen. Die Applikation wird die PROFINET Kommunikationsstufe Real-Time Class-1 nutzen. In diesem Rahmen werden folgende Punkte behandelt:

• Erstellung eines, auf das EB200 abgestimmtes IO-Moduls, • Erstellung der, für die Projektierung des EB200 erforderlichen GSD-Datei. • Erstellung einer Projektierung eines Automatisierungssystems mit NCM, • Anpassungen der Device- und Controller-Applikationen.


X20

X22

X21

2 4 61 3 5

87

.. ..

.. ..

Steckerschema X..

X11 X10

11.1 IO-Modul erstellen Die Kanäle des IO-Knotens werden über Taster und LEDs simuliert. Hierzu wird ein kleines Modul erstellt. Punkt 1: Steckerposition und Belegung Das Modul wird an den X21-Stecker des EB200 angeschlossen. Es handelt sich hier um eine 2x10 polige Stiftleiste die mit den GPIO[16…31] der ERTEC 200 verbunden ist. Für das hier entstehende IO-Modul werden lediglich die GPIO[16…23] genutzt. Die Steckerposition sowie die Steckerbelegung wird in den folgenden Abbildungen veranschaulicht:

20 19

18 17

16 15

14 13

12 11

10 9

8 7

6 5

4 3

2 1

GND

Taster 2

Taster 1 LED 4

LED 2

+3V

LED 3

LED 1

GND

GND

GPIO[17]

GPIO[19]

GPIO[21]

GPIO[23]

GPIO[16]

GPIO[18]

GPIO[20]

GPIO[22]

Taster 4

Taster 3


Punkt 2: Stückliste und Schaltplan für das IO-Modul Um das Ganze möglichst einfach zu machen, werden hier lediglich die folgenden Bauteile benötigt:

• 4* LEDs (D1…D4) • 4* 150Ω-Widerstände2 (R1) • 4* Taster (T1…T4) • 1* 20-adriges Flachbandkabel ca. 20-30cm • 2* 20-polige Pfostenbuchse, • 1* 2-reihige, 2x10-polige Stiftleiste (P1) • Lochrasterplatine, ca. 6x6cm • Litzen für die Verdrahtung der Platine

-

2 Spannung an den Pins des EB200 U = 3V; Übliche Stromstärke für LEDs (bitte im Datenblatt überprüfen) I = 20mA. R=3V/20mA=150Ω


11.2 GSD-Datei für das EB200 erstellen Für jedes PROFINET-Gerät muss eine Gerätebeschreibung als XML-Datei erstellt werden, eine so genannte Geräte-Stammdaten-Datei (GSD-Datei). Die GSD-Datei enthält die Geräte-Stammdaten des Produkts und ist vom Hersteller anzufertigen. Sie umfasst die technischen Kenndaten des Gerätes, Angaben zu seinen Kommunikationsfähigkeiten sowie weitere Informationen, zum Beispiel über Diagnosewerte. Als Vorlage für die Eigene kann die im DevKit enhaltene GSD-Datei des EB200 dienen.Hilfreich bei der Erstellung der GSD-Datei sind auch die Beispiele von der offiziellen PROFINET Webpräsenz (http://www.profibus.com/pn/applications/products/). Als Editor wird der XMLspy 2007 Enterprise Edition der Firma Altova empfohlen, dieser ist in einer kostenlosen 30-Tage Trialversion zum testen erhältlich (www.xmlspy.com). Grundsätzlicher Aufbau einer GSD-Datei: Der Aufbau einer GSD-Datei sieht immer gleich aus, die eigentliche Gerätebeschreibung befindet sich im ProfileBody. Hier werden zuerst allgemeine Informationen festgelegt, wie Hersteller und Gerätefamilie. Im ApplicationProcess folgen die speziellen Informationen, zum Beispiel über wie viele Slots das Gerät verfügt, ob diese fest belegt sind und so weiter. <?xml version="1.0" encoding="iso-8859-1"?> <ISO15745Profile xmlns="http://www.profibus.com/GSDML/2003/11/DeviceProfile" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.profibus.com/GSDML/2003/11/DeviceProfile ..\XSD\GSDML-DeviceProfile-v2.0.xsd"> <ProfileHeader> <ProfileBody> <DeviceIdentity VendorID="0x002A" DeviceID="0x0001"> <DeviceFunction> <ApplicationProcess> <DeviceAccessPointList> <ModuleList> <ChannelDiagList> <GraphicsList> <CategoryList> <ExternalTextList> </ApplicationProcess> </ProfileBody> </ISO15745Profile> Der Weg und das Ziel: Im Folgenden wird eine GSD-Datei nach und nach zusammengesetzt. Sie können schrittweise vorgehen oder die Datei komplett runterladen (www.init-owl.de/EB200-Leitfaden) und das Kapitel bis auf den letzten Schritt überspringen. Das Ziel der folgenden Schritte ist eine GSD-Datei wie in nachfolgender Skizze:

• Eigene Kategorie

• Eigener Name

• Eigenes Bild

• Feste Slots/Subslots

• Ein 4Bit Eingang

• Ein 4Bit Ausgang


Schritt 1 Ablauf: GSD-Datei erstellen

Beschreibung: Erstellen Sie eine neue GSD-Datei (.xml-Datei) Ihrem XML-Editor:

GSDML-[GSD-Schemaversion]-[Herstellername]-[Gerätefamilie]-[Datum].xml

zum Beispiel: GSDML-v2.0-Siemens-ERTEC200IODev-20070207.xml GSD-Schemaversion Der XML-Editor validiert die erstellte Datei mit einem GSD-Schema im

Internet. Hier bitte die version 2, also v2.0 nutzen Herstellername Die Firmenkennung des Geräteherstellers. In diesem Projekt wird die

Kennung Siemens genutzt, sowie deren VendorID. Sollten Sie bereits eine eigene Kennung sowie VendorID besitzen, so müssen sie diese im Tornado-Projekt in der Datei pniodev_cfg.h ändern (# define VENDOR_ID 0x002a).

Gerätefamilie Gibt an, welcher Gerätefamilie das jeweilige Gerät zugeordnet ist Datum Das Freigabedatum der GSD-Datei im Format JahrMonatTag (yyyymmdd)

Schritt 2

Ablauf 1: Alles löschen Ablauf 2: Ort des GSD-Schemas angeben

Beschreibung: Zuerst alles was in der Datei eventuell erzeugt wurde, löschen.

Um die GSD-Datei zu validieren, also mit einem Schema abgleichen zu können, muss der Ort angegeben werden, wo sich dieses Schema befindet:

GSD-Datei ergänzen: <?xml version="1.0" encoding="iso-8859-1"?> <ISO15745Profile xmlns="http://www.profibus.com/GSDML/2003/11/DeviceProfile" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.profibus.com/GSDML/2003/11/DeviceProfile ..\XSD\GSDML-DeviceProfile-v2.0.xsd">

Schritt 3

Ablauf: ProfileHeader einfügen

Beschreibung: Der ProfileHeader beschreibt einige allgemeine Informationen:

GSD-Datei ergänzen: […] <ProfileHeader> <ProfileIdentification>PROFINET Device Profile</ProfileIdentification> <ProfileRevision>1.00</ProfileRevision> <ProfileName>Device Profile for PROFINET Devices</ProfileName> <ProfileSource>PROFIBUS Nutzerorganisation e. V. (PNO)</ProfileSource> <ProfileClassID>Device</ProfileClassID> <ISO15745Reference> <ISO15745Part>4</ISO15745Part> <ISO15745Edition>1</ISO15745Edition> <ProfileTechnology>GSDML</ProfileTechnology> </ISO15745Reference> </ProfileHeader>


Schritt 4 Ablauf 1: ProfileBody eröffnen Ablauf 2: DeviceIdentity einfügen Ablauf 3: DeviceFunction einfügen

Beschreibung: Im ProfileBody stehen alle Devicespezifischen Informationen.

Den Anfang macht die DeviceIdentity in der u.a. Herstellername und -ID stehen. Aufgrund der Informationen in DeviceFunktion wird das Gerät in Step7/NCM im Hardwarekatalog eingeordnet.

GSD-Datei ergänzen: […] <ProfileBody> <DeviceIdentity VendorID="0x002A" DeviceID="0x0001"> <InfoText TextId="DevIdent_InfoText"/> <VendorName Value="SIEMENS"/> </DeviceIdentity> <DeviceFunction> <Family MainFamily="I/O" ProductFamily="DEVKIT"/> </DeviceFunction>

Erläuterung: <InfoText TextId="[…]"/> Hier wird auf einen Text verwiesen, der in mehreren Sprachen

abgelegt sein kann. Der Text befindet sich in der ExternalTextList, welche einem der späteren Schritte eingefügt wird.

Schritt 5

Ablauf: ApplicationProcess einfügen

Beschreibung: Der nächste Punkt im ProfileBody ist der ApplicationProcess. Hier befinden sich alle Daten zur Funktion des Gerätes (Slots, Subslots, Diagnosewerte,…).

GSD-Datei ergänzen: […] <ApplicationProcess>


Schritt 6 Ablauf: DAP einfügen

Beschreibung: Standardmäßig im Slot 0 des Gerätes befindet sich eine Busanschaltung, den so genannten DAP (Device Access Point)

GSD-Datei ergänzen: […] <DeviceAccessPointList> <DeviceAccessPointItem ID="DAP 1" PhysicalSlots="0..2" ModuleIdentNumber="0x00000001" MinDeviceInterval="32" ImplementationType="ERTEC200" DNS_CompatibleName="IO-DEV" ExtendedAddressAssignmentSupported="true" FixedInSlots="0" ObjectUUID_LocalIndex="1" RequiredSchemaVersion="V1.0"> <ModuleInfo CategoryRef="ID_ERTEC200DEVKit"> <Name TextId="V1.0"/> <InfoText TextId="InfoText_DAP1"/> <VendorName Value="Siemens"/> <OrderNumber Value="abab ccc-deded"/> <HardwareRelease Value="A1.0"/> <SoftwareRelease Value="Z1.0"/> </ModuleInfo> <IOConfigData MaxInputLength="128" MaxOutputLength="128"/> <UseableModules> <ModuleItemRef ModuleItemTarget="Mod_1" FixedInSlots="1"/> <ModuleItemRef ModuleItemTarget="Mod_2" FixedInSlots="2"/> </UseableModules> <VirtualSubmoduleList> <VirtualSubmoduleItem ID="DAP 1" SubmoduleIdentNumber="0x00000001"> <IOData IOPS_Length="1" IOCS_Length="1"/> </VirtualSubmoduleItem> </VirtualSubmoduleList> <Graphics> <GraphicItemRef Type="DeviceSymbol" GraphicItemTarget="ID_Graph_1"/> </Graphics> </DeviceAccessPointItem> </DeviceAccessPointList>

Erläuterungen: PhysicalSlots="0..2" Hier wird festgelegt, über wie viele Slots das Gerät verfügen soll. In

diesem Fall drei, dem DAP, einem Slot für den Eingang und einen für den Ausgang.

[…]IdentNumber="[…]"> Die Identifikationsnummern sind Herstellerspezifisch. MinDeviceInterval="32" Gibt die Mindestzykluszeit in 31,25µs-Schritten für das Gerät an. Hier

also 32*31,25µs=1ms. FixedInSlots="[…]" Wenn das Modul (DAP, Ein-/Ausgang) einen festen Slot haben soll,

ist dieser hier anzugeben. <IOConfigData […]/> Begrenzt die Daten die in einem Datenzyklus gesendet und

empfangen werden können. <UseableModules> Verweist auf die gesteckten Module, auf die dieser DAP zugreifen

kann und welche später definiert werden (Mod_1 und Mod_2).

Schritt 7 Ablauf: ModuleList mit ersten ModuleItem einfügen

Beschreibung: Die ModuleList beinhaltet die Module (ModuleItems), welche in diesem Gerät gesteckt werden können. Den Anfang macht hier ein Eingabemodul (Mod_1)

GSD-Datei ergänzen: […] <ModuleList>  <ModuleItem ID="Mod_1" ModuleIdentNumber="0x00000021"> <ModuleInfo> <Name TextId="4 Bit Input"/> <InfoText TextId="4 Bit Eingabemodul"/> <HardwareRelease Value="1.0"/> <SoftwareRelease Value="1.0"/> </ModuleInfo> <VirtualSubmoduleList> <VirtualSubmoduleItem ID="1" SubmoduleIdentNumber="0x0001" API="0"> <IOData IOPS_Length="1" IOCS_Length="1"> <Input Consistency="All items consistency"> <DataItem DataType="Unsigned8" UseAsBits="true" TextId="Eingänge"/> </Input> </IOData> </VirtualSubmoduleItem> </VirtualSubmoduleList> </ModuleItem>

Schritt 8

Ablauf: ModuleList mit zweiten ModuleItem ergänzen und schließen

Beschreibung: Der ModuleList ein weiteres Modul (Mod_2) hinzufügen.

GSD-Datei ergänzen: […]  <ModuleItem ID="Mod_2" ModuleIdentNumber="0x00000022"> <ModuleInfo> <Name TextId="4 Bit Output"/> <InfoText TextId="4 Bit Ausgabemodul"/> <HardwareRelease Value="1.0"/> <SoftwareRelease Value="1.0"/> </ModuleInfo> <VirtualSubmoduleList> <VirtualSubmoduleItem ID="2" SubmoduleIdentNumber="0x0001" API="0"> <IOData IOPS_Length="1" IOCS_Length="1"> <Output Consistency="All items consistency"> <DataItem DataType="Unsigned8" UseAsBits="true" TextId="Ausgänge"/> </Output> </IOData> </VirtualSubmoduleItem> </VirtualSubmoduleList> </ModuleItem> </ModuleList>

Erläuterungen: <VirtualSubmodule[…]> Dient zur eindeutigen Adressierung der Slots und Subslots. <Output […] ,<Input[…] Legt die Richtung fest, ob es sich hier um einen Ein- oder einen

Ausgang handelt. DataType="Unsigned8" Der Datentyp der für dieses Modul genutzt werden soll. Unsigned8 ist

hier die kleinste mögliche Einheit.


Schritt 9 Ablauf: ChannelDiagList einfügen

Beschreibung: Die ChannelDiagList beinhaltet die Diagnosemeldungen des Gerätes.

GSD-Datei ergänzen: […] <ChannelDiagList> <ChannelDiagItem ErrorType="16"> <Name TextId="Parametrierfehler"/> </ChannelDiagItem> </ChannelDiagList>

Schritt 10

Ablauf: GraphicsList einfügen

Beschreibung: Die GraphicsList beinhaltet den verweis auf eine Bitmapdatei welche diesem Gerät zugeordnet wird und man dann in NCM/Step7 HW Konfig sehen kann. Die Datei wird aus dem Ordner …\Siemens\SIMATIC.NCM\S7data\nsbmp geladen.

GSD-Datei ergänzen: […] <GraphicsList> <GraphicItem ID="ID_Graph_1" GraphicFile="GSDML_IODEV"/> </GraphicsList>

Schritt 11

Ablauf: CategoryList einfügen

Beschreibung: Die CategoryList erhöht die Übersicht im Hardwarekatalog von NCM/Step7

GSD-Datei ergänzen: […] <CategoryList> <CategoryItem ID="ID_ERTEC200DEVKit" TextId="Category_ERTEC200DEVKit"/> </CategoryList>

Schritt 12 Ablauf: ExternalTextList einfügen

Beschreibung: Die vorangegangen TextIds referenzieren in diese Liste. Hier können die Textlinks in verschiedenen Sprachen abgelegt werden.

GSD-Datei ergänzen: […] <ExternalTextList> <PrimaryLanguage>  <Text TextId="DevIdent_InfoText" Value="IO-Devkit with ERTEC 200"/>  <Text TextId="Category_ERTEC200DEVKit" Value="ERTEC200 IO-Device"/> <Text TextId="V1.0" Value="IO-Dev"/> <Text TextId="InfoText_DAP1" Value="ERTEC 200 IO-Device V1.0"/>  <Text TextId="Input Module" Value="Inputmodule"/> <Text TextId="Output Module" Value="Outputmodule"/>  <Text TextId="4 Bit Input" Value="4 Bit Input"/> <Text TextId="4 Bit Eingabemodul" Value="4 Bit input module"/> <Text TextId="Eingänge" Value="Inputs"/>  <Text TextId="4 Bit Output" Value="4 Bit Output"/> <Text TextId="4 Bit Ausgabemodul" Value="4 Bit output module"/> <Text TextId="Ausgänge" Value="Outputs"/>  <Text TextId="Parametrierfehler" Value="Parameter assignment error"/> </PrimaryLanguage> <Language xml:lang="de">  <Text TextId="DevIdent_InfoText" Value="IO-Device mit ERTEC 200"/>  <Text TextId="Category_ERTEC200DEVKit" Value="ERTEC 200 IO-Device"/> <Text TextId="V1.0" Value="IO-Dev"/> <Text TextId="InfoText_DAP1" Value="ERTEC 200 IO-Device V1.0"/>  <Text TextId="Input Module" Value="Eingabemodul"/> <Text TextId="Output Module" Value="Ausgabemodul"/>  <Text TextId="4 Bit Input" Value="4 Bit Eingang"/> <Text TextId="4 Bit Eingabemodul" Value="4 Bit Eingabe Modul"/> <Text TextId="Eingänge" Value="Eingänge"/>  <Text TextId="4 Bit Output" Value="4 Bit Ausgang"/> <Text TextId="4 Bit Ausgabemodul" Value="4 Bit Ausgabe Modul"/> <Text TextId="Ausgänge" Value="Ausgänge"/>  <Text TextId="Parametrierfehler" Value="Parametrierfehler"/> </Language> </ExternalTextList>

Schritt 13

Ablauf: Das Ende der GSD-Datei

Beschreibung: Es muss darauf geachtet werden das alle geöffneten Passagen auch wieder geschlossen werden. Sind Sie nach den vorangegangenen Schritten vorgegangen, so ist dies das Ende der GSD-Datei:

GSD-Datei ergänzen: […] </ApplicationProcess> </ProfileBody> </ISO15745Profile>


Schritt 14 Ablauf: GSD-Datei speichern

Beschreibung: Auch wenn eine Fehlermeldung sagt, dass die Daten nicht gültig sind, wird die Datei trotzdem gespeichert. Grund dafür kann zum Beispiel sein, dass die Datei nicht mit dem Schema abgeglichen werden konnte (fehlende Internetverbindung).

Schritt 15

Ablauf 1: GSD-Datei nach …\Siemens\SIMATIC.NCM\S7data\gsd veschieben Ablauf 2: Bilddatei nach …\Siemens\SIMATIC.NCM\S7data\nsbmp verschieben

Beschreibung: Die Bilddatei wurde in der GraphicsList verlinkt, muss also diesen Namen tragen, hier also GSDML_IODEV.bmp. Als Vorbild für Ihr eigenes Bild können die bereits vorhandenen Dateien dienen. Ansonsten erstellen sie eine Bitmapdatei mit den Abmessungen 70x40 pixel


11.3 NCM-Projektierung erstellen In diesem Kapitel wird Schrittweise eine NCM-Projektierung für das vorliegende Projekt erstellt. Schritt 1

Ablauf 1: SIMATIC NCM PC Manager starten Ablauf 2: NCM Manager Menüleiste: Datei->Neu Ablauf 3: Neues Projekt: Name: myRTsystem Ablauf 4: Neues Projekt: mit OK bestätigen

Beschreibung: SIMATIC NCM PC Manager starten und ein neues Projekt erstellen. Das Projekt zum Beispiel „myRTsystem“ nennen

Schritt 2

Ablauf: Rechtsklick auf myRTsystem: Neues Objekt einfügen->SIMATIC PC-Station

Beschreibung: Als Controller wird in diesem Projekt eine PC-Station mit CP1616 projektiert. Erstellen Sie also eine SIMATIC PC-Station in Ihrem Projekt.

Schritt 3

Ablauf: SIMATIC PC-Station öffnen Ablauf: Rechtsklick auf Konfiguration: Objekt öffnen

Beschreibung: Die Hardwarekonfiguration für die PC-Station öffnen


Schritt 4 Ablauf 1: Menüleiste SIMATIC NCM PC Konfig: Extras -> Katalog aktualisieren Ablauf 2: Hardwarekatalog -> CP1616: V1.0 in den grünen Bereich der PC-Station

ziehen Ablauf 3: Eigenschaften - Ethernet Schnittstelle CP1616: IP-Adresse: 192.168.20.101 Ablauf 4: Eigenschaften - Ethernet Schnittstelle CP1616: Neu Ablauf 5: Eigenschaften - Neues Subnetz Industrial Ethernet: OK

Beschreibung: Zuerst den Hardwarekatalog aktualisieren, damit auch die eigene GSD-Datei geladen wird. Danach die CP1616 V1.0 in die PC-Station ziehen (z.B. mit Hilfe der gedrückten linken Maustaste). Die Eigenschaften dieser Schnittstelle werden dann automatisch aufgerufen. Hier muss die IP-Adresse eingestellt und ein neues Subnetz erstellt werden. Das Subnetz muss nicht konfiguriert werden.

Schritt 5

Ablauf 1: CP 1616 markieren Ablauf 2: Menüleiste SIMATIC NCM PC Konfig: Einfügen-> PROFINET IO-System

Beschreibung: Fügen Sie ein PROFINET IO-System ein.


Schritt 6 Ablauf: Hardwarekatalog ->I/O: Eigenes Device IO-Dev einfügen

Beschreibung: Fügen Sie das eigene Device, hier IO-Dev in die Projektierung ein (mit gedrückter Maustaste auf das PROFINET IO-System ziehen)

Sollte das eigene Device nicht im Hardwarekatalog angezeigt werden, so aktualisieren Sie erneut den Hardwarekatalog. Ein Neustart von NCM kann in manchen Fällen ebenfalls helfen. Wird das Modul immer noch nicht angezeigt, so wird der Fehler wahrscheinlich in der GSD-Datei liegen, überprüfen Sie diese nochmals und vergleichen Sie ggf. mit Kapitel 11.2.

Schritt 7

Ablauf 1: Rechtsklick auf das IO-Device-Objekt -> Objekteigenschaften… Ablauf 2: Eigenschaften des Objekts: Gerätename: EB200PNIO Ablauf 3: Eigenschaften des Objekts: Gerätename: IP-Adresse: 192.168.20.102

Beschreibung: Name und IP-Adresse des Devices überprüfen und wenn nötig ändern. Der Name muss EB200PNIO sein, da dieser Name vom Controller erwartet wird.


Schritt 8 Ablauf: CP1616 verbinden

Beschreibung: Den CP1616 mit dem PC verbinden und aktivieren.

Schritt 9

Ablauf 1: Menüleiste SIMATIC NCM PC Konfig: Zielsystem -> Laden in Baugruppe Ablauf 2: Teilnehmeradresse auswählen: Aktualisieren Ablauf 3: Erreichbare Teilnehmer: CP 1616 auswählen Ablauf 4: Mit OK bestätigen

Beschreibung: Laden Sie das System in die Baugruppen. Sollte der CP1616 unter den Erreichbaren Teilnehmern nicht angezeigt werden, so überprüfen Sie bitte die Verbindungen (siehe 6.3) und schauen Sie ob der Linux-PC mit dem CP1616 eingeschaltet ist.


11.4 Device Applikation erstellen Die Applikation die hier erstellt werden wird, verzichtet auf das Benutzermenü und gibt lediglich noch Ausgaben an die serielle Schnittstelle weiter. Device-Applikation:

• 4 digitale Eingänge (Taster) zyklisch abrufen und über PROFINET senden, • 4 digitale Ausgänge (LEDs) zyklisch anhand der PROFINET IO-Informationen setzen, • Kein Benutzermenü, sondern lediglich eine Ausgabe der IO-Daten auf die serielle

Schnittstelle, • RT Class-1 Kommunikation.

Für den Überblick Die eigene Applikation wird auf Grundlage des, im DevKit enthaltenen Anwenderbeispiels erstellt:

1. pniodev_usrmain.c Diese Datei beinhaltet u.a. die main()-Funktion sowie die IOD-Funktion für den PROFINET-Verbindungsaufbau und die Message-Queue für die Benutzeranwendung. (wird im Folgenden geändert) 2. pniodev_cb.c Callback-Funktionen, die zum Beispiel von der IOD-Task benötigt werden. 3. pniodev_mod_list.c Funktionen für Module, Submodule und deren Daten 4. pniodev_alarm.c Alarmfunktionen 5. pniodev_api.c API-Funktionen 6. pniodev_menu.c Diese Datei enthält das eigentliche Anwenderprogramm. Im weiteren Verlauf dieses Leitfadens wird diese Datei durch eine eigene ersetzt. 7. pniodev_tasks.c Funktionen für den Umgang mit Tasks, Messages und Timer. 8. pniodev_system.h Diese Header-Datei enthält einige wichtige System-Definitionen 9. pniodev_cfg.h Diese Datei enthält Definitionen der Konfiguration PROFINET IO-Device. (wird im Folgenden geändert) 10. pniodev.h Hier werden alle „private types“, „macros“ und Deklarationen definiert. (wird im Folgenden geändert) 11.pnioerrx.h Fehler-Codes für die Benutzerschnittstelle.


Punkt 1: pniodev_in_out.c erstellen Es werden im Folgenden die Erstellung der eigenen Funktionen in der Datei pniodev_in_out.c erklärt. Sie können diese Datei auch komplett runterladen (www.init-owl.de/EB200-Leitfaden) und dann im Ordner …\Tornado2.2\target\proj\pniodev_application\src ablegen. Schritt 1

Ablauf: Tornado und das Projekt devkit_eb200 starten

Beschreibung: Für die nächsten Schritte werden Tornado und das Beispielprojekt welches bereits bearbeitet wurde, benötigt.

Schritt 2

Ablauf 1: Workspace devkit_eb200: devkit_eb200 Files -> (Rechtsklick) Add Files… Ablauf 2: Add Source File to devkit_eb200: Suchen in: Ordner

…\Tornado2.2\target\proj\pniodev_application\src wählen Ablauf 3: Add Source File to devkit_eb200: Dateityp: All Files (*.*) Ablauf 4: Add Source File to devkit_eb200: (rechtsklick) Neu -> Textdokument Ablauf 5: Add Source File to devkit_eb200: umbenennen in pniodev_in_out.c Ablauf 6: Add Source File to devkit_eb200: Mit Add einfügen Ablauf 7: Dependencies: OK

Beschreibung: Im Workspace die Datei pniodev_in_out.c einfügen. Diese entweder wie hier gezeigt, generieren oder die, aus dem Internet geladene Datei einfügen. Wurde die Internetdatei eingefügt, so kann bei Punkt 2 fortgefahren werden.

Schritt 3

Ablauf 1: pniodev_in_out.c in Tornado öffnen Ablauf 2: Tornado Menüleiste: Edit -> Select All -> Entfernen-Taste (Entf)

Beschreibung: Datei pniodev_in_out.c bereinigen. Die ersten Zeilen sollten Beschreibungen zu den Funktionen dieser Datei enthalten, was später erledigt werden kann.


Schritt 4 Ablauf: Bibliotheken einbeziehen

Beschreibung: Die ersten Zeilen der eigenen Applikation. Hier werden die Systembibliotheken (pniodev_system.h, pniousrd.h) und Bibliotheken der eigenen Task (pniodev.h, pniodev_cfg.h) eingefügt

pniodev_in_out.c Ergänzen: /******************************** * Includes ********************************/ #include <pniodev_system.h> #include <pniousrd.h> #include "pniodev.h" #include "pniodev_cfg.h"

Schritt 5

Ablauf: Pointer zu den GPIO-Registeradressen setzen

Beschreibung: Poiner zu den GPIO-Registeradressen setzen, welche in einem späteren Schritt in der Header-Datei pniodev.h eingebunden werden.

Register Beschreibung GPIO_IOCTRL Legt die die Richtung fest, also ob ein Pin Ein- oder Ausgang ist. GPIO_PORT_MODE_H Die GPIOs können bis zu 4 verschiedene Funktionen ausführen. Welche

Funktion aktiv sein soll, muss hier im festgelegt werden. GPIO_OUT Ausgänge werden hier gesetzt GPIO_IN Eingänge werden hier abgerufen

pniodev_in_out.c Ergänzen: /******************************** * Pointer to GPIO-Registers ********************************/ volatile PNIO_UINT32 *GPIO_IOcontrol = (PNIO_UINT32*)GPIO_IOCTRL; volatile PNIO_UINT32 *GPIO_mode = (PNIO_UINT32*)GPIO_PORT_MODE_H; volatile PNIO_UINT32 *GPIO_output = (PNIO_UINT32*)GPIO_OUT; volatile PNIO_UINT32 *GPIO_input = (PNIO_UINT32*)GPIO_IN;

Schritt 6

Ablauf: Lokale Prototypen deklarieren

Beschreibung: Alle Funktionen die noch folgen werden hier deklariert. Detailinformationen zu den Funktionen folgen in den nächsten Schritten.

pniodev_in_out.c Ergänzen: /******************************** * Locale Prototypes ********************************/ int pniodev_InOutMain(int iodTaskId, int *debug, int start); static int PNIO_Output(int taskId, void *message[]); static int PNIO_Input(); static int Test_In_Out(); static void SetData (pniodev_device_data_t *devData, PNIO_UINT8 val); static int sendCommand(int taskId, void *message[]);


Schritt 7 Ablauf: Funktion sendCommand() ergänzen

Beschreibung: Wie im nachstehenden Code zu sehen, werden hier Messages an die IOD-Funktion gesendet. Die IOD-Funktion befindet sich in der Datei pniodev_usrmain.c. Es wird in dieser Applikation lediglich der Befehl zum setzten der PROFINET IO-Prozessdaten genutzt. Weitere Befehle sind zum Beispiel das Setzen von Alarmen oder Diagnosewerten.

pniodev_in_out.c Ergänzen: /************************************************** * sendCommand() * send a message to the iod main task **************************************************/ static int sendCommand(int taskId, void *message[]) if ( (int)message[0] == TSTCMD_NO_MSG ) return PNIO_OK; return pniodev_sendMessage(taskId, (void*)message, MSG_PRIO_USER);

Schritt 8

Ablauf: Funktion SetData() ergänzen

Beschreibung: Diese Funktion beschreibt die PROFINET IO-Prozessdaten eines spezifischen Slots/Subslots.

pniodev_in_out.c Ergänzen: /************************************************** * SetData() * sets the IO-Data for the specified slot/subslot **************************************************/ static void SetData (pniodev_device_data_t *devData, PNIO_UINT8 val) int i; if ( devData != NULL ) for ( i = 0; i < devData->InDatLen; i++ ) devData->InData[i] = val;


Schritt 9 Ablauf: Funktion PNIO_Output() ergänzen

Beschreibung: Es wird hier das GPIO-Eingangsregister ausgelesen um den Status der Taster zu erfragen. Das Ergebnis wird in der Variablen var gespeichert und an die Funktionen SetData() (setzen der IO-Daten) und sendCommand() (senden der IO-Daten) weitergegeben. Außerdem wird der Status der Taster auf der seriellen Schnittstelle ausgegeben.

pniodev_in_out.c Ergänzen: /************************************************* * PNIO_Output() * gets the Input from the Buttons and write it to the PROFINET OUTPUT *************************************************/ static int PNIO_Output(int taskId, void *message[]) PNIO_UINT8 val; pniodev_device_data_t *devData; /* pointer to data from Input-Module Slot 1, Subslot 1 */ devData = pniodev_getModSubmod(1,1); message[1] = (void*)devData; /* read Inputregister */ val = val | ((*GPIO_getin & 0x00F00000)>>20); /* set IO-data */ SetData(devData, (PNIO_UINT8)val); /* Output for Hyperterminal */ printf("\tIn: %01x", (devData->InData[0]) & 0x0F); /* request that a initiate data write is performed */ message[0] = (void*)TSTCMD_INI_WR; sendCommand(taskId, message); return PNIODEV_OK;

Schritt 10

Ablauf: Funktion PNIO_Intput() ergänzen

Beschreibung: Es wird hier der Input vom PROFINET abgefragt und auf die GPIO-Ausgangsregister gelegt, welche den LEDs zugeteilt sind. Außerdem wird der Status des PROFINET IO-Inputs auf der seriellen Schnittstelle ausgegeben.

pniodev_in_out.c Ergänzen: /************************************************* * PNIO_Input() * sets the OUTPUT register in order to the PROFINET INPUT *************************************************/ static int PNIO_Input() PNIO_UINT8 val; pniodev_device_data_t *devData; /* pointer to data from Output-Module Slot2, Subslot 1*/ devData = pniodev_getModSubmod(2,1); if (devData->OutDatLen != 0) val = (PNIO_UINT8)devData->OutData[0]; /* Output for Hyperterminal */ printf("\nOut: %01x ", (PNIO_UINT8)devData->OutData[0] & 0x0F); /* mask outputregister */ *GPIO_output = *GPIO_output & 0xFFF0FFFF; *GPIO_output = *GPIO_output | (val<<16); return PNIODEV_OK;


Schritt 11 Ablauf: Testfunktion PNIO_Intput() ergänzen

Beschreibung: Diese Funktion ist im Betrieb nicht aktiviert. Lediglich zum testen der LEDs und der Taster ist sie sinnvoll. Es wird hier der GPIO-Treiber genutzt um direkt auf die Ein- und Ausgänge zuzugreifen. Außerdem wird eine Textausgabe an die serielle Schnittstelle gesendet.

pniodev_in_out.c Ergänzen: /************************************************* * Test_In_Out() * Taster steuern direkt LEDs, - Funktion zum testen der GPIOs *************************************************/ static int Test_In_Out() ertecx00GpioOut(16, ertecx00GpioIn(20)); ertecx00GpioOut(17, ertecx00GpioIn(21)); ertecx00GpioOut(18, ertecx00GpioIn(22)); ertecx00GpioOut(19, ertecx00GpioIn(23)); printf("test"); return PNIODEV_OK;


Schritt 12 Ablauf: Hauptfunktion pniodev_InOutMain() ergänzen

Beschreibung: Die Funktion pniodev_InOutMain() wird aus der main() der Datei pniodev_usrmain() aufgerufen und ist der Startpunkt der eigenen Applikation.

Hier werden die GPIO-Konfigurationsregister den Bedürfnissen angepasst (Input, Output, Funktion des GPIOs). Wie die Register maskiert werden müssen und wo die Eingangs und Ausgangsdaten abgerufen bzw. gesetzt werden, ist untenstehender Tabelle zu entnehmen.

pniodev_in_out.c Ergänzen: /********************************************** * pniodev_InOutMain() * entry point **********************************************/ int pniodev_InOutMain(int iodTaskId, int *debug, int start) int status = PNIODEV_OK; void *message[10]; message[0] = TSTCMD_NO_MSG; /* mask GPIO-configuration-registers */ *GPIO_IOcontrol = *GPIO_IOcontrol | 0x00F00000; *GPIO_IOcontrol = *GPIO_IOcontrol & 0xFFF0FFFF; *GPIO_mode = *GPIO_mode & 0xFFFF0000; /* cyclic data check */ while(status == PNIODEV_OK) status = PNIO_Output(iodTaskId, message); status = PNIO_Input(); /* status = Test_In_Out(); Einkommentieren für den Testbetrieb */ return status;

Die folgende Tabelle stellt die Register Binär dar und mit Strichen „-„ gekennzeichnete Felder werden nicht berücksichtigt. Im Programm werden die Register in Hexadezimaler Form maskiert und bearbeitet. Bit-Nummer 31…28 27…24 23…20 19…16 15…12 11…8 7…4 3…0

GPIO_IOCTRL - - - - - - - - 1 1 1 1 0 0 0 0 - - - - - - - - - - - - - - - -GPIO_PORT_ MODE_H - - - - - - - - - - - - - - - - 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

GPIO_IN - - - - - - - - x x x x - - - - - - - - - - - - - - - - - - - -

GPIO_OUT - - - - - - - - - - - - x x x x - - - - - - - - - - - - - - - -


Punkt 2: pniodev_cfg.h Es werden in den folgenden Schritten Änderungen an der Header-Datei pniodev_cfg.h vorgenommen. Sie können den Folgenden Schritten folgen um die vorgehen oder die Datei komplett runterladen (www.init-owl.de/PN-Leitfaden ). Schritt 1

Ablauf: Definition für eine neue Konfiguration ergänzen und aktivieren

Beschreibung: Es wird hier im weiteren Verlauf eine GSD-Datei mit vorgegebenen Slots/Subslots erstellt, daher wird hier eine weitere Konfiguration ergänzt und diese aktiviert:

Original: […] # define GSDML_V1_RT 0 /* only RT for connection with V1 controller */ # define GSDML_V2_RT 0 /* only RT module from the GSDML V2.0 version */ # define GSDML_V2_IRT 1 /* use IRT module (only for IRT operation) */ […]

Ergänzen mit: […] # define GSDML_V1_RT 0 /* only RT for connection with V1 controller */ # define GSDML_V2_RT 0 /* only RT module from the GSDML V2.0 version */ # define GSDML_V2_IRT 0 /* use IRT module (only for IRT operation) */ # define GSDML_V1_RT_FIXED 1 /* only RT for GSD with fixed Slots with V1 controller */ […]


Schritt 2 Ablauf: Definition für eine neue Konfiguration ergänzen und aktivieren

Beschreibung: Die Konfiguration der Slots/Subslots muss ergänzt werden:

Original: […] /************************************************* * a little check for our configuration *************************************************/ # if (GSDML_V1_RT + GSDML_V2_RT + GSDML_V2_IRT) != 1 # error "Please set only one of the GSDML_* defines to 1" # endif /**************************************************** * help data for plugging of modules and sub modules ****************************************************/ […] # if (GSDML_V2_IRT == 1) # define DEVICE_DATA \ 0, 1, 0x0002, 0x001, 0x00 , \ 1, 1, 0x0050, 0x001, 0x00 , \ 2, 1, 0x0051, 0x001, 0x00 # endif # endif /* ONLY_DAP */ […]

Ergänzen mit: […] /************************************************* * a little check for our configuration *************************************************/ # if (GSDML_V1_RT + GSDML_V2_RT + GSDML_V2_IRT + GSDML_V1_RT_FIXED) != 1 # error "Please set only one of the GSDML_* defines to 1" # endif /**************************************************** * help data for plugging of modules and sub modules ****************************************************/ […] # if (GSDML_V2_IRT == 1) # define DEVICE_DATA \ 0, 1, 0x0002, 0x001, 0x00 , \ 1, 1, 0x0050, 0x001, 0x00 , \ 2, 1, 0x0051, 0x001, 0x00 # endif # if (GSDML_V1_RT_FIXED == 1) # define DEVICE_DATA \ 0, 1, 0x0001, 0x001, 0x00 , \ 1, 1, 0x0021, 0x001, 0x00 , \ 2, 1, 0x0022, 0x001, 0x00 # endif # endif /* ONLY_DAP */ […]


Punkt 3: pniodev.h Es werden in den folgenden Schritten Änderungen an der Header-Datei pniodev.h vorgenommen. Schritt 1

Ablauf: Definitionen für die GPIO-Register einfügen

Beschreibung: Es werden hier die Adressen zu den GPIO-Registern definiert: Register Adresse Beschreibung GPIO_IOCTRL 0x40002500 Legt die die Richtung fest, also ob ein Pin Ein- oder

Ausgang ist. GPIO_PORT_MODE_H 0x40002510 Die GPIOs können bis zu 4 verschiedene

Funktionenausführen. Welche Funktion aktiv sein soll, muss hier im festgelegt werden.

GPIO_OUT 0x40002504 Ausgänge werden hier gesetzt GPIO_IN 0x40002508 Eingänge werden hier abgerufen

Ergänzen: […] /************************************* * Defines and enums *************************************/ /* Settings concerning GPIO for EB200 */ #define GPIO_IOCTRL 0x40002500 #define GPIO_PORT_MODE_H 0x40002510 #define GPIO_OUT 0x40002504 #define GPIO_IN 0x40002508 […]

Punkt 4: pniodev_usrmain.c Es werden im Folgenden die Änderungen an der Datei pniodev_usrmain.c verdeutlicht. Schritt 1

Ablauf: Funktion: main() -> Menü-Funktion ersetzten

Beschreibung: Lediglich statt des Menüs eine andere Applikation pniodev_InOutMain() starten.

Original: […] if ( status == PNIODEV_OK ) /* call the menu */ menuReturn = pniodev_menuMain(iodMainId, &debug, start); […]

Ersetzen durch: […] if ( status == PNIODEV_OK ) /* Eigene Applikation starten */ menuReturn = pniodev_InOutMain(iodMainId, &debug, start); […]


Punkt 5: Tornadoprojekt kompilieren und Applikation auf das EB200 laden Zuletzt muss das Softwareprojekt für das EB200 noch kompiliert werden. Schritt 1

Ablauf: Tornado Menüleiste: Build -> Rebuild All

Beschreibung: Ein downloadfähiges Gesamtsystem für das EB200 erzeugen (Datei: (vxworks.stripped). Die Datei vxworks.stripped befindet sich an einer definierten Stelle, welche vom FTP-Server als Standardordner benutzt wird. Hier muss also nichts weiter eingestellt werden.

Schritt 2

Ablauf: Applikation auf das EB200 laden

Beschreibung: Falls Sie es noch nicht bereits erledigt haben so aktivieren Sie das EB200, schließen Sie das IO-Modul daran an, überprüfen Sie die Debug-Verbindung für den FTP-Server und starten Sie diesen. Die Applikation sollte nun auf das EB200 geladen werden und startet danach automatisch.


11.5 Controller Applikation erstellen Die Datei cp1616_example_appl.c mit der erweiterte Applikation kann komplett aus dem Internet geladen werden (www.init-owl.de/EB200-Leitfaden). Punkt 1: Controller-Applikation erweitern Dieser Punkt startet auf der grafischen Oberfläche von Linux. Schritt 1

Ablauf 1: In den Ordner CP1616_Controller_Application wechseln Ablauf 2: Rechtsklick auf cp1616_example_appl.c -> Eigenschaften Ablauf 3: Kontrollieren ob Sie Vollzugriff auf die Datei haben Ablauf 4: Rechtsklick auf cp1616_example_appl.c -> Offnen mit -> KWrite

Beschreibung: Wechseln sie in den Ordner, in dem sich die Controller Applikation befindet, hier zum Beispiel Festplatte/home/user/cp1616/CP1616_Controller_Application. Überprüfen Sie, ob Sie Vollzugriff auf die Datei cp1616_example_appl.c haben und rufen Sie dann mit einem Texteditor, zum Beispiel KWrite diese Datei auf.

Schritt 2

Ablauf: Definitionen für Inputlänge und Adresse ändern

Beschreibung: Die folgenden Einträge suchen und die Adresse von 256 auf 0 ändern und die Inputlänge ändert sich auf 1, was für 1 Byte steht.

Ändern: […] /*------------------------------------------------------------------------*/ /* Global Data for Device */ /*------------------------------------------------------------------------*/ PNIO_ADDR g_deviceInputAddress = PNIO_ADDR_LOG, PNIO_IO_IN, 0 ; #define DEVICE_INPUT_LENGTH 1 […]

Schritt 3

Ablauf: Definitionen und Variablen ergänzen

Beschreibung: Für die Funktion zum senden von IO-Daten werden einige Variablen und Definitionen benötigt, ähnlich denen der Input-Funktion.

Tipp: Die Input-Variablen kopieren und Input mit Output ersetzen.

Ergänzen: […] /*------------------------------------------------------------------------*/ /* Global Data for Device */ /*------------------------------------------------------------------------*/ volatile PNIO_IOXS g_deviceOutputState= PNIO_S_BAD; PNIO_ADDR g_deviceOutputAddress = PNIO_ADDR_LOG, PNIO_IO_OUT, 0 ; #define DEVICE_OUTPUT_LENGTH 1 /* length in bytes of output module */ const PNIO_UINT32 g_deviceOutputLength = DEVICE_OUTPUT_LENGTH; /* Output data buffer */ PNIO_UINT8 g_deviceOutputData[DEVICE_OUTPUT_LENGTH]; /* last Output buffer data */ PNIO_UINT8 g_deviceLastOutputData[DEVICE_OUTPUT_LENGTH]; […]


Schritt 4 Ablauf: Prototypen ergänzen Beschreibung: Hier muss lediglich eine zusätzliche Funktion geschrieben werden, also

benötigt man auch nur dessen Prototyp:

Ergänzen: […] /*------------------------------------------------------------------------*/ /* forward declaration of helper functions */ /*------------------------------------------------------------------------*/ bool WriteOutputData(PNIO_UINT32 dwHandle); […]

Schritt 5

Ablauf: Funktion WriteOutputData() erstellen

Beschreibung: Diese Funktion versendet die IO-Daten:

Ergänzen: […] bool WriteOutputData(PNIO_UINT32 dwHandle) PNIO_UINT32 dwErrorCode; if (!g_deviceActivated) return(false); dwErrorCode = PNIO_data_write( /*in*/ dwHandle, /* handle */ /*in*/ &g_deviceOutputAddress, /* pointer to device Output address */ /*in*/ g_deviceOutputLength, /* length in bytes of output */ /*in*/ &g_deviceOutputData[0], /* pointer to output data */ /*in*/ g_localState, /* local status */ /*out*/ (PNIO_IOXS*)&g_deviceOutputState); /* remote status */ if (dwErrorCode == PNIO_OK) memcpy(g_deviceLastOutputData, g_deviceOutputData, sizeof(g_deviceOutputData)); return(true); else printf("Error in PNIO_data_write, function returned 0x%x"CRLF, dwErrorCode); return(false); […]


Schritt 6 Ablauf: Funktion main() ergänzen

Beschreibung: Diese Funktion versendet die IO-Daten:

Original: […] /* At least one byte in both arrays must be different to print the first read data and */ g_deviceInputData[0] = 0; g_deviceLastInputData[0] = 1; […]

Ergänzen mit: […] /* At least one byte in both arrays must be different to print the first read data and write to IO-Base. */ g_deviceInputData[0] = 0; g_deviceLastInputData[0] = 1; g_deviceOutputData[0] = 0; g_deviceLastOutputData[0] = 1; […]


Schritt 7 Ablauf: Funktion main() ergänzen

Beschreibung: Die do-Schleife ergänzen, damit die Eingangsdaten direkt wieder versendet werden.

Original: […] do if ((bIrt && memcmp(g_deviceInputData, g_deviceLastInputData, g_deviceInputLength)) || (!bIrt && ReadInputData(g_dwHandle))) printf("\nNew input data from address %u with length %u:", g_deviceInputAddress.u.Addr, g_deviceInputLength); printf("\n input device state = %s", ((g_deviceInputState == PNIO_S_GOOD) ? "good" : "bad")); /* Print bytes as hex values */ for (byt = 0; byt < g_deviceInputLength; byt++) if ((byt % 16) == 0) printf(CRLF); printf(" "); else if ((byt % 8) == 0) printf(" "); else if ((byt % 4) == 0) printf("- "); printf("%02x ", g_deviceInputData[byt]); printf(CRLF); memcpy(g_deviceLastInputData, g_deviceInputData, g_deviceInputLength); key = getCharWithTimeout(); […]

Ergänzen und Ersetzen mit: […] do if ((bIrt && memcmp(g_deviceInputData, g_deviceLastInputData, g_deviceInputLength)) || (!bIrt && ReadInputData(g_dwHandle))) printf("\nNew input data from address %u with length %u:", g_deviceInputAddress.u.Addr, g_deviceInputLength); printf("\n input device state = %s", ((g_deviceInputState == PNIO_S_GOOD) ? "good" : "bad")); /* print bytes as hex values */ printf("Device -> Controller: %02X ", g_deviceInputData[0]); g_deviceOutputData[0]=g_deviceInputData[0]; printf("\n Controller -> Device: %02X ", g_deviceOutputData[0]);

/* set output */ WriteOutputData(g_dwHandle); printf(CRLF); memcpy(g_deviceLastInputData, g_deviceInputData, g_deviceInputLength); key = getCharWithTimeout(); […]


Schritt 8 Ablauf: Applikation speichern Beschreibung: Speichern Sie die Applikation.

Punkt 2: Controller-Applikation compilieren und starten (Kommandozeile) Das Compilieren und Starten der Applikation geschieht in der Linux Kommandozeile. Schritt 1

Tastenkombintion: STRG+ALT+F1 Befehl 2: su Befehl 3: cd /home/user/cp1616/CP1616_Controller_Application

Beschreibung: Mit dem Switch-User-Kommando User wechseln um Administratorrechte zu bekommen. Wechseln sie in den Ordner, in dem sich die Controller Applikation befindet, hier zum Beispiel /home/user/cp1616/CP1616_Controller_Application.

Schritt 2

Befehl: make

Beschreibung: Applikation kompilieren. Schritt 3

Befehl 1: ./cp1616_example_appl Befehl 2: s

Beschreibung: Applikation starten.

11.6 Der Betrieb Eingaben über die Taster vom IO-Modul werden über PROFINET an den CP1616 gesendet. Das Anwenderprogramm des CP1616 sendet die Prozessdaten vom EB200 einfach zurück. Aufgrund dieser zurückgesendeten Daten werden die LEDs des IO-Moduls gesetzt. Die Ein- und Ausgangsdaten werden außerdem vom EB200 über die serielle Schnittstelle ausgegeben, welche dann mit dem Hyperterminal ausgelesen werden kann.

Leitfaden V1 2 - Technische Hochschule OWL · Beschreibung: SIMATIC NCM PC Manager starten und ein...

Documents

Transcript of Leitfaden V1 2 - Technische Hochschule OWL · Beschreibung: SIMATIC NCM PC Manager starten und ein...