VisionCam XM / XM2

Table of Contents

• Hardware trigger
• Controlling LED lighting
  • External lighting units
  • VisionCam XM Strobe unit
  • VisionCam XM2 ring light
• Embedded counters (VisionCam XM / LM)

There are two VisionCam XM hardware generations available:

• VisionCam XM / LM: dual-core ARM Cortex-A15 (armhf architecture).
• VisionCam XM2 / LM2: hexa-core / octa-core ARM Cortex-A78 (arm64 architecture).

Take a look at the Sensors page for information about supported sensors for each platform.

The VisionCam XM / XM2 provides a user-configurable FPGA, the "Real Time Communication Controller" (RTCC). It contains functional units for controlling trigger signals without CPU intervention.

The RTCC is controlled by the VisionBox Interface Library. The library modules controlling trigger signals are listed below:

• VIB::Multiplexer: Controls connections for trigger signals between functional units and input / output interfaces
• VIB::DigitalInput: Opto-coupled input signals
• VIB::DigitalOutput: Opto-coupled output signals
• VIB::Rs422: RS-422 input / output signals (only accessible for supported models)
• VIB::Strobe: Controlls LED strobe for the internal ring light or an external LED
• VIB::TriggerGenerator: Internal unit for generation or reshaping of trigger signals
• VIB::IOScheduler: Internal unit for real-time scheduling of trigger signals

Hardware trigger

The function FG_set_trigger_mode() is used to configure one of the trigger modes:

• Free-run
• Software triggered
• Hardware triggered

Example:

// Activate hardware trigger:
FG_set_trigger_mode(FG_TRIGGER_MODE_HARDWARE);

The VisionCam uses the VIB::Multiplexer output line 0 as hardware trigger by default. The Multiplexer line can be changed with the special feature TriggerLine. The sensor will trigger on the selected edge of the signal. There are no restrictions on the pulse length.

Property name	Description	Library
TriggerLine	Sets the VIB::Multiplexer line for hardware triggered mode (default: 0): 0...15: Use Multiplexer output line 0...15 with rising edge 100...115: same as 0...15 (compatibile with VisionSensor PV3 + I/O Expansion) 200...215: Use Multiplexer output line 0...15 with falling edge	≥ 1.1.1.0

Note

• Software trigger mode is not available for line scan sensors.
• The default setting after initialization is software trigger mode for area scan sensors and free-run for line scan sensors.
• The VisionCam LM2 with the Gpixel GL7004 line-scan sensor additionally supports a Frame trigger mode.

Example 1: Use a digital input to trigger the sensor

In the following example, the digital input 0 is connected to the sensor by using the Multiplexer output 2: VIB::Multiplexer multiplexer; unsigned int muxOutput = 2; // Open the multiplexer device multiplexer.Open(); // Connect the multiplexer output with the first digital input multiplexer.ConnectOutput(muxOutput, VIB::Multiplexer::MUX_SRC_DIG_IN0); // Setup the FG camera interface FG_install_camera(FG_CAMERA_TYPE_X_X_IMAGO_Vxx_AUTO); // Use hardware triggered mode FG_set_trigger_mode(FG_TRIGGER_MODE_HARDWARE); // Select the multiplexer output for triggering the sensor FG_set_special_option("TriggerLine", muxOutput); ... Please note that no error checking is performed in the examples in order to simplify the code.

Example 2: Derive the trigger signal from a rotary encoder

The following example shows how to configure the RTCC for using a rotary encoder to generate an adequate trigger signal. A divider is used to reduce the frequency of the signal. The example uses DividerA withtin the Trigger Unit (VIB::TriggerGenerator) with the encoder signals A and B. The divider value EncoderDivider (1...) determines the ratio between encoder speed and trigger frequency. This setup can be used to adapt the frequency for line scan applications, or to trigger a frame after a certain number of encoder steps. void SetupTrigger(unsigned int EncoderDivider) { VIB::TriggerGenerator triggerUnit; VIB::Multiplexer multiplexer; char text[200]; // Open Multiplexer and Trigger Unit multiplexer.Open(); triggerUnit.Open(); // Connect RS-422 encoder signals A and B to MUX output 0 and 1 multiplexer.ConnectOutput(0, VIB::Multiplexer::MUX_SRC_SYNC_0); // encoder signal A multiplexer.ConnectOutput(1, VIB::Multiplexer::MUX_SRC_SYNC_1); // encoder signal B // Setup DividerA using both encoder signals to get the highest input frequency: snprintf(text, sizeof(text), "DividerA=%u,TrigIn0/1_Both", EncoderDivider); triggerUnit.ConfigureSet(text); // We use Divider output 'TrigInB' because it has twice the frequency compared to output 'DividerA' triggerUnit.ConfigureSet("MuxIntern0=TrigInB"); // Connect the trigger signal to output 0 of the Trigger Unit triggerUnit.ConfigureSet("TrigOut0_Mux=TrigIntern0"); // Connect the trigger signal to MUX output 2 multiplexer.ConnectOutput(2, VIB::Multiplexer::MUX_SRC_TRIGGEN_OUT0); // Configure the sensor to use MUX output 2, the default is 0 FG_set_special_option("TriggerLine", 2); // Activate hardware trigger for the sensor FG_set_trigger_mode(FG_TRIGGER_MODE_HARDWARE); } Please note that no error checking is performed in the examples in order to simplify the code.

Example 3: Using an encoder and a frame trigger signal

This example is based on the previous example. An external frame trigger signal is now used to start acquistion for a limited number of trigger events. After a frame trigger happens, only the specified number of trigger events (TriggerCount) will be sent to the sensor. Further events are ignored, until the next frame trigger arrives. Further, the value TriggerDelay can be used to delay the first sensor event after the frame trigger. This value is also based on encoder position, not on time. Please note that the VisionCam LM2 provides a dedicated frame trigger mode which ensures synchronization between frame trigger and captured images. void SetupTrigger(unsigned int EncoderDivider, unsigned int TriggerCount, unsigned int TriggerDelay) { VIB::TriggerGenerator triggerUnit; VIB::Multiplexer multiplexer; char text[200]; // Open Multiplexer and Trigger Unit multiplexer.Open(); triggerUnit.Open(); multiplexer.ConnectOutput(0, VIB::Multiplexer::MUX_SRC_SYNC_0); // encoder signal A multiplexer.ConnectOutput(1, VIB::Multiplexer::MUX_SRC_SYNC_1); // encoder signal B multiplexer.ConnectOutput(2, VIB::Multiplexer::MUX_SRC_DIG_IN0); // frame trigger at digital input 0 // multiplexer.ConnectOutput(2, VIB::Multiplexer::MUX_SRC_SYNC_2); // alternatively: use encoder zero pulse as frame trigger // Setup DividerA using both encoder signals to get the highest input frequency: snprintf(text, sizeof(text), "DividerA=%u,TrigIn0/1_Both", EncoderDivider); triggerUnit.ConfigureSet(text); triggerUnit.ConfigureSet("DividerA_Reset=TrigIntern3"); // Use divider-reset to reduce jitter triggerUnit.ConfigureSet("MuxIntern1=DividerA"); // Use CounterB to generate a delay after the frame trigger signal triggerUnit.ConfigureSet("MuxIntern2=TrigIn2"); triggerUnit.ConfigureSet("CounterB_Start=TrigIntern2"); // Use frame trigger as start signal // Setup ON / OFF times to create a short output pulse after reaching the delay position: snprintf(text, sizeof(text), "CounterB=%u,TrigIn0/1_Both CounterB_ON=%u CounterB_OFF=%u", EncoderDivider * TriggerDelay + 1, EncoderDivider * TriggerDelay, EncoderDivider * TriggerDelay + 1); triggerUnit.ConfigureSet(text); triggerUnit.ConfigureSet("CounterB_Reset=Auto"); // Reset counter automatically after reaching the highest value triggerUnit.ConfigureSet("MuxIntern3=CounterB"); // CounterB output is the start signal for CounterA // Use CounterA to mask the divider output triggerUnit.ConfigureSet("CounterA_Start=TrigIntern3"); // Use CounterB output as start signal // Setup ON / OFF times to create the mask signal: snprintf(text, sizeof(text), "CounterA=%u,TrigIntern1_Both CounterA_On=1 CounterA_Off=%u", TriggerCount + 1, TriggerCount + 1); triggerUnit.ConfigureSet(text); triggerUnit.ConfigureSet("CounterA_Reset=Auto"); // Reset counter automatically after reaching the highest value // Divider output 'TrigInB' is masked by CounterA triggerUnit.ConfigureSet("MuxIntern0=TrigInB"); // Connect the trigger signal to output 0 of the Trigger Unit triggerUnit.ConfigureSet("TrigOut0_Mux=TrigIntern0"); // Connect the trigger signal to MUX output 3 multiplexer.ConnectOutput(3, VIB::Multiplexer::MUX_SRC_TRIGGEN_OUT0); // Configure the sensor to use MUX output 3, the default is 0 FG_set_special_option("TriggerLine", 3); // Activate hardware trigger for the sensor FG_set_trigger_mode(FG_TRIGGER_MODE_HARDWARE); } Please note that no error checking is performed in the examples in order to simplify the code.

Controlling LED lighting

Within the RTCC, the sensor's exposure signal can be used by the VIB::Multiplexer with VIB::Multiplexer::MUX_SRC_SYNC_1_0 as the source signal.

External lighting units

The following example sends the exposure signal to a digital output which then can be connected to an external lighting unit as trigger signal:

VIB::Multiplexer    multiplexer;
VIB::DigitalOutput  digOut;
 
// Open the Multiplexer device
multiplexer.Open();
 
// Open the DigitalOutput device
digOut.Open();
 
// Connect the Multiplexer line 4 with the exposure signal comming from the sensor
multiplexer.ConnectOutput(4, VIB::Multiplexer::MUX_SRC_SYNC_1_0);
 
// Connect the digital output 0 to the Multiplexer line 4
digOut.SetSource(0, VIB::DigitalOutput::DIG_OUT_SRC_MUX_OUT4, false);

VisionCam XM Strobe unit

The VIB::Strobe device controls the internal Strobe unit for the VisionCam XM. It can be used for the internal LED ring light if installed, or for an external LED connected to the I/O connector.

Example:

VIB::Multiplexer    multiplexer;
VIB::Strobe         strobe;
bool                strobeInternal = true;
int                 result;
 
// Open the Multiplexer device
multiplexer.Open();
 
// Open the Strobe device
strobe.Open();
 
// Initialize the strobe unit
strobe.Init();
 
// Select the strobe output
if (strobeInternal)
    strobe.SetOutputType(VIB::Strobe::STROBE_OUTPUT_TYPE_INTERNAL);  // internal LED ring light
else
    strobe.SetOutputType(VIB::Strobe::STROBE_OUTPUT_TYPE_EXTERNAL);  // I/O connector
 
// Set strobe parameters
strobe.SetFixedCurrent(24 /*SupplyVoltage*/, 12 /*LoadVoltage*/, 1000/*MaxOnTime*/, 0/*MinOffTime*/, 1000 /*Current*/, result);
 
// Connect the Multiplexer output 0 with the exposure signal comming from the sensor
multiplexer.ConnectOutput(0, VIB::Multiplexer::MUX_SRC_SYNC_1_0);
 
// Use the Multiplexer output 0 as trigger signal for the strobe unit
strobe.SetTriggerSource(VIB::Strobe::STROBE_SOURCE_MUX_OUT0, false);
 
// Configure the strobe trigger mode to copy the exposure signal
strobe.SetTriggerMode(VIB::Strobe::STROBE_MODE_HARDWARE_COPY, result);
 
// Setup the FG Camera interface and start acquisition
...

VisionCam XM2 ring light

If the optional LED ring light is enabled, the LED turns on during the integration period of the sensor. The image brightness can be changed by adjusting the integration time and the LED current.

The ring light is controlled by the following special features:

Property name	Description
StrobeEnable	Enables or disables the LED 0: disable (default) 1: enable
LedCurrent	LED current in percent 20...100 (default: 100)
LedDutyCycle	Returns the maximum usable duty cycle in percent (read-only)

Note

The maximum allowed duty cycle is calculated by the library to protect against hardware damage. If the frame rate is too high for the given exposure time, the LED ON-time will be reduced. This results in a reduction of the image brightness.

Embedded counters (VisionCam XM / LM)

Three special features are provided in order to embed additional information into the beginning of each frame or each line for line scan cameras:

• InsertImageCounter: a 16 bit value counting the number of sensor frames or lines for line scan cameras.
• InsertTriggerCounter: a 16 bit value counting the number of trigger events received.
• InsertTimeStamp: a 32 bit timestamp value in microseconds

Property name	Description	Version requirements
		Library	FPGA
InsertImageCounter	Enables or disables insertion of a frame / line counter. 0: disable counter (default) 1: enable counter	≥ 1.2.4.0	≥ 1.0.0.48
InsertTriggerCounter	Enables or disables insertion of a trigger counter. 0: disable counter (default) 1: enable counter
InsertTimeStamp	Enables or disables insertion of a time stamp. 0: disable time stamp (default) 1: enable time stamp

The image counter can be used for detection of dropped senor lines which are caused by insufficient acquisition buffers.

The trigger counter is used in hardware triggered mode for detection of ignored trigger events when the trigger signal is arriving too fast. This counter doesn't increment in free run mode.

Note

• Embedded counters are not avalailable for the VisionCam XM2
• The counters must be configured before buffers are allocated.
• Because of the processing pipeline delay for the Dragster line scan sensors, the inserted trigger counter can be inaccurate. Use the Dragster feature InsertLineCounters for getting a synchronized trigger counter, see Embedded line and trigger counters.

Example code for reading embedded counters

int main() { FG_IMAGE imageList[NUM_BUFFERS]; int checkCounters = 0; unsigned short frameCounter[2]; unsigned short trgCounter[2]; unsigned int timestamp[2]; // install and configure the camera SetupCamera(); // configure customized hardware trigger SetupTrigger(); // activate all counters FG_set_special_option("InsertImageCounter", 1); FG_set_special_option("InsertTriggerCounter", 1); FG_set_special_option("InsertTimeStamp", 1); // allocate image buffers for (UINT32 i = 0; i < NUM_BUFFERS; i++) FG_alloc_image(&imageList[i]); // start acquisition for (UINT32 i = 0; i < NUM_BUFFERS; i++) FG_append_image(&imageList[i]); // enter acquisition loop while (isRunning) { FG_IMAGE currentImage; unsigned short counterDiff; UINT32 res = FG_get_image(&currentImage, UINT_MAX); if (res == FG_ERROR_CODE_NoError) { // read the counter values from the beginning of the image: frameCounter[0] = ((unsigned short *)currentImage.pixel_ptr)[0]; trgCounter[0] = ((unsigned short *)currentImage.pixel_ptr)[1]; timestamp[0] = ((unsigned int *)currentImage.pixel_ptr)[1]; if (checkCounters) { // check the received sensor frames counterDiff = frameCounter[0] - frameCounter[1]; if (counterDiff != 1) printf("%d sensor frames dropped\n", counterDiff - 1); // check the trigger counter counterDiff = trgCounter[0] - trgCounter[1]; if (counterDiff != 1) printf("%d trigger events dropped\n", counterDiff - 1); printf("Frame period: %u us\n", timestamp[0] - timestamp[1]); } else { // delayed start of counter check checkCounters = 1; } // store values for the next cycle frameCounter[1] = frameCounter[0]; trgCounter[1] = trgCounter[0]; timestamp[1] = timestamp[0]; FG_append_image(&currentImage); } else if (res == FG_ERROR_CODE_BrokenImage) { FG_append_image(&currentImage); } else // Error during waiting return -1; } // abort image acquisition FG_stop_image(); // free buffers for (UINT32 i = 0; i < NUM_BUFFERS; i++) FG_free_image(&imageList[i]); // Close the camera FG_uninstall_camera(); return 0; } Please note that no error checking is performed in the examples in order to simplify the code.