SimConnect

[Patrice Terrier]

This thread is dedicated to the Flight Simulator SimConnect API,
and the specific C++ 64-bit VS2019 SIM.dll project.

Here is the code of SIM.dll (the full VS2019 project is attached to this post)


// dllmain.cpp : Defines the entry point for the DLL application.
#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
// Windows Header Files
#include <windows.h>

#include <tchar.h>
#include <stdio.h>
#include <strsafe.h>

#include "Tools.h"
#include "simconnect.h"
#include "Sim.h"

struct PROP {
    int     quit = 0;
    HWND    hParent = 0;
    HANDLE  hSimConnect = NULL;
    char    zaf[MAX_PATH] = { 0 };
    WCHAR   ZAF[MAX_PATH] = { 0 };
};

static PROP gP;

struct Struct1 {
    char    title[256];
    double  kohlsmann;
    double  altitude;
    double  latitude;
    double  longitude;
};
 
enum EVENT_ID{
    EVENT_SIM_START,
};
 
enum DATA_DEFINE_ID {
    DEFINITION_1,
};
 
enum DATA_REQUEST_ID {
    REQUEST_1,
};
 
void CALLBACK MyDispatchProcRD(SIMCONNECT_RECV* pData, DWORD cbData, void *pContext) {
 
    switch(pData->dwID)     {
 
        case SIMCONNECT_RECV_ID_SIMOBJECT_DATA:
        {
            SIMCONNECT_RECV_SIMOBJECT_DATA* pObjData = (SIMCONNECT_RECV_SIMOBJECT_DATA*)pData;
 
            switch (pObjData->dwRequestID)
            {
            case REQUEST_1:
            {
                DWORD ObjectID = pObjData->dwObjectID;
                Struct1* pS = (Struct1*)&pObjData->dwData;
                if (SUCCEEDED(StringCbLengthA(&pS->title[0], sizeof(pS->title), NULL))) { // security check

                    StringCchPrintfA(gP.zaf, strSize(gP.zaf), "ObjectID=%d  Title=\"%s\"\nLat=%f  Lon=%f  Alt=%f  Kohlsman=%.2f", ObjectID, pS->title, pS->latitude, pS->longitude, pS->altitude, pS->kohlsmann);
                    MultiByteToWideChar(CP_ACP, 0, gP.zaf, lstrlenA(gP.zaf), gP.ZAF, MAX_PATH);
                    zTrace(gP.ZAF);

                    if (IsWindow(gP.hParent)) {
                        PostMessage(gP.hParent, WM_USER + SIMCONNECT_RECV_ID_SIMOBJECT_DATA, NULL, (LPARAM) pS);
                    }
                }
                break;
            }
 
            default:
                break;
            }
            break;
        }
 
        case SIMCONNECT_RECV_ID_QUIT:
        {
            gP.quit = 1;
            break;
        }
 
        default:
            StringCchPrintfA(gP.zaf, strSize(gP.zaf), "Received:%d",pData->dwID);
            MultiByteToWideChar(CP_ACP, 0, gP.zaf, lstrlenA(gP.zaf), gP.ZAF, MAX_PATH);
            zTrace(gP.ZAF);
            break;
    }
}
 
//void testDataRequest() {
//
//    if (SUCCEEDED(SimConnect_Open(&gP.hSimConnect, "Request Data", NULL, 0, 0, 0))) {
//        zTrace(L"Connected to Flight Simulator!");
//
//        HRESULT hr;
//        // Set up the data definition, but do not yet do anything with it
//        hr = SimConnect_AddToDataDefinition(gP.hSimConnect, DEFINITION_1, "Title", NULL, SIMCONNECT_DATATYPE_STRING256);
//        hr = SimConnect_AddToDataDefinition(gP.hSimConnect, DEFINITION_1, "KOHLSMAN SETTING MB", "Millibars");
//        hr = SimConnect_AddToDataDefinition(gP.hSimConnect, DEFINITION_1, "INDICATED ALTITUDE", "feet");
//        hr = SimConnect_AddToDataDefinition(gP.hSimConnect, DEFINITION_1, "Plane Latitude", "degrees");
//        hr = SimConnect_AddToDataDefinition(gP.hSimConnect, DEFINITION_1, "Plane Longitude", "degrees");
//
//        // Request an event when the simulation starts
//        // Didier : j'ai mis les // juste en dessous Cela arrête la détection de lancement du simulateur et c'est inutile dans mon code
//        // hr = SimConnect_SubscribeToSystemEvent(hSimConnect, EVENT_SIM_START, "SimStart");
//
//        hr = SimConnect_RequestDataOnSimObject(gP.hSimConnect, REQUEST_1, DEFINITION_1, SIMCONNECT_SIMOBJECT_TYPE_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
//
//        zTrace(L"Launch a flight.");
//
//
//        for ( ;; ) {
//            if (gP.quit) break;
//            SimConnect_CallDispatch(gP.hSimConnect, MyDispatchProcRD, NULL);
//            Sleep(1);
//        }
//
//        hr = SimConnect_Close(gP.hSimConnect);
//    }
//}

//// Patrice
//BOOL Sim_Connect(HWND hParent) { // dllexport
//    BOOL bRet = FALSE;
//    if (IsWindow(hParent)) {
//        gP.hParent = hParent;
//        testDataRequest();
//        bRet = TRUE;
//    }
//    return bRet;
//}
// Patrice
void Sim_Quit() { // dllexport
    gP.quit = 1;
}
// Patrice
HRESULT Sim_AddToDataDefinition(HANDLE hSimConnect, SIMCONNECT_DATA_DEFINITION_ID DefineID, const char * DatumName, const char * UnitsName, DWORD DatumType, float fEpsilon, DWORD DatumID) { // dllexport
    HRESULT hr = SimConnect_AddToDataDefinition(hSimConnect, DefineID, DatumName, UnitsName, (SIMCONNECT_DATATYPE) DatumType, fEpsilon, DatumID);
    return hr;
}
// Patrice
HRESULT Sim_RequestDataOnSimObject(HANDLE hSimConnect, SIMCONNECT_DATA_REQUEST_ID RequestID, SIMCONNECT_DATA_DEFINITION_ID DefineID, SIMCONNECT_OBJECT_ID ObjectID, DWORD Period, SIMCONNECT_DATA_REQUEST_FLAG Flags, DWORD origin, DWORD interval, DWORD limit) { // dllexport
    HRESULT hr = SimConnect_RequestDataOnSimObject(hSimConnect, RequestID, DefineID, ObjectID, (SIMCONNECT_PERIOD) Period, Flags, origin, interval, limit);
    return hr;
}
// Patrice
HRESULT Sim_CallDispatch(HANDLE hSimConnect) {
    //for ( ;; ) {
    //    if (gP.quit) break;
        HRESULT hr = SimConnect_CallDispatch(hSimConnect, MyDispatchProcRD, NULL);
    //    Sleep(1);
    //}
    return hr;
}
// Patrice
HRESULT Sim_Close(HANDLE hSimConnect) {
    HRESULT hr = SimConnect_Close(hSimConnect);
    return hr;
}
// Patrice (replace my previous Sim_Connect)
HRESULT Sim_Open(HANDLE * phSimConnect, LPCSTR szName, HWND hWnd, DWORD UserEventWin32, HANDLE hEventHandle, DWORD ConfigIndex) {
    HRESULT hr = E_FAIL;
    if (IsWindow(hWnd)) {
        gP.hParent = hWnd;
        hr = SimConnect_Open(phSimConnect, szName, hWnd, UserEventWin32, hEventHandle, ConfigIndex);
        if (hr == S_OK) gP.hSimConnect = phSimConnect;
    }
    return hr;
}

BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

[Didier MALBRANQUE]

Ok  I try with SIM.dll in Windev MiniSIM

[Didier MALBRANQUE]

Bonjour Patrice
 J'ai donc fait l'essai avec le projet Windev.
 Les valeurs reçus sont correctes même si parfois elles paraissent  étranges dans l'affichage.
 Je vais modifier la librairie dans visual studio de manière à ôter les ztraces et ainsi liibérer de l'espace d'affichage.
Il faudrait peu être changer la période pour l'appel du callback pour synchroniser  avec l'affichage du simulateur. Ne pas utiliser le SIM_RATE mais le VISUAL_SIM_RATE. Au pire, utiliser le ONCE et gérer les appels dans windev. Dans mon cas il paraît inutile d'aller au delà de 2 fois par seconde.
Une question : le Sim_Quit permet la sortie de la boucle ?
Autre question : est ce que je peux essayer avec d'autres SimVar que les 4 que nous avons utilisées (title, etc...) ?

‐----------

Traduction  Google :
Hello Patrice
  So I did the test with the Windev project.
  The values ​​received are correct even if sometimes they appear strange in the display.
  I will modify the library in visual studio so as to remove the ztraces and thus free up display space.
 It may be necessary to change the period for the callback call to synchronize with the display of the simulator.  Do not use the SIM_RATE but the VISUAL_SIM_RATE.  At worst, use ONCE and handle calls in windev.  In my case it seems useless to go beyond 2 times per second.
 A question: the Sim_Quit allows the exit of the loop?
 Another question: can I try with other SimVars than the 4 we used (title, etc...)?

[Patrice Terrier]

Les zTrace(s) peuvent être enlevés si cela fonctionne.
Concernant SimVar, en principe oui on peut en utiliser d'autres.

Initialement le Sim_Quit était prévu pour sortir de la boucle si celle-ci était utilisée directement dans SIM.dll
Mais désormais, dans le code WD Sim26, c'est gP.BoucleEnCours qui doit être utilisé.
Il est possible de remplacer la boucle, par un Timer exécuté à la fréquence souhaitée.

[Didier MALBRANQUE]

Ok...

D'après ce que je vois il semblerait que le Simu s'occupe également de renvoyer tout seul la réponse à la "période" souhaitée.
Je l'ai vu car dans WD la période est la seconde sur le trace de Windev; et le ZTrace renvoie beaucoup plus rapidement. Je pense donc que tant que nous ne disons à SimConnect de s'arrêter, il continue sans arrêt ; d'où l'intérêt dans ce cas d'utiliser, dans WD, la période SIMCONNECT_CLIENT_DATA_PERIOD_ONCE afin que SimConnect ne continue pas à répondre indéfiniment et inutilement.
Je continue mes essais.
Dans cette librairie, peut-on renvoyer des commandes ?

[Patrice Terrier]

Oui, on doit pouvoir envoyer des commandes, il faut me fournir une liste de ce dont vous avez besoin.

[Didier MALBRANQUE]

 Je viens de regarder la SIM.DLL.
Dans le code il y a  :

-----------------------------

struct Struct1 {
    char    title[256];
    double  kohlsmann;
    double  altitude;
    double  latitude;
    double  longitude;
};

C'est une structure fixe qui est utilisée pour une Request fixe concernant ces valeurs là.

-----------------------------

et dans le callback il y a

enum DATA_DEFINE_ID {
    DEFINITION_1,
};
 
enum DATA_REQUEST_ID {
    REQUEST_1,
};

Ces énumérations son fixes puisque qu'il est possible d'envoyer plusieurs requêtes avec chacun sont identifiant.

---------------------------

ainsi que :

...
            case REQUEST_1:
            {
                DWORD ObjectID = pObjData->dwObjectID;
                Struct1* pS = (Struct1*)&pObjData->dwData;
                if (SUCCEEDED(StringCbLengthA(&pS->title[0], sizeof(pS->title), NULL))) { // Cela n e concerne que le TITLE lorsqu'il est demandé

                    //StringCchPrintfA(gP.zaf, strSize(gP.zaf), "ObjectID=%d  Title=\"%s\"\nLat=%f  Lon=%f  Alt=%f  Kohlsman=%.2f", ObjectID, pS->title, pS->latitude, pS->longitude, pS->altitude, pS->kohlsmann);
                    //MultiByteToWideChar(CP_ACP, 0, gP.zaf, lstrlenA(gP.zaf), gP.ZAF, MAX_PATH);
                    //zTrace(gP.ZAF);

                    if (IsWindow(gP.hParent)) {
                        PostMessage(gP.hParent, WM_USER + SIMCONNECT_RECV_ID_SIMOBJECT_DATA, NULL, (LPARAM) pS); //
                        // La structure Ps est renvoyée mais elle fixe et uniquement pour ces 5 valeurs demandées.
                    }
                }
                break;
            }
...


Etant donné que dans ce cas précis, la rapidité n'est pas très importante, ne serait-il pas mieux de faire un appel pour chaque SimVar demandée séparément ? Mais iol n'empêche que la structure reste différente pour chaque valeur, certaines sont en Char, d'autres en Réels... etc...
Je vais quand même faire l'essai d'appeler d'autres SimVar comme par exemple une fréquence radio.

[Didier MALBRANQUE]

Pour envoyer une "Commande", soit on modifie directement une valeur modifiable dans la liste des Event du Simu c'est le SendData (Zip en attache), soit on gère un SendEvent (3 exemples en attache).

[Didier MALBRANQUE]

Je suis dans VS2019 et j'ai des variable déclarées de cette manière :

    HWND    hParent = 0;
    HANDLE  hSimConnect = NULL;
    WCHAR   ZAF[MAX_PATH] = { 0 };

Où sont définies ces types : HWND, HANDLE, WCHAR ?
Dans un Header ?
Merci

[Patrice Terrier]

Didier

Les constantes se trouvent dans "windef.h"

HWND, HANDLE = system int
WCHAR = string unicode

mais windef.h est toujours inclus lors de l'initialisation, via les
#include
qui se trouvent en début de code.

Voici la liste complète de l'API SimConnect, qu'on peut encapsuler dans SIM.dll.

Code: [Select]

ExportC HRESULT Sim_MapClientEventToSimEvent(HANDLE hSimConnect, DWORD EventID, const char * EventName = "");
ExportC HRESULT Sim_TransmitClientEvent(HANDLE hSimConnect, DWORD ObjectID, DWORD EventID, DWORD dwData, DWORD GroupID, SIMCONNECT_EVENT_FLAG Flags);
ExportC HRESULT Sim_SetSystemEventState(HANDLE hSimConnect, DWORD EventID, DWORD dwState);
ExportC HRESULT Sim_AddClientEventToNotificationGroup(HANDLE hSimConnect, DWORD GroupID, DWORD EventID, BOOL bMaskable = FALSE);
ExportC HRESULT Sim_RemoveClientEvent(HANDLE hSimConnect, DWORD GroupID, DWORD EventID);
ExportC HRESULT Sim_SetNotificationGroupPriority(HANDLE hSimConnect, DWORD GroupID, DWORD uPriority);
ExportC HRESULT Sim_ClearNotificationGroup(HANDLE hSimConnect, DWORD GroupID);
ExportC HRESULT Sim_RequestNotificationGroup(HANDLE hSimConnect, DWORD GroupID, DWORD dwReserved = 0, DWORD Flags = 0);
ExportC HRESULT Sim_AddToDataDefinition(HANDLE hSimConnect, DWORD DefineID, const char * DatumName, const char * UnitsName, DWORD DatumType = DWORD_FLOAT64, float fEpsilon = 0, DWORD DatumID = SIMCONNECT_UNUSED);
ExportC HRESULT Sim_ClearDataDefinition(HANDLE hSimConnect, DWORD DefineID);
ExportC HRESULT Sim_RequestDataOnSimObject(HANDLE hSimConnect, DWORD RequestID, DWORD DefineID, DWORD ObjectID, DWORD Period, DWORD Flags = 0, DWORD origin = 0, DWORD interval = 0, DWORD limit = 0);
ExportC HRESULT Sim_RequestDataOnSimObjectType(HANDLE hSimConnect, DWORD RequestID, DWORD DefineID, DWORD dwRadiusMeters, SIMCONNECT_SIMOBJECT_TYPE type);
ExportC HRESULT Sim_SetDataOnSimObject(HANDLE hSimConnect, DWORD DefineID, DWORD ObjectID, DWORD Flags, DWORD ArrayCount, DWORD cbUnitSize, void * pDataSet);
ExportC HRESULT Sim_MapInputEventToClientEvent(HANDLE hSimConnect, DWORD GroupID, const char * szInputDefinition, DWORD DownEventID, DWORD DownValue = 0, DWORD UpEventID = (DWORD)SIMCONNECT_UNUSED, DWORD UpValue = 0, BOOL bMaskable = FALSE);
ExportC HRESULT Sim_SetInputGroupPriority(HANDLE hSimConnect, DWORD GroupID, DWORD uPriority);
ExportC HRESULT Sim_RemoveInputEvent(HANDLE hSimConnect, DWORD GroupID, const char * szInputDefinition);
ExportC HRESULT Sim_ClearInputGroup(HANDLE hSimConnect, DWORD GroupID);
ExportC HRESULT Sim_SetInputGroupState(HANDLE hSimConnect, DWORD GroupID, DWORD dwState);
ExportC HRESULT Sim_RequestReservedKey(HANDLE hSimConnect, DWORD EventID, const char * szKeyChoice1 = "", const char * szKeyChoice2 = "", const char * szKeyChoice3 = "");
ExportC HRESULT Sim_SubscribeToSystemEvent(HANDLE hSimConnect, DWORD EventID, const char * SystemEventName);
ExportC HRESULT Sim_UnsubscribeFromSystemEvent(HANDLE hSimConnect, DWORD EventID);
ExportC HRESULT Sim_WeatherRequestInterpolatedObservation(HANDLE hSimConnect, DWORD RequestID, float lat, float lon, float alt);
ExportC HRESULT Sim_WeatherRequestObservationAtStation(HANDLE hSimConnect, DWORD RequestID, const char * szICAO);
ExportC HRESULT Sim_WeatherRequestObservationAtNearestStation(HANDLE hSimConnect, DWORD RequestID, float lat, float lon);
ExportC HRESULT Sim_WeatherCreateStation(HANDLE hSimConnect, DWORD RequestID, const char * szICAO, const char * szName, float lat, float lon, float alt);
ExportC HRESULT Sim_WeatherRemoveStation(HANDLE hSimConnect, DWORD RequestID, const char * szICAO);
ExportC HRESULT Sim_WeatherSetObservation(HANDLE hSimConnect, DWORD Seconds, const char * szMETAR);
ExportC HRESULT Sim_WeatherSetModeServer(HANDLE hSimConnect, DWORD dwPort, DWORD dwSeconds);
ExportC HRESULT Sim_WeatherSetModeTheme(HANDLE hSimConnect, const char * szThemeName);
ExportC HRESULT Sim_WeatherSetModeGlobal(HANDLE hSimConnect);
ExportC HRESULT Sim_WeatherSetModeCustom(HANDLE hSimConnect);
ExportC HRESULT Sim_WeatherSetDynamicUpdateRate(HANDLE hSimConnect, DWORD dwRate);
ExportC HRESULT Sim_WeatherRequestCloudState(HANDLE hSimConnect, DWORD RequestID, float minLat, float minLon, float minAlt, float maxLat, float maxLon, float maxAlt, DWORD dwFlags = 0);
ExportC HRESULT Sim_WeatherCreateThermal(HANDLE hSimConnect, DWORD RequestID, float lat, float lon, float alt, float radius, float height, float coreRate = 3.0f, float coreTurbulence = 0.05f, float sinkRate = 3.0f, float sinkTurbulence = 0.2f, float coreSize = 0.4f, float coreTransitionSize = 0.1f, float sinkLayerSize = 0.4f, float sinkTransitionSize = 0.1f);
ExportC HRESULT Sim_WeatherRemoveThermal(HANDLE hSimConnect, DWORD ObjectID);
ExportC HRESULT Sim_AICreateParkedATCAircraft(HANDLE hSimConnect, const char * szContainerTitle, const char * szTailNumber, const char * szAirportID, DWORD RequestID);
ExportC HRESULT Sim_AICreateEnrouteATCAircraft(HANDLE hSimConnect, const char * szContainerTitle, const char * szTailNumber, int iFlightNumber, const char * szFlightPlanPath, double dFlightPlanPosition, BOOL bTouchAndGo, DWORD RequestID);
ExportC HRESULT Sim_AICreateNonATCAircraft(HANDLE hSimConnect, const char * szContainerTitle, const char * szTailNumber, SIMCONNECT_DATA_INITPOSITION InitPos, DWORD RequestID);
ExportC HRESULT Sim_AICreateSimulatedObject(HANDLE hSimConnect, const char * szContainerTitle, SIMCONNECT_DATA_INITPOSITION InitPos, DWORD RequestID);
ExportC HRESULT Sim_AIReleaseControl(HANDLE hSimConnect, DWORD ObjectID, DWORD RequestID);
ExportC HRESULT Sim_AIRemoveObject(HANDLE hSimConnect, DWORD ObjectID, DWORD RequestID);
ExportC HRESULT Sim_AISetAircraftFlightPlan(HANDLE hSimConnect, DWORD ObjectID, const char * szFlightPlanPath, DWORD RequestID);
ExportC HRESULT Sim_ExecuteMissionAction(HANDLE hSimConnect, const GUID guidInstanceId);
ExportC HRESULT Sim_CompleteCustomMissionAction(HANDLE hSimConnect, const GUID guidInstanceId);
ExportC HRESULT Sim_Close(HANDLE hSimConnect);
ExportC HRESULT Sim_RetrieveString(SIMCONNECT_RECV * pData, DWORD cbData, void * pStringV, char ** pszString, DWORD * pcbString);
ExportC HRESULT Sim_GetLastSentPacketID(HANDLE hSimConnect, DWORD * pdwError);
ExportC HRESULT Sim_Open(HANDLE * phSimConnect, LPCSTR szName, HWND hWnd, DWORD UserEventWin32, HANDLE hEventHandle, DWORD ConfigIndex);
ExportC HRESULT Sim_CallDispatch(HANDLE hSimConnect, DispatchProc pfcnDispatch, void * pContext);
ExportC HRESULT Sim_GetNextDispatch(HANDLE hSimConnect, SIMCONNECT_RECV ** ppData, DWORD * pcbData);
ExportC HRESULT Sim_RequestResponseTimes(HANDLE hSimConnect, DWORD nCount, float * fElapsedSeconds);
ExportC HRESULT Sim_InsertString(char * pDest, DWORD cbDest, void ** ppEnd, DWORD * pcbStringV, const char * pSource);
ExportC HRESULT Sim_CameraSetRelative6DOF(HANDLE hSimConnect, float fDeltaX, float fDeltaY, float fDeltaZ, float fPitchDeg, float fBankDeg, float fHeadingDeg);
ExportC HRESULT Sim_MenuAddItem(HANDLE hSimConnect, const char * szMenuItem, DWORD MenuEventID, DWORD dwData);
ExportC HRESULT Sim_MenuDeleteItem(HANDLE hSimConnect, DWORD MenuEventID);
ExportC HRESULT Sim_MenuAddSubItem(HANDLE hSimConnect, DWORD MenuEventID, const char * szMenuItem, DWORD SubMenuEventID, DWORD dwData);
ExportC HRESULT Sim_MenuDeleteSubItem(HANDLE hSimConnect, DWORD MenuEventID, const DWORD SubMenuEventID);
ExportC HRESULT Sim_RequestSystemState(HANDLE hSimConnect, DWORD RequestID, const char * szState);
ExportC HRESULT Sim_SetSystemState(HANDLE hSimConnect, const char * szState, DWORD dwInteger, float fFloat, const char * szString);
ExportC HRESULT Sim_MapClientDataNameToID(HANDLE hSimConnect, const char * szClientDataName, SIMCONNECT_CLIENT_DATA_ID ClientDataID);
ExportC HRESULT Sim_CreateClientData(HANDLE hSimConnect, SIMCONNECT_CLIENT_DATA_ID ClientDataID, DWORD dwSize, SIMCONNECT_CREATE_CLIENT_DATA_FLAG Flags);
ExportC HRESULT Sim_AddToClientDataDefinition(HANDLE hSimConnect, SIMCONNECT_CLIENT_DATA_DEFINITION_ID DefineID, DWORD dwOffset, DWORD dwSizeOrType, float fEpsilon = 0, DWORD DatumID = SIMCONNECT_UNUSED);
ExportC HRESULT Sim_ClearClientDataDefinition(HANDLE hSimConnect, SIMCONNECT_CLIENT_DATA_DEFINITION_ID DefineID);
ExportC HRESULT Sim_RequestClientData(HANDLE hSimConnect, SIMCONNECT_CLIENT_DATA_ID ClientDataID, DWORD RequestID, SIMCONNECT_CLIENT_DATA_DEFINITION_ID DefineID, SIMCONNECT_CLIENT_DATA_PERIOD Period = SIMCONNECT_CLIENT_DATA_PERIOD_ONCE, SIMCONNECT_CLIENT_DATA_REQUEST_FLAG Flags = 0, DWORD origin = 0, DWORD interval = 0, DWORD limit = 0);
ExportC HRESULT Sim_SetClientData(HANDLE hSimConnect, SIMCONNECT_CLIENT_DATA_ID ClientDataID, SIMCONNECT_CLIENT_DATA_DEFINITION_ID DefineID, SIMCONNECT_CLIENT_DATA_SET_FLAG Flags, DWORD dwReserved, DWORD cbUnitSize, void * pDataSet);
ExportC HRESULT Sim_FlightLoad(HANDLE hSimConnect, const char * szFileName);
ExportC HRESULT Sim_FlightSave(HANDLE hSimConnect, const char * szFileName, const char * szTitle, const char * szDescription, DWORD Flags);
ExportC HRESULT Sim_FlightPlanLoad(HANDLE hSimConnect, const char * szFileName);
ExportC HRESULT Sim_Text(HANDLE hSimConnect, SIMCONNECT_TEXT_TYPE type, float fTimeSeconds, DWORD EventID, DWORD cbUnitSize, void * pDataSet);
ExportC HRESULT Sim_SubscribeToFacilities(HANDLE hSimConnect, SIMCONNECT_FACILITY_LIST_TYPE type, DWORD RequestID);
ExportC HRESULT Sim_UnsubscribeToFacilities(HANDLE hSimConnect, SIMCONNECT_FACILITY_LIST_TYPE type);
ExportC HRESULT Sim_RequestFacilitiesList(HANDLE hSimConnect, SIMCONNECT_FACILITY_LIST_TYPE type, DWORD RequestID);

[Didier MALBRANQUE]

Ok Merci Patrice.


Je suis sur VS avec SIM.dll car j'aimerais modifier le code (c'est pas simple pour moi, ne maitrisant pas le C++) et je me posais une question :
Actuellement on part du principe que ce qui est demandé correspond à quelques variables prédéfinies à l'avance.
Je commence à maitriser la fonction Sim_RequestDataOnSimObject qui offre des possibilités de réponse périodique en fonction d'un flag de changement de valeur de l'un e des variables, des périodicités en complément de SIMCONNECT_PERIOD_VISUAL_FRAME, etc...
De plus SimCOnnect est capable de gérer plusieurs DEFINITIONS_ID et plusieurs REQUEST_ID.
Si maintenant je désire que le SIM, qui interface correctement WD et SImConnect, soit plus "ouvert", il me faut principalement que DEFINITION_ID, REQUEST_ID et la structure des données reçues (ici Struct1).
A première vue, j'ai 2 principes qui s'offrent à moi :
1/ Gérer en live n'importe quels DEFINITIONS_ID, n'importe quels REQUEST_ID et n'importe quelles structures que vont générer les requêtes. C'est un lourd chantier non ?
2/ Prévoir à l'avance, dans SIM.dll, tout ce que je veux faire avec WD, et ainsi créer des DEFINITIONS_ID, REQUEST_ID, Structures.

La deuxième, pour mon niveau VS et C++, semble plus simple, mais nécessite une modification permanente de SIM.dll.
De plus, dans ce deuxième cas, je peux toujours partager ce que je fais mais cela risque d'être strictement d'une utilisation personnelle qui ne s'adapte pas tous ceux qui seraient intéressés.

Que pensez-vous de cela ?

[Patrice Terrier]

Je pense que compte tenu de vos connaissances actuelles il faut progresser un pas après l'autre.

Le principe 1, est le meilleur, mais il faut d'abord passer par le 2 pour que je puisse vous aider, car pour moi qui n'ai pas FS je ne peux pas faire grand chose de plus.

[Didier MALBRANQUE]

Comment vous le disiez à juste titre faisons les choses les unes après les autres.

J'ai rajouté la fonction : Sim_SubscribeToSystemEvent
Elle permet de demander la surveillance, notamment, de l'activité du simulateur (ex : SimStart, SimPause, SimStop).
J'ai rajouté également la gestion du retour vers WD : case SIMCONNECT_RECV_ID_EVENT:

Vous me direz si ce que j'ai fait est correct

Je vais implémenter le code WD pour la demande et la lecture de cette info.

Voici la dll :

[Patrice Terrier]

Oui, tout me semble correct.

Tous les ID (DefineID, RequestID, EventID, etc.) sont des DWORD (entiers non signés).