GigEVisionActionFeatures.cpp

The GigEVisionActionFeatures program is a simple example which illustrates how GigE Vision™ actions can be used to trigger events like starting an image in multiple cameras and instantaneously receive a confirmation about it.

How it works:

1. Let the user decide which devices to use. Make sure to use devices on the same Ethernet interface.
2. Prepare the two cameras for being able to properly react to the action commands.
3. Prepare the interface for being able to send the action command.
4. Arm the acquisition in the two cameras.
5. Fire the action command from the same interface.
6. Depending on the responses, request the images.

The explanation regarding the action commands and the usage of action command acknowledges can be found in chapter Actions and their Balluff extensions .

Source code

#include <iostream>
#include <vector>
#include <apps/Common/exampleHelper.h>
#include <mvIMPACT_CPP/mvIMPACT_acquire.h>
#include <mvIMPACT_CPP/mvIMPACT_acquire_GenICam.h>
 
 
using namespace std;
using namespace mvIMPACT::acquire;
using namespace mvIMPACT::acquire::GenICam;
 
//-----------------------------------------------------------------------------
bool findDeviceInGenTLTree( const Device* pDev, int64_type& systemIndex, int64_type& interfaceIndex )
//-----------------------------------------------------------------------------
{
    systemIndex = -1;
    interfaceIndex = -1LL;
    // find the GenTL interface this device claims to be connected to
    PropertyI64 interfaceID;
    DeviceComponentLocator locator( pDev->hDev() );
    locator.bindComponent( interfaceID, "InterfaceID" );
    if( !interfaceID.isValid() )
    {
        return false;
    }
    const std::string interfaceDeviceHasBeenFoundOn( interfaceID.readS() );
    const int64_type systemModuleCount = mvIMPACT::acquire::GenICam::SystemModule::getSystemModuleCount();
    for( int64_type i = 0; i < systemModuleCount; i++ )
    {
        mvIMPACT::acquire::GenICam::SystemModule sm( i );
        if( !sm.interfaceSelector.isValid() ) // CPPUNIT_ASSERT( sm.interfaceSelector.isValid() );
        {
            return false;
        }
        const int64_type interfaceSelectorMax = sm.interfaceSelector.getMaxValue();
        for( int64_type index = 0; index <= interfaceSelectorMax; index++ )
        {
 
            if( !sm.interfaceSelector.write( index ) )// CPPUNIT_ASSERT_NO_THROW( sm.interfaceSelector.write( index ) );
            {
                return false;
            }
            const std::string val( sm.interfaceID.read() );
            if( val == interfaceDeviceHasBeenFoundOn )
            {
                interfaceIndex = index;
                systemIndex = i;
                break;
            }
        }
    }
    return ( systemIndex != -1 ) && ( interfaceIndex != -1 );
}
 
//-----------------------------------------------------------------------------
void printNotSupportedAndWait( const Device* pDev, const std::string additionalInfo )
//-----------------------------------------------------------------------------
{
    cout << "Device " << pDev->serial.read() << "(" << pDev->product << ") is not supported by this sample";
    if( additionalInfo.empty() )
    {
        cout << endl;
    }
    else
    {
        cout << ":" << endl;
        cout << additionalInfo << endl;
    }
    cout << "Press [ENTER] to end the application" << endl;
    cin.get();
}
 
//-----------------------------------------------------------------------------
bool isCameraSuitableForSample( const Device* pDev, int64_type& systemIndex, int64_type& interfaceIndex )
//-----------------------------------------------------------------------------
{
    if( pDev == nullptr )
    {
        return false;
    }
 
    if( !pDev->interfaceLayout.isValid() )
    {
        return false;
    }
 
    vector<pair<string, TDeviceInterfaceLayout> > dict;
    pDev->interfaceLayout.getTranslationDict( dict );
    if( dict.empty() )
    {
        return false;
    }
 
    // if this device offers the 'GenICam' interface switch it on, as this will
    // allow are better control over GenICam compliant devices
    conditionalSetProperty( pDev->interfaceLayout, dilGenICam, true );
    // if this device offers a user defined acquisition start/stop behavior
    // enable it as this allows finer control about the streaming behavior
    conditionalSetProperty( pDev->acquisitionStartStopBehaviour, assbUser, true );
 
    int64_type sI = -1;
    int64_type iI = -1;
    if( !findDeviceInGenTLTree( pDev, sI, iI ) )
    {
        printNotSupportedAndWait( pDev, "Device not found in GenTL tree." );
        return false;
    }
 
    if( ( systemIndex == -1 ) && ( interfaceIndex == -1 ) )
    {
        systemIndex = sI;
        interfaceIndex = iI;
    }
    else if( ( systemIndex != sI ) || ( interfaceIndex != iI ) )
    {
        printNotSupportedAndWait( pDev, "Error: Both devices must be on the same interface." );
        return false;
    }
 
    SystemModule sm( systemIndex );
    InterfaceModule im( sm, interfaceIndex );
 
    if( im.interfaceType.readS() != "GEV" )
    {
        printNotSupportedAndWait( pDev, "Error: Only GEV interfaces are supported." );
        return false;
    }
 
    return true;
}
 
//-----------------------------------------------------------------------------
void resetDeviceTriggers( Device* pDev0, Device* pDev1 )
//-----------------------------------------------------------------------------
{
    AcquisitionControl acC0( pDev0 );
    AcquisitionControl acC1( pDev1 );
    acC0.triggerMode.writeS( "Off" );
    acC1.triggerMode.writeS( "Off" );
}
 
//-----------------------------------------------------------------------------
bool prepareCam0ForActionTriggering( Device* pDev )
//-----------------------------------------------------------------------------
{
    if( !pDev->isOpen() )
    {
        pDev->open();
    }
 
    ActionControl ac( pDev );
    if( !ac.actionSelector.isValid() || !ac.actionDeviceKey.isValid() || !ac.actionGroupKey.isValid() || !ac.actionGroupMask.isValid() )
    {
        printNotSupportedAndWait( pDev, "Not all Action features found in device." );
        return false;
    }
    ac.actionDeviceKey.write( 0x1 );
    ac.actionSelector.write( 0 );
    ac.actionGroupKey.write( 0x1 );
    ac.actionGroupMask.write( 0x1 );
 
    AcquisitionControl acC( pDev );
    if( !acC.triggerSelector.isValid() || !acC.triggerSource.isValid() || !acC.triggerMode.isValid() )
    {
        printNotSupportedAndWait( pDev, "Not the necessary Trigger features found in device." );
        return false;
    }
    acC.triggerSelector.writeS( "FrameStart" );
    acC.triggerSource.writeS( "Action1" );
    acC.triggerMode.writeS( "On" );
    return true;
}
 
//-----------------------------------------------------------------------------
bool prepareCam1ForActionTriggering( Device* pDev )
//-----------------------------------------------------------------------------
{
    if( !pDev->isOpen() )
    {
        pDev->open();
    }
 
    ActionControl ac( pDev );
    if( !ac.actionSelector.isValid() || !ac.actionDeviceKey.isValid() || !ac.actionGroupKey.isValid() || !ac.actionGroupMask.isValid() )
    {
        printNotSupportedAndWait( pDev, "Not all Action features found in device." );
        return false;
    }
    ac.actionDeviceKey.write( 0x1 );
    ac.actionSelector.write( 0 );
    ac.actionGroupKey.write( 0x1 );
    ac.actionGroupMask.write( 0x1 );
 
    CounterAndTimerControl ctc( pDev );
    if( !ctc.timerSelector.isValid() || !ctc.timerReset.isValid() || !ctc.timerDuration.isValid() || !ctc.timerTriggerSource.isValid() )
    {
        printNotSupportedAndWait( pDev, "Not the necessary Timer features found in device." );
        return false;
    }
    ctc.timerSelector.writeS( "Timer1" );
    ctc.timerReset.call();
    ctc.timerDuration.write( 500000 );
    ctc.timerTriggerSource.writeS( "Action1" );
 
    AcquisitionControl acC( pDev );
    if( !acC.triggerSelector.isValid() || !acC.triggerSource.isValid() || !acC.triggerMode.isValid() )
    {
        printNotSupportedAndWait( pDev, "Not the necessary Trigger features found in device." );
        return false;
    }
    acC.triggerSelector.writeS( "FrameStart" );
    acC.triggerSource.writeS( "Timer1End" );
    acC.triggerMode.writeS( "On" );
    return true;
}
 
//-----------------------------------------------------------------------------
void prepareAcquisition( const FunctionInterface& fi )
//-----------------------------------------------------------------------------
{
    fi.imageRequestSingle();
    fi.acquisitionStart();
}
 
//-----------------------------------------------------------------------------
void prepareInterfaceForActionTriggering( const InterfaceModule& im )
//-----------------------------------------------------------------------------
{
    im.actionDeviceKey.write( 0x1 );
    im.actionGroupKey.write( 0x1 );
    im.actionGroupMask.write( 0x1 );
    const uint64_type subnetMask = im.gevInterfaceSubnetMask.read();
    const int64_type broadcast = ( ( im.gevInterfaceSubnetIPAddress.read() & subnetMask ) | ~subnetMask  ) & 0x00000000ffffffff;
    im.gevActionDestinationIPAddress.write( broadcast );
    im.mvActionAcknowledgeEnable.write( TBoolean::bTrue );
    im.mvActionAcknowledgesExpected.write( 2 );
    im.mvActionAcknowledgeTimeout.write( 20 );
}
 
//-----------------------------------------------------------------------------
int main( void )
//-----------------------------------------------------------------------------
{
    const DeviceManager devMgr;
    int64_type systemIndex = -1;
    int64_type interfaceIndex = -1;
 
    try
    {
        cout << "Please select the first camera that you want to use:" << endl;
        Device* pDev0 = getDeviceFromUserInput( devMgr );
        cout << "Using camera with " << pDev0->serial << endl;
        if( !isCameraSuitableForSample( pDev0, systemIndex, interfaceIndex ) )
        {
            return 1;
        }
 
        cout << "Please select the second camera on the same interface that you want to use:" << endl;
        Device* pDev1 = getDeviceFromUserInput( devMgr );
        cout << "Using camera with " << pDev1->serial << endl;
        if( !isCameraSuitableForSample( pDev1, systemIndex, interfaceIndex ) )
        {
            return 2;
        }
 
        if( !prepareCam0ForActionTriggering( pDev0 ) || !prepareCam1ForActionTriggering( pDev1 ) )
        {
            return 3;
        }
 
        // Prepare the acknowledged Action. Any device on the same interface may signal the Action command
        const SystemModule sm( systemIndex );
        const InterfaceModule im( sm, interfaceIndex );
        prepareInterfaceForActionTriggering( im );
 
        // Prepare acquisition
        FunctionInterface fi0( pDev0 );
        prepareAcquisition( fi0 );
        FunctionInterface fi1( pDev1 );
        prepareAcquisition( fi1 );
 
        // Invoke the action
        if( ( im.actionCommand.call() != mvIMPACT::acquire::DMR_NO_ERROR ) ||
            ( im.mvActionAcknowledgesReceived.read() < im.mvActionAcknowledgesExpected.read() ) ||
            ( im.mvActionAcknowledgesFailed.read() > 0 ) )
        {
            cout << "Action was not successful. " << im.mvActionAcknowledgesReceived.read() << " of ";
            cout << im.mvActionAcknowledgesExpected.read() << " expected acknowledges have arrived ";
            cout << "and " << im.mvActionAcknowledgesFailed.read() << " had a non-SUCCESS status code" << endl;
            cout << "Aborting image reception." << endl;
            return 4;
        }
 
        // Now fetch the images because we know that the commands have been delivered correctly
        const int iReq0 = fi0.imageRequestWaitFor( 1000 );
        if( !fi0.isRequestNrValid( iReq0 ) )       // check if the image has been captured without any problems
        {
            cout << "*** Error waiting for image no. 1: " << ImpactAcquireException::getErrorCodeAsString( iReq0 ) << "(" << iReq0 << ")" << endl;
        }
        const int iReq1 = fi1.imageRequestWaitFor( 1500 );
        if( !fi1.isRequestNrValid( iReq1 ) )       // check if the image has been captured without any problems
        {
            cout << "*** Error waiting for image no. 2: " << ImpactAcquireException::getErrorCodeAsString( iReq1 ) << "(" << iReq1 << ")" << endl;
        }
 
        // Allow the cameras to be triggered normally again
        resetDeviceTriggers( pDev0, pDev1 );
    }
    catch( const ImpactAcquireException& e )
    {
        cout << "Something went wrong: " << e.getErrorString() << "(" << e.getErrorCodeAsString() << ")" << endl;
        cout << "Press [ENTER] to end the application" << endl;
        cin.get();
        return 10;
    }
    cout << "Press [ENTER] to end the application" << endl;
    cin.get();
    return 0;
}