Inside Application Process

If an OTX procedure will be executed, the OTX-Runtime API creates a new runtime context. Each runtime context normally has its own process called OTX-Runner. Especially in safety-critical systems it might not be possible to create new processes. In this case the runtime context will be run inside a thread of the application and not inside a new runner process. This is called RAW transport layer.

Note: The RAW transport layer only works with C++ OTX-Runtime API.

Code Example with RAW Transport Layer

How the OTX-Runtime API can be used with with RAW Transport Layer can be used, is described in the following C++ example. The example connects to a started DiagManager and executes the main procedure of a PTX file.

Code snippet of the OTX-Runtime API Sample Program.

#include <RuntimeManagerFactory.h>
using OpenTestSystem::Otx::Runtime::Api::RuntimeManagerFactory;
using OpenTestSystem::Otx::Runtime::Api::IRuntimeManager;
 
#include <IRuntimeContext.h>
using OpenTestSystem::Otx::Runtime::Api::IRuntimeContext;
 
#include <Project/IProject.h>
using OpenTestSystem::Otx::Runtime::Api::Otx::IProject;
 
#include <Otx/IProcedure.h>
using OpenTestSystem::Otx::Runtime::Api::Otx::IProcedure;
 
#include <OtxDiagFactory.h>
using OpenTestSystem::Otx::DiagManager::OtxDiagApi::OtxDiagFactory;
using OpenTestSystem::Otx::DiagManager::Common::ICommandProcessor;
using OpenTestSystem::Otx::DiagManager::Common::IDiagRuntimeSystem;
using OpenTestSystem::Otx::DiagManager::OtxDiagApi::IOtxDiag;
 
#include <OpenTestSystem.Otx.Runtime2.Api/License/LicenseManager.h>
#include <OpenTestSystem.OtxDiagManager.OtxDiagApi/License/LicenseManager.h>
 
typedef ICommandProcessor* (__cdecl* typeCreateCommandProcessor)(IDiagRuntimeSystem* diagRuntimeSystem);
typedef IDiagRuntimeSystem* (__cdecl* typeCreateDiagRuntimeSystem)(const char * projectName, const char * vehicleInfo);
 
#include <iostream>
#include <Windows.h>
 
int main(int argc, char **argv)
{
    // ==================================
    // Create Raw OtxDiagApi
    // ==================================
    const char * odxProject = ""; // declare OdxProject, it can be empty.
    const char * odxVehicle = ""; // declare OdxVehicle, it can be empty.
    const char * commandProcessorFilePath = "OpenTestSystem.Otx.DiagManager.CommandProcessor.dll";
    const char * drsFilePath = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.dll";
 
    // Set license for OtxDiagApi
    OpenTestSystem::Otx::DiagManager::OtxDiagApi::License::LicenseManager::SetLicenseKey("XXXXX-XXXXX-XXXXX-XXXXX-XXXXX");
 
    // Please note that:
    //  - VW_MCD_HOME, VW_MCD_CONFIG enviroment variables must be set
    //  - PATH enviroment variable contains VW_MCD_HOME value
    HMODULE DRS_Module = ::LoadLibrary(drsFilePath); // Dynamically loading the DiagRuntimeSystem.dll
    if (DRS_Module == NULL)
    {
        std::cout << drsFilePath << " not found!" << std::endl;
        return 1;
    }
 
    // Create an instance of function CreateDiagRuntimeSystem
    typeCreateDiagRuntimeSystem createDRSFunction = reinterpret_cast<typeCreateDiagRuntimeSystem>(::GetProcAddress(DRS_Module, "CreateDiagRuntimeSystem"));
    if (createDRSFunction == NULL)
    {
        std::cout << "function CreateDiagRuntimeSystem not found!" << std::endl;
        return 1;
    }
 
    // Dynamically loading the CommandProcessor.dll
    HMODULE CP_Module = ::LoadLibrary(commandProcessorFilePath);
    if (CP_Module == NULL)
    {
        std::cout << commandProcessorFilePath << " not found!" << std::endl;
        return 1;
    }
 
    // Create an instance of function CreateCommandProcessor
    typeCreateCommandProcessor createCPFunction = reinterpret_cast<typeCreateCommandProcessor>(::GetProcAddress(CP_Module, "CreateCommandProcessor"));
    if (createCPFunction == NULL)
    {
        std::cout << "function CreateCommandProcessor not found!" << std::endl;
        return 1;
    }
 
    // Call the function CreateDiagRuntimeSystem with project, vehicle parameters
    IDiagRuntimeSystem * diagRuntimeSystem = createDRSFunction(odxProject, odxVehicle);
 
    // Call the function CreateCommandProcessor
    ICommandProcessor * commandProcessor = createCPFunction(diagRuntimeSystem);
 
    OtxDiagFactory otxDiagFactory;
    std::shared_ptr<IOtxDiag> rawOtxDiag = otxDiagFactory.CreateRawOtxDiag(commandProcessor);
    // ==================================
    // Create Raw OtxDiagApi done.
    // ==================================
 
 
    // ==================================
    // Create Otx RuntimeManager and execute the main procedure.
    // ==================================
 
    // Set license for Otx Runtime Api
    OpenTestSystem::Otx::Runtime::Api::License::LicenseManager::SetLicenseKey("XXXXX-XXXXX-XXXXX-XXXXX-XXXXX");
    // Create the RuntimeManager with raw DiagManager
    std::shared_ptr<IRuntimeManager> runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(rawOtxDiag);
 
    // Load PTX file
    std::shared_ptr<IProject> project = runtimeManager->LoadPtx("DiagComSample.ptx");
    std::shared_ptr<IProcedure> procedure = project->GetMainProcedure();
 
    // Executes the procedure synchronous
    std::shared_ptr<IRuntimeContext> runtimeContext = runtimeManager->Execute(procedure);
 
    // ==================================
    // Do somethings and exit.
    // ==================================
}