General
Banner
Home | Artikelen | English

 

Basis vaardigheden voor cockpitbouwers.

Interface programma tussen Flight Simulator en cockpit hardware maken.

Deel 1: Uitlezen en wegschrijven van waarde in FS.

Voorwoord | Benodigde software | Voorkennis | Uitlees programma | Schrijf programma

Voorwoord.

Dit onderwerp is waarschijnlijk iets waar al vele mensen zich vragen hebben over gesteld. Geen eenvoudige materie om even in drie woorden uit te leggen. We gaan eerst de basis uitleggen hoe je varaibelen kan uitlezen uit FS en schrijven naar FS via de SDK for programmers van FSUIPC (system development kit van Fligh Simulator Universal Inter-Process communication) van Peter Dowson. Daarna gaan we deze kennis gebruiken om dit te koppelen aan de hardware interface K8061 om zo een schakelaar aan te sturen. Als tweede interface gaan we gebruik maken van een seriële communicatie naar een zelfbouw instrument. Zo belichten we het twee richting verkeer naar en van de cockpit.

Vooreerst ben ik zelf geen programmeur. Alle kennis die ik hiervan heb komt enkel door zelfstudie. Ik heb mij ooit eens een dik boek genaamd "Het boek Visual Basic 5" van Easy computing aangeschaft, een kanjer van 1370 bladzijden en ben hiermee aan de slag gegaan. Dit boek geeft een goede basis kennis en heeft mij al veel geholpen bij het oplossen van problemen. Ook heb ik hulp gekregen van twee collega's van de Flight Simulator club Belgium die mij in het begin op weg hebben geholpen. Eenmaal je een beetje de basis door hebt kan je zelf iets in elkaar gaan steken waarmee je op een directe manier dingen in FS kunt gaan uitlezen en schrijven. Ik zal trachten deze materie op een eenvoudige manier uit te leggen met een aantal voorbeelden. Om een algemeen idee te krijgen hoe je schakelaars kan koppelen met FS verwijs ik graag naar artikel 9 waar hierover een heel relaas wordt gedaan.

Top

Benodigde software.

Aangezien we in Visual Basic gaan programeren heb je Microsoft Visual Basic 6 of 5 nodig. Alle voorbeelden beschreven in dit artikel zijn enkel van toepassing op versie 6.

Verder gaan we gebruik maken van FSUIPC.dll. Deze verbindingsmodule voor MSFS wordt in de folder 'module' van flight simulator geplaats en dient als tussenstap om varaibelen te kunnen uitlezen en schrijven met de FSUIPC SDK for programmers. In de pagina links vind je de site waar je de software kan downloaden en registeren. Zonder deze dll is er geen communicatie mogelijk tussen deze twee. Er zijn uiteraard nog andere mogelijkheden om met FS te gaan communiceren maar deze zijn te complex en ook niet universeel. Daarom hou ik mij enkel bij FSUIPC. Deze dll bevat natuurlijk ook al een windows based programma op zich waarmee je zowat alle parameters in FS kan gaan sturen maar van deze mogelijkheid gaan we geen direct gebruik maken. We gaan zelf een eigen windows based programma in elkaar steken dat dezelfde functies aan kan maar dan custom made en enkel voor die dingen die we nodig hebben en die gekoppeld gaan worden aan externe elektronica.

FSUIPC System Developer Kit (SDK for programmers). Deze bevat de module (FSUIPC.bas) die we nodig hebben om met de FSUIPC dll te kunnen communiceren in Visual basic.

K8000 visual basic module. Aangepaste versie voor Windows XP om een verbinding tot stand te brengen met de IO card van Velleman. Deze module heb ik wel zelf aangepast om gebruikt te kunnen maken van 128 bits in plaats van de oorspronkelijke 64 bits. Normaal kan je deze kaart maar uitbreiden tot 4 kaarten (1 master en 3 slaves) maar door gebruik te maken van een andere I²C chip PCF8574P ipv PCF8574AP kan je deze kaarten nog eens uitbreiden met 4 kaarten. Zodat je in totaal 128 uit- of ingangen kan gaan sturen. Deze module kan je terug vinden onder de rubriek downloads.

DlportIO.dll. Deze objectbibliotheek dient om de parrallelpoort te kunnen aansturen onder Windows XP. Deze dll hebben we dus enkel nodig wanneer we met de K8000 willen gaan werken. Voor seriële communicatie hebben we dit niet nodig.

Top

Voorkennis van Visual Basic.

Enige voorkennis van Visual basic is wel aan te raden maar is geen noodzaak om toch tot een eindresultaat te komen. Ik zou je wel aanraden een degelijk boek in eigen taal aan te schaffen. Het bovenvermelde boek "Het boek Visual Basic 5" is een uitstekend boek om basiskennis op te doen. Het zal ook wel bestaan voor Visual Basic 6. U begrijpt dat ik hier niet elke basis handeling uitgebreid kan behandelen. Dit zou een boek op zich worden. Maar Visual Basic is vrij goed begrijpbaar. Het maken van een formulier met daarop enkele knoppen en het toevoegen van een module aan een project is vrij snel te leren.

Top

Uitlezen van variabelen uit Flight Simulator.

We starten met een nieuw project in VB en zullen dit ReadFS noemen. We maken hierin een formulier voorzien van twee knoppen, een combobox en een labelveld met frame om de uitgelezen waarden in te tonen. Het project bevat eveneens twee modules namelijk FSUIPC.bas (de basis module van de FSUIPC SDK) en een MdlRead.bas (zelf geprogrammeerde basis module voor uitlezing van FS gegevens) Het programma voorbeeld kan je vinden bij downloads. Je kan dit openen in VB en zo een beter inzicht krijgen in het programma.

De initialisatie van FSUIPC en het openen ervan gebeurt wanneer we de button "Start FSUIPC" aan klikken. Met deze stap gaan we kijken of FS reeds opgestart is. Het leest uit welke versie actief is en stuurt dit naar de label 'lblFSUIPCcon'. Indien er geen connectie kan gemaakt worden krijgen we een messagebox met daarop de foutmelding waarom er geen verbinding kan gemaakt worden. Eenmaal FSUIPC geopend is kunnen we de Read en/of write procedures gebruiken. In ons voorbeeld gaan we enkel gebruik maken van de read functie.

In de module MdlRaed.bas zie je voorbeelden van hoe we een read procedure maken.
De basis is altijd dezelfde. We benoemen eerst een aantal globale varaibelen die we buiten de subroutine en module kunnen gebruiken.
Voorbeeld:
Public All_LigHt As Integer
De lengte van de variabele wordt bepaald door de lengte van het resultaat van de gekozen offset. De lengtes van de verschillende offsets en de functie ervan kan je terug vinden in de bijhorende tabellen van de FSUIPC SDK.
Vervolgens voegen we een Publieke procedure toe die we ook buiten de module kunnen aanroepen.
Binnen deze subroutine benoemen we de interne variabelen die we enkel binnen de subroutine kunnen gebruiken.
Voorbeeld:
Dim booResult As Boolean
Dim dwOffset As Long
Dim dwSize As Long
Dim dwResult As Long
Dim Light As Integer

De waarde van de offset is terug te vinden in de tabel van de SDK (light = 0D0C).
De lengte van de offset wordt als volgende type benoemd. (light = 2)

1 as byte
2 as integer
4 as long
8 as double

Vervolgens roepen we de FSUIPC Read procedure aan en geven het offset nummer mee samen met de lengte van de offset.
We krijgen het resultaat terug uit FSUIPC na de procedure FSUIPC_Process . Dit gaat als volgt

dwOffset = (&HD0C)
dwSize = Len(Light)
If FSUIPC_Read(dwOffset, dwSize, VarPtr(Light), dwResult) Then
If FSUIPC_Process(dwResult) Then
All_LigHt = Light
End If
End If

Deze manier van uitlezen is heel goed voor het uitlezen van een enkele offset. Om testen me te doen of om snel te zien wat voor resultaten uit een bepaalde variabele komen. Indien je echter meerdere offsets gelijktijdig wil uitlezen is deze manier van werken niet zo geschikt omdat je teveel tijd verliest met het uitvoeren van de procedure FSUIPC_Process . De volgende werkwijze is dan aan te raden.

'read Land Lights
dwOffset = (&HODC)
dwSize = Len(Light)
booResult = FSUIPC_Read(dwOffset, dwSize, VarPtr(Light), dwResult)
'read Flap position
dwOffset = (&HBE0)
dwSize = Len(strFlapPos)
booResult = FSUIPC_Read(dwOffset, dwSize, VarPtr(strFlapPos), dwResult)

booResult = FSUIPC_Process(dwResult)

All_Light = Light
Flap_pos = strFlapPos

Met deze manier van werken moet je maar éénmaal de procedure FSUIPC_Process aanroepen terwijl je alle offset met lengte die je wenst uit te lezen in een keer meegeeft. Dit verhoogd de snelheid van uitlezen aanzienlijk. Zeker met een ganse reeks offsets.

Bij het sluiten van het formulier moet je er wel steeds voor zorgen dat FSUIPC wordt afgesloten. Dit om te voorkomen dat je bij een volgende sessie een foutmelding krijgt dat FSUIPC nog open staat en je geen nieuwe verbinding kan maken. Of een andere applicatie die ook gebruik maakt van FSUIPC ook geen verbinding kan maken. Dit gebeurt in de subroutine Form_terminate.

Top

Schrijven van variabelen naar Fligth Simulator:

We geven altijd wel de voorkeur om inputs naar FS via de joystick buttons te doen maar soms is het ook handig om een andere weg te bewandelen. Ik heb hiervoor zelf de K8000 van Velleman gebruikt. In dit voorbeeld gaan we eerst even kijken hoe we waarden naar FS kunnen gaan schrijven. Om de zaken een beetje duidelijk te houden zullen we in een ander deel de koppeling tussen de schakelaars verbonden aan de K8000 en de computer toelichten. Hierbij maken we eigenlijk gewoon een koppeling tussen het schrijf- en leesprogramma en het VB programma van de K8000. Maar dit voor later.

We starten een nieuw project in VB genaamd WriteFS. In dit project gaan we toelichten hoe je waarden kan wegschrijven in FS via FSUIPC offsets. Tweede mogelijke wijze om waarden in FS te wijzigen is het sturen van keycodes. (vb.: F7 Flaps down). Het programma bestaat uit een formulier en twee modules. Ten eerste de FSUIPC.bas, ten tweede een zelfgemaakte mdlWrite.bas. Het programma voorbeeld kan je vinden bij downloads. Je kan dit openen in VB en zo een beter inzicht krijgen in het programma.

De initialisatie van FSUIPC en het openen ervan gebeurt wanneer we de button "Start FSUIPC" aan klikken. Met deze stap gaan we kijken of FS reeds opgestart is. Het leest uit welke versie actief is en stuurt dit naar de label 'lblFSUIPCcon'. Indien er geen connectie kan gemaakt worden krijgen we een messagebox met daarop de foutmelding waarom er geen verbinding kan gemaakt worden. Eenmaal FSUIPC geopend is kunnen we de Read en/of Write procedures gebruiken. In ons voorbeeld gaan we enkel gebruik maken van de Write functie.

In de module mdlWrite zitten twee voorbeelden van subroutines. Het eerste voorbeeld laat zien hou we via een keycode een waarde naar FS kunnen sturen. Een tweede voorbeeld zal ons tonen hoe we via een Offset een waarde naar FS sturen.

Keycode voorbeeld:

'Write example keycode (function code F7 flaps down one step,max 4)
Public Sub Flap_down()
Static strFlp

If strFlp < 4 Then
AppActivate (FSversie)
SendKeys "{F7}"
WaiT (0.5)
strFlp = strFlp + 1
End If

End Sub

De variabele strFlp benoemen we als statisch (Static). Deze behoud zijn waarde telkens hij opnieuw wordt geladen. Dit is vooral handig voor het tellen van het aantal keer deze taak is uitgevoerd.
Vervolgens roepen we het programma op waar we een keycode naar toe willen schrijven om er zeker van te zijn dat de focus op dit programma ligt en niet op een ander, waar deze keycode niet voor bedoeld is. Dit doen we met de procedure AppActivate(Title,[wait]). Tussen de haakjes geven we de naam (titel) mee van het programma dat geopend moet worden. In mijn voorbeeld zet ik hier de variabele FSversie in. De waarde van deze variabele wordt bepaald bij het opstarten van het programma door de routine FSversie_controle die ook in de module mdlwrite staat. Deze wordt uitgevoerd op het moment dat we een verbinding maken met FSUIPC. Te vinden in code van het formulier frmWriteFs onder de subroutine cmdConnect_Click. Afhankelijk van de gebruikte FS versie geeft dit een verschillende titel. In mijn geval is dit "Microsoft Flight Simulator 2004".
Hierna zenden we een Keycode met de procedure Sendkeys string al naar gelang je een enkele letter of cijfer of speciale toets wil sturen is de tekst die je tussen de aanhalingstekens zet anders. De verschillende mogelijkheden kan je altijd terug vinden in de hulpfiles van VB. Voor een kleine letter of cijfer is dit eenvoudig weg bijvoorbeeld "A" voor een functietoets is dit bijvoorbeeld "{F7}". Voor alle andere speciale toetsen en gecombineerde toetsen verwijs ik naar de hulpfile.
Na het zenden van de keycode wachten we een halve seconde alvorens verder te gaan met het stuurprogramma om FS de kans te geven deze keycode te verwerken. Uit ervaring is gebleken dat dit een noodzakelijke stap is want soms wordt deze keycode niet uitgevoerd als we te snel zijn. In ons huidige write programma zou dit wel niet nodig zijn maar vanaf we via een interne timer ons besturingsprogramma gaan laten beheren zal dit wel een must zijn.
Als laatste stap tellen we bij de variable strFlp, 1 op. Als deze kleiner dan 4 is kunnen deze routine blijven uitvoeren. Van zodra hij 4 is stop de uitvoering ervan. Zo kunnen we verhinderen dat we meer dan 4 maal de flaps kunnen aansturen.

Vrij eenvoudig met enkele instructies kan je dus keycodes naar een bepaald applicatie sturen.

Offset voorbeeld:

Dit zit wel iets ingewikkelder in elkaar en bestaat uit twee stappen verdeeld over een basis deel in de module mldWriteFs en het uitvoerend gedeelte in formulier frmWriteFs.

We bekijken eerst de subroutine in de module genaamd LL2

Public Sub LL2()

Deze is een beetje gelijkaardig opgebouwd als de Read subroutine. We benoemen eerst de interne variabelen
Dim booResult As Boolean
Dim dwOffset As Long
Dim dwSize As Long
Dim dwResult As Long
Dim LL2 As Byte

Vervolgens geven de LL2 een waarde 1 (landing lichten aan = 1 of uit = 0). De in te geven waarde kan je terug vinden in de lijst met offsets in de SDK van FSUIPC.
LL2 = 1

Hierna kennen we de hexadecimale offset nummer toe van de variabele waar we de bovenvermeld waarde willen naar toe schrijven. Samen met de lengte van deze waarde. Voor de lengte verwijs ik terug naar het lees gedeelte
dwOffset = (&H28C)
dwSize = Len(LL2)

Als laatste stap roepen we FSUIPC_write procedure aan en geven de verschillende waarde van de offset door.
booResult = FSUIPC_Write(dwOffset, dwSize, VarPtr(LL2), dwResult)
End Sub

Zoals je bemerkt gaan we niet over tot de uitvoeren van de procedure FSUIPC_process. Ook om dezelfde reden als bij het uitlezen van waarde gaan we gelijktijdig al deze waarde wegschrijven om zo tijd te winnen. Deze tweede stap gebeurt in het formulier gedeelte in de subroutine Write_FSUIPC

Public Sub Write_FSUIPC()

We benoemen ook hier eerst weer de interne variabelen
Dim booResult As Boolean
Dim dwResult As Long

Vervolgens roepen we de verschillende subroutines aan waarnaar we gegevens wens te schrijven. Uiteraard kan dit gekoppeld gaan met een aantal voorwaarden. Bijvoorbeeld een schakelaar moet aan staan. Dit zien we verder nog wel als we de K8000 gaan koppelen. In ons voorbeeld hebben we maar 1 offset die verandert moet worden namelijk LL2. We roepen deze op met opdracht Call. Hierdoor gaat het programma naar de subroutine LL2 in de module mdlWriteFs, voert daar alle stappen uit.
Call LL2

Vervolgens geven we de opdracht om alle waarde weg te schrijven naar FS. Dit kan uiteraard ook samengaan met het uitlezen van waarden uit FS.
booResult = FSUIPC_Process(dwResult)

Zo eenvoudig is het om waarden te wijzigen in FS via FSUIPC.

 

Top

< Vorige | Home | Artikelen | Volgende >

 

© Verley Jan 2007-2017