Titel-Banner
Programmierung16.01.2002

Die Programmierung der EPIC-Card

Die Programmierung der EPIC ist - sofern man das Prinzip verstanden hat - keine allzu große Sache mehr. Aber wie so oft liegt hier die Tücke im Detail und umfangreiche Programmierberspiele sucht man leider in der Dokumentation vergebens. Daher möchte ich hier in einer etwas ungeordneten Reihenfolge ein paar kleine Programmierbeispiele für einige alltägliche Problemstellungen geben. Viel Spaß damit.

Anschluss von Kippschaltern an die EPIC-Card
Grundsätzliches zu einem EPIC-Programm
Ansteuerung eines ON/OFF-Kippschalters
Ansteuerung eines ON/OFF/ON-Kippschalters
Ansteuerung eines Rotary-Elementes
Ansteuerung einer LED per Kippschalter
Ansteuerung einer LED über QProcs
Ansteuerung von LEDs über Pigeon-Holes


Anschluss von Kippschaltern an die EPIC-Card

Zuerst einmal müssen wir den Kippschalter an die EPIC-Card anschliessen. Hierfür benötigen wir natürlich neben der Basic Card mit ihrem First Expansion Modul ein ABA-Modul und mindestens ein 64BTN-Modul. An einem 64BTN-Modul befinden sich - wie der Name schon vermuten läßt - 64 Schraubklemmen zum bequemen Anschluß von Schaltern, Buttons etc. sowie 2 Klemmen zum Anschluß der Masseleitungen. Der eine Pol unseres Kippschalters wird nun an irgend einer der 64 Klemmen angeschraubt. Den zweiten Pol schrauben wir an eine der beiden Masseklemmen. Das war's schon.

Wenn wir mehr als einen Kippschalter o.ä. anschliessen wollen, müssen wir wie im unten angezeigtem Schaltbild den einen Pol des zusätzlichen Schalters an eine freie Klemme am 64BTN-Modul anschrauben. Den anderen Pol dieses Schalters "kaskadieren" wir, indem wir ihn an den Pol des bereits angeschlossenen Kippschalters schrauben, welcher weiter zur Masseklemme des 64BTN-Moduls weitergeführt wurde.

EPIC-Schaltbild


Grundsätzliches zu einem EPIC-Programm

Ein EPIC-Programm bzw. besser der EPIC-Quelltext kann mit jedem handeslüblichen ASCII-Editor erstellt und bearbeitet werden. Nach der Erstellung wird dieser Quelltext mit Hilfe des mitgelieferten Programmes EPL.EXE auf Fehler überprüft und anschliessend kompiliert. Das kompilierte EPIC-Programm kann nun mit dem Programm LOADEPIC.EXE an die EPIC-Card "upgeloadet" werden und ist anschliessend dort aktiv.

Leider dürfen EPIC-Quelltexte inklusive Kommentare nicht grösser sein als 64 KByte, da sonst EPL.EXE mit einer Fehlermeldung abbricht. Bei mir zumindest ist mein Quelltext gut dokumentiert und damit wesentlich grösser als die 64 KByte. Daher habe ich ein kleines Hilfsprogramm mit Namen XEPL.EXE geschrieben, welches meinen Quelltext automatisch komprimiert, indem es alle Kommentare sowie überflüssige Leerstellen und Tabulatoren temporär entfernt und anschliessend den EPIC-Compiler EPL.EXE aufruft.

Ein EPIC-Quelltext sollte immer aus folgenden Programmzeilen bestehen:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset }

Dieses Programm macht erst einmal nicht besonders viel, sondern initialisiert nach seinem Laden nur die EPIC-Card. Ebenfalls wird hier angegeben, dass das sogenannte Modul 0 sehr häufig (Angabe "FASTSCAN") sowie die weiteren Module 1 und 2 nur mit normaler Geschwindigkeit auf Veränderungen gescannt werden soll. EPIC kann maximal 16 Rows schnell scannen.


Ansteuerung eines ON/OFF-Kippschalters

Zuerst müssen wir mit dem mitgelieferten Programm TEST128.EXE feststellen, auf welcher Nummer der angeschlossene Kippschalter reagiert. Hierfür müssen wir als erstes das obige Kernprogramm kompilieren und an die EPIC-Card updoaden. Danach starten wir das Programm TEST128.EXE und betätigen den angeschlossenen Kippschalter. Wenn auf dem Bildschirm keine Taste von Modul 0 aufleuchtet, wählen wir in Programm Modul 1 aus und betätigen den Kippschalter erneut. Wird hier die Taste noch immer nicht erkannt, wählen wir Modus 2 aus und wiederholen den Vorgang. Jetzt spätestens muss eine Taste erkannt werden. Eine Nummer müsste bei Aktivierung des Schalters in Grün angezeigt werden und beim Deaktivieren müsste die gleiche Nummer Rot aufleuchten. Diese Nummer merken wir uns, da sie in Zukunft für diesen Schalter steht. Wir gehen für unser Beispiel nehmen wir an, dass die Nummer "192" ist. Jetzt gehen wir davon aus, dass wir mit diesem Kippschalter das ECM aktivieren wollen. Hierzu müssen wir die Taste "j" an den Flugsimulator Falcon senden. Hier nun das dazugehörige Programm:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset }

:ECMToggle { KeyHit(j) }     ; ECM togglen

DefineButton(192, ON,  ECMToggle)
DefineButton(192, OFF, ECMToggle)

Ist doch gar nicht so schwer, oder?


Ansteuerung eines ON/OFF/ON-Kippschalters

Ein sogenannter ON/OFF/ON-Kippschalter ist genauso einfach in EPIC zu programmieren. Bei einem ON/OFF/ON-Kippschalter haben wir es - wie der Name bereits andeutet - mit einem Schalter zu tun, welcher zwei! ON-Stellungen besitzt. Somit müssen bei einem korrekten Anschluss an die EPIC auch zwei Nummern mit dem Programm TEST128.EXE geliefert bekommen und zwar für jede ON-Stellung eine. Gehen wir einmal davon aus, dass wir die Nummern "73" und "74" geliefert bekommen haben und mit dem Kippschalter den Master Arm Schalter simulieren wollen. Dann sieht das Programm so aus:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset }

:MasterArm { ShiftHit(m) }     ; Master Arm auf Arm
:MasterOff { CtrlHit(m) }      ; Master Arm auf Off
:MasterSim { AltHit(m) }       ; Master Arm auf Simulate

DefineButton(73, ON,  MasterArm)
DefineButton(73, OFF, MasterOff)
DefineButton(74, ON,  MasterSim)
DefineButton(74, OFF, MasterOff)


Ansteuerung eines Rotary-Elementes

Der Anschluss eines sogenannten Incrementalgebers - ich möchte es einfacher Rotary-Element nennen - kann einen schon graue Haare kosten, wenn man nicht genau versteht, was da passiert und wenn man keine Hilfen hat. Da gibt es zum einen schon einmal zwei verschiedene Typen von Rotary-Elemente, welche unterschiedlich programmiert werden. Und da man den Rotary-Elementen so leicht nicht ansehen kann, zu welchem Typ sie gehören, hilft hier nur ausprobieren.

Doch zuerst einmal, was ist ein Rotary-Element und für was kann es in der F-16 verwendet werden? Ein Rotary-Element ist ein in beiden Richtungen endlos drehbarer Knopf, welcher beim Drehen in die ein- oder andere Richtung Impulse ausgiebt. In der F-16 befinden sich z.B. zwei Rotary-Elemente auf dem HSI zum Einstellen von "Course" und "Heading".

Um überhaupt ein Rotary-Element am Rotary-Modul zum Laufen bringen zu wollen, muß die Datei MAKEBTN.DAT angepasst werden. Dort müssen folgende Zeilen angehängt werden:

700 BUTTON700      0    1    7
701 BUTTON701      0    2    7
702 BUTTON702      0    4    7
703 BUTTON703      0    8    7
704 BUTTON704      0   16    7
705 BUTTON705      0   32    7
706 BUTTON706      0   64    7
707 BUTTON707      0  128    7
708 BUTTON708      1    1    7
709 BUTTON709      1    2    7
710 BUTTON710      1    4    7
711 BUTTON711      1    8    7
712 BUTTON712      1   16    7
713 BUTTON713      1   32    7
714 BUTTON714      1   64    7
715 BUTTON715      1  128    7
716 BUTTON716      2    1    7
717 BUTTON717      2    2    7
718 BUTTON718      2    4    7
719 BUTTON719      2    8    7
720 BUTTON720      2   16    7
721 BUTTON721      2   32    7
722 BUTTON722      2   64    7
723 BUTTON723      2  128    7
724 BUTTON724      3    1    7
725 BUTTON725      3    2    7
726 BUTTON726      3    4    7
727 BUTTON727      3    8    7
728 BUTTON728      3   16    7
729 BUTTON729      3   32    7
730 BUTTON730      3   64    7
731 BUTTON731      3  128    7

Anschliessend müssen diese Änderungen mit dem Programm MAKEBTN.EXE aktiviert werden. Der Anschluss des Rotary-Elementes an das Rotary-Moodul von EPIC ist gemäß der zum Rotary-Modul mitgelieferten Handzettel relativ einfach zu erledigen. Nun müssen wir nur noch mit TEST128.EXE in Modul 7! (Rotaries liegen hier) die Nummern des angeschlossenen Rotary-Elementes herausginden. Auch hier bekommen wir für jede Drehrichtung des Rotary-Elementes eine Nummer geliefert. In unserem Beispiel gehen wir davon aus, dass wir die Nummern "700" für Linksdrehen und "701" für Rechtsdrehen bekommen. In unserem Beispiel wollen wir mit diesem Rotary-Element den "Heading"-Knopf am HSI programmieren.

Gut, jetzt sind wir Startbereit für die Programmierung des 1. Typen. Diese sieht wie folgt aus:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 8)
DefineModule(0, LOWSCAN,  8, 8)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)
DefineModule(7, FASTSCAN, 0, 8)

:INIT { Reset SendData(7, 0, 1) }

:HSIHeadingInc { KeyPress(CTRL) AltHit(m) KeyRelease(CTRL) }
:HSIHeadingDec { KeyPress(CTRL) AltHit(n) KeyRelease(CTRL) }

DefineButton(700, ON,  HSIHeadingDec)
DefineButton(700, OFF, HSIHeadingDec)
DefineButton(701, ON,  HSIHeadingInc)
DefineButton(701, OFF, HSIHeadingInc)

Mit dem Befehl "SendData(7, 0, 1)" wird das 1. Rotary-Element auf den Typ 1 gesetzt. Zu beachten ist hierbei, dass das Rotary-Modul (7) besser mit hoher Priorität von EPIC gescannt wird, daher habe ich hier die ersten 8 Rows des 7. Modules mit "DefineModule(7, FASTSCAN, 0, 8)" auf schnelles Scannen gesetzt.

Und hier nun das gleiche Beispiel mit dem zweiten möglichen Typen eines Rotary-Elementes:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 8)
DefineModule(0, LOWSCAN,  8, 8)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)
DefineModule(7, FASTSCAN, 0, 8)

:INIT { Reset SetPoint(7,0,0b00000001) }

:HSIHeadingInc { KeyPress(CTRL) AltHit(m) KeyRelease(CTRL) }
:HSIHeadingDec { KeyPress(CTRL) AltHit(n) KeyRelease(CTRL) }
:HSIHeading    { ifactive(701) jump HSIHeadingDec else jump HSIHeadingInc }

DefineButton(700, ON,  HSIHeading)
DefineButton(700, OFF, HSIHeading)


Ansteuerung einer LED per Kippschalter

Ein LED über die EPIC anzusteuern ist mit Hilfe des Output-Modules von EPIC eine Kleinigkeit. Über ein Output-Modul können biz zu 32 Schaltkreise über ein EPIC- Programm geschlossen und wieder geöffnet werden. Was man hinter diese Schaltkreise hängt, bleibt jedem selbst überlassen. Es könnten LEDs sein, Lüftungsmotoren, Scheinwerfer und vieles mehr sein. Der Anschluß einer LED an ein Output-Modul ist relativ einfach. Die Spannungsversorgung eines Output-Modules beträgt 12 Volt. Wenn mann will, kann man diese 12 Volt auch als Spannungsversorgung für an das Output-Modul angeschlossene Lampen etc. verwenden. Bei einer LED müssen wir hier aber noch ein paar Widerstände dazwischen löten. LEDs eignen sich besser als Leuchtmittel in einem F-16 Simulator, da hier auch bei mehreren brennenden LEDs der Stromverbrauch noch sehr gering ist.

Ein wenig aufwendiger wird es, die Nummer des an das Output-Modul angeschlossenen LED zu ermitteln. Leider geht dies nicht mit dem Programm TEST128.EXE, sodass wir uns hier mit Hilfsprogrammen zum Ermitteln der Nummern herumärgern müssen. Gehen wir für unser Beispiel mal davon aus, dass die angeschlossene LED das ECM-Light räpresentieren soll und die Nummer "2" des 5. Output-Rows ist. Nummern von Output-Kanälen werden in EPIC binär codiert, sodass die Nummer unserer LED wie folgt geschrieben wird: 0,5,0b00000010. Diese Nummer ist nicht ganz leicht zu verstehen, deshalb werden wir sie per DEFINE-Befehl einem sprechenden Namen zuordnen:

#define LED_ECM  0,5,0b00000010

In unserem Beispiel werden wir diese LED bei Aktivierung des ECM per Kippschalter ein- und bei Deaktivierung wieder ausschalten. Das sieht wie folgt aus:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

#define LED_ECM  0,5,0b00000010

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset }

:ECMOn  { KeyHit(j) SetPoint(LED_ECM) }
:ECMOff { KeyHit(j) ClearPoint(LED_ECM) }

DefineButton(192, ON,  ECMOn)
DefineButton(192, OFF, ECMOff)

Wie man sieht, kann man mit "SetPoint()" die LED zum Leuchten bringen und mit "ClearPoint()" wieder löschen. Nun hat unser Programm noch eine kleine Schwäche. Wenn der Kippschalter auf "On" steht, wenn wir das Programm zur EPIC-Card uploaden, so bleibt die LED aus. Wenn wir es schöner finden, die LED in diesem Falle gleich einzuschalten, so sieht unser Programm so aus:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

#define LED_ECM  0,5,0b00000010

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset ifactive(192) Call LED_ECMOn }

:LED_ECMOn  { SetPoint(LED_ECM) }
:LED_ECMOff { ClearPoint(LED_ECM) }

:ECMOn  { KeyHit(j) Call(LED_ECMOn) }
:ECMOff { KeyHit(j) Call(LED_ECMOff) }

DefineButton(192, ON,  ECMOn)
DefineButton(192, OFF, ECMOff)

Hier habe ich nun zwei Functionen mit Namen "LED_ECMOn" und "LED_ECMOff" hinzugefügt, die jetzt das Ein- und Ausschalten der ECM LED übernehmen. In der INIT-Function, welche beim ersten Upload zur EPIC-Card ausgeführt wird, wird nun überprüft, ob der ECM-Kippschalter auf ON steht (Nummer "192"). Ist dies der Fall, so wird die Function zum Einschalten der dazugehörigen LED aufgerufen. Thats all.


Ansteuerung einer LED über QProcs

Im obigen Beispiel haben wir eine LED direkt bei Betätigen des dazugehörigen Kippschalters aktiviert. Ein anderer und wesentlich eleganterer Weg ist das Ein- und Ausschalten einer LED über eine direkte Schnittstelle zwischen der EPIC-Card und dem verwendeten Flugsimulatorprogramm. Hierzu benötigen wir jedoch ein spezielles Schnittstellenprogramm, welches Daten von dem Flugsimulator auslesen und weitergeben kann. Für Falcon habe ich das Programm F4-Reader geschrieben, welches auch kostenlos zum Download zur Verfügung steht.

Im Programm F4-Reader gibt es nun zwei Möglichkeiten, Daten von LEDs u.ä. an die EPIC-Card zu senden. Die erste und etwas einfachere Art wollen wir hier behandeln. Es ist die Kommunikation über sogenannte QProcs. Hierbei wird eine Kanalnummer definiert, die für das Ein- oder Ausschalten einer LED genutzt werden soll. In unserem Beispiel gehen wir davon aus, das die Kanalnummer "20" zum Einschalten und die Kanalnummer "21" zum Ausschalten der ECM-LED genutzt wird. Welche Kanalnummern für welche LED verwendet wird, kann beliebig im F4-Reader definiert werden.

Und hier nun das dazugehörige Programm:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

#define LED_ECM  0,5,0b00000010

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

:INIT { Reset }

:LED_ECMOn  { SetPoint(LED_ECM) }
:LED_ECMOff { ClearPoint(LED_ECM) }

DefineQProc(20, LED_ECMOn)
DefineQProc(21, LED_ECMOff)

Mit dem Befehl "DefineQProc()" wird hierbei die Funktion angegeben, welche bei Aktivieren des entsprechenden QProcs angesprungen werden soll.


Ansteuerung von LEDs über Pigeon-Holes

Wie wir in dem obigen Beispiel gesehen haben, ist die Ansteuerung von LEDs über QProcs kein allzu grosses Problem. Wenn wir aber eine Reihe von Zuständen von LEDs über das Schnittstellenprogramm F4-Reader an die EPIC-Card senden wollen, so wird das Programm schon etwas umfangreicher. Ebenfalls haben QProcs den Nachteil, dass - wenn viele Zustandsänderungen von LEDs gleichzeitig zusammentreffen, EPIC sich hierbei verschluckt und eine Reihe von QProcs nicht bearbeitet werden. Abhilfe schafft hier die Verwendung von sogenannten Pigeon-Holes. Leider ist dieser Begriff in der EPIC-Dokumentation nicht beschrieben und auch Beispiele sucht man vergebens. Daher hier ein kleiner Ausflug in die Programmierung mit Pigeon-Holes.

Mit einem QProc kann nur eine digitale Information übertragen werden. Wenn man nun aber einen analogen Wert per Schnittstelle übertragen will (z.B. Geschwindigkeit, Höhe etc.), so kann man dies über Pigeon-Holes tun. Über ein Pigeon-Hole können gleichzeitig vier analoge Werte von 0 bis 255 an die EPIC-Card übertragen werden. Wir können uns dies zunutze machen, um z.B. über ein Pigeon-Hole gleichzeitig 32 LED Zustände übertragen zu können (4 x 8Bit = 32).

Wir wollen in unserem Beispiel einmal davon ausgehen, dass wir alle LED-Zustände des Caution Panels gleichzeitig per Pigeon-Holes übertragen wollen. Wir haben zuvor alle 32 Caution Lights des Caution Paneles an ein Output-Modul angeschlossen. Nun müssen wir im Programm F4-Reader alle Caution Lights den entsprechenden Bits eines Pigeon-Holes zuordnen. Wir wählen hierzu das Pigeon-Hole mit der Nummer "10". Die binäre Zuordnung auf die einzelnen Rows bzw. PH-Indexe im F4-Reader erfolgt analog zur Zuordnung auf dem Output-Modul. Das z.B. 12. LED auf dem Output-Modul würde ja das Bit 3 auf dem 1. Output-Row sein (=0,1,0b00001000). Somit wäre diese LED Bit 3 des 1. PH-Indexes. Zu kompliziert? Ich glaube ja, daher hier einmal das ganze 1. Output-Modul mit der entsprechenden Zuordnung im F4-Reader:

LED-#Row-#Bit-#EPIC-CallPH-IndexBit(s)s to send
1000,0,0b00000001000000001
2010,0,0b00000010000000010
3020,0,0b00000100000000100
4030,0,0b00001000000001000
5040,0,0b00010000000010000
6050,0,0b00100000000100000
7060,0,0b01000000001000000
8070,0,0b10000000010000000
9100,1,0b00000001100000001
10110,1,0b00000010100000010
11120,1,0b00000100100000100
12130,1,0b00001000100001000
13140,1,0b00010000100010000
14150,1,0b00100000100100000
15160,1,0b01000000101000000
16170,1,0b10000000110000000
17200,2,0b00000001200000001
18210,2,0b00000010200000010
19220,2,0b00000100200000100
20230,2,0b00001000200001000
21240,2,0b00010000200010000
22250,2,0b00100000200100000
23260,2,0b01000000201000000
24270,2,0b10000000210000000
25300,3,0b00000001300000001
26310,3,0b00000010300000010
27320,3,0b00000100300000100
28330,3,0b00001000300001000
29340,3,0b00010000300010000
30350,3,0b00100000300100000
31360,3,0b01000000301000000
32370,3,0b10000000310000000

So, wenn wir jetzt einmalig die Zuordnung im Programm F4-Reader vorgenommen haben, können wir an das eigendliche EPIC-Programm gehen. Dieses sieht so aus:

#define FASTSCAN 0
#define LOWSCAN  1
#define OUTPUT   2

DefineModule(0, FASTSCAN, 0, 16)
DefineModule(1, LOWSCAN,  0, 16)
DefineModule(2, LOWSCAN,  0, 16)

#macro GetPH8(bytev, phnum)
       pushc(phnum)
       exec(67)
       popv8(bytev)
#endmac

VAR(Var_PHoles)       ; 8-Bit Hilfs-Variable deklarieren

:INIT { Reset }

:PH_OutputM0 {
       #expand getPH8(Var_PHoles, 0x000A)
       ClearPoint(0, 0, 0b11111111)
       SetPoint(0,   0, Var_PHoles)

       #expand getPH8(Var_PHoles, 0x010A)
       ClearPoint(0, 1, 0b11111111)
       SetPoint(0,   1, Var_PHoles)

       #expand getPH8(Var_PHoles, 0x020A)
       ClearPoint(0, 2, 0b11111111)
       SetPoint(0,   2, Var_PHoles)

       #expand getPH8(Var_PHoles, 0x030A)
       ClearPoint(0, 3, 0b11111111)
       SetPoint(0,   3, Var_PHoles)
}

DefinePH(10, PH_OutputM0, 0, 0, 0, 0)

Das ist alles. Was auffällt, ist das definierte Macro "GetPH8", welches einen 8 Bit-Wert aus dem Pigeon-Hole Speicher liest. Dieses Macro ist normalerweise in der mitgelieferten Include-Datei EpicVXD.inc enthalten. Ich habe es jedoch zur besseren Übersicht mit in das obige Programm aufgenommen.

Als nächstes erfolgt die Deklaration einer Hilfsvariablen mit Namen "Var_PHoles", über die wir später die Werte aus dem Pigeon-Hole auslesen werden.

Dann folgt eine Function für die Abarbeitung des kompletten 1. Output-Modules (Nr. 0). Dort wird für jedes Output-Row der dazugehörige Pigeon-Hole Wert gelesen. Dann werden mit einem Schlag alle LEDs des entsprechenden Rows gelöscht und anschliessend gemäss der Übergabe neu gesetzt. Das komplette Löschen und anschliessende Aktualisieren eines Output-Rows geht dermaßen schnell, dass man es mit dem Auge nicht mitbekommt, zumal diese Function nur dann angesprochen wird, wenn es tatsächlich eine Veränderung in einem der 4 Pigeon-Hole Werte gegeben hat.

Mit "DefinePH" wird wie oben gewünscht das 10. Pigeon-Hole der Function "PH_OutputM0" zugewiesen. Das war's schon ;-)


 Home  Simulator  Ansteuerung  EPIC(c) by Martin "Pegasus" Schmitt