Updates

Bertec Device DLL revision history.

Current version: 2.51

Synchronization between multiple devices using the SYNC line connection has been improved.
Starting synchronization with external clock sources now accepts either an all-high or all-low 'quiet period' state instead of just all-low.
Minor performance improvements have been made to the data collection routines, which will result in slightly less cpu overhead.
Updated the SDK sample code files to better reflect possible use conditions such as rate generation, etc.

bertec_Stop should now complete faster with multi-device setups, and extreme cases of 30+ seconds blocking should now be reduced to less than 5 seconds.
Applications that directly use the Windows API function FreeLibrary or cycling LoadLibrary/FreeLibrary aggressively without first calling bertec_Close should no longer randomly crash or block excessively. One particular scenario is when the library is unloaded while the devices are being detected and initialized. Note that using ExitProcess, exit(), or returning from main() without first calling berte_Close can also trigger this condition.
This issue does not occur with BertecDeviceNET since its Finalizer explicitly calls bertec_Close.
The device detection logic now has a hard limit of 3 seconds for devices to respond; any devices that fail to respond in this time frame will assume to be in a 'hung' state and ignored.

Multiple device detection should now be significantly faster, typically bringing the init time down from 10+ seconds to 2 seconds or less. This becomes important with large-scale deployments where there can be tens of connected devices that all must be detected in a short period of time.
Performance improvements to the data reading and processioning, resulting in slightly less memory consumption and cpu/power usage.
More checking is now done during the data reading, resulting in better error/disconnection detection.
bertec_Status now returns BERTEC_DATA_READ_NOT_STARTED if bertec_Start has not been called or bertec_Close has been called. If bertec_Start has been called, then bertec_Status will return the current status (looking for devices, devices found, autozeroing, etc).

NOTICE: The 2.50 version of the SDK introduces a breaking change regarding the 'init' or 'startup' phase of your program. Please see the updated BertecExample.cpp and BertecExampleNET.cs files for examples on the code changes your implementation will need to use.

The Device SDK now requires the use of the Data Stream Control system which the caller must use in order to set up how they plan on interacting with the device's data stream. Data Stream Control is provided to allow better, more fine-grained support for the various data alignment/sync modes, including internal and external clock frequencies. Data Stream Control functionality is exposed through the bertec_StartDataStream and bertec_StopDataStream methods (.NET: StartDataStream and StopDataStream), and the SDK PDF docs have been updated to document the various modes Data Stream Control provides. If the connected hardware does not support the requested feature, bertec_StartDataStream/StartDataStream will return an error.
This control block is required, and bertec_StartDataStream must be called before any data will be provided to the end consumer; calls to bertec_StartDataStream/StartDataStream should be made after GetStatus returns BERTEC_DEVICES_READY. Calling bertec_StartDataStream prior to a BERTEC_DEVICES_READY will fail to function, and failing to call bertec_StartDataStream will result in no data being processed.
You can use bertec_CanStartDataStream to determine if the connected hardware supports the desired Data Stream Control parameter block prior to calling bertec_StartDataStream.
See BertecExample.cpp and BertecExampleNET.cs for examples on the needed code changes.
bertec_StartDataStreamAsync is also provided as a non-blocking method with a callback function. There is no equivalent .NET function; if your .NET program requires StartDataStreamAsync-like functionality, consider using a thread or concurrent object to make the function call asynchronous.
Additional examples in both C++ and C# are now included in the SDK Package to cover the various modes of operation as documented in the SDK PDF file. These examples cover starting and stopping data using the AUX input port, the internal/external clocking modes, and a simple FZ data reader.
The bertec_SetEnableMasterSlaveMode/bertec_GetEnableMasterSlaveMode functions have been removed since this functionality is now covered by bertec_StartDataStream.
bertec_DeviceTimestampCallback has been removed as this functionality is no longer supported.
bertec_SetPinFlowControl/bertec_GetPinFlowControl has been added, which allows you to set the sync/aux pin on/off flow control independently of the data stream setup function.
An advanced feature bertec_PinStateChangeCallback has been added, which allows your code to be triggered whenever the value of the selected IOPins enum on a given device changes value. This can be called up to 8000mhz vs the 1000mhz data rate, since the sync and aux pins are sampled at 8x the hardware frequency, and operates outside the context of internal or external clock signaling.
The .NET library has the equivalent SetPinStateChangeNotification + PinStateChangedHandler event.
bertec_SetAggregateDeviceMode no longer takes a flag but now an enum value which allows for different physical arrangement of devices.
bertec_SetSubjectHeight, which is used to compute the Sway Angle for USB Force Plates, now enforces a lower limit of 1000mm and an upper limit of 2700mm. This prevents erroneous sway angle values when the height is impossible for the measured force data.
The hard limit of 32 devices has been removed, and the SDK can now support up to as many USB devices as Windows allows.
Data alignment between devices now will backfill missing data when it appears there is a mismatch between devices, which works better at keeping multiple devices in sync even without a connected sync cable.
The USB devices now handle device buffering in a non-blocking manner which improves the data alignment of multiple devices. This applies to various data structures and callback handlers, which should improve responsiveness in several areas.
The DeviceData::sequence member has been renamed to DeviceData::frameCounter, and DeviceInfo::hasInternalClock has been renamed to DeviceInfo::has64BitTimestamp to better match what how they are used.
The bertec_ResetDeviceClock, bertec_ResetAllDeviceClocks, bertec_ResetDeviceClockAtTime, and bertec_ResetAllDeviceClocksAtTime have all been renamed to bertec_ResetDeviceTimestamp, bertec_ResetAllDeviceTimestamps, bertec_ResetDeviceTimestampAtMark, and bertec_ResetAllDeviceTimestampsAtMark to better reflect that they are actually doing in regards to the hardware devices.
The Device Hardware ID enum has been updated with all currently available Bertec devices.
Corrected the naming of the SyncPinMode enums, and removed redundant prefixes for the .NET enums. This may introduce compilation errors in .NET code until the usage points are cleaned up.
A potential deadlock that could occur in user code where SDK functions were being invoked during a callback (ex: bertec_StatusCallback) has been resolved.
A random ~100ms delay during device setup has been resolved and devices should now initialize faster and align their clock frequencies better.
Devices without configured serial numbers (common for Treadmill systems) now default to the hardware id, and serial numbers now have leading/trailing whitespace removed.
Additional diagnostic logging is now being collected into the bertec_device_log file.
The .NET interface now does a better job of avoiding memory "churn", which should improve GC hits.

A potential race condition with the USB connection has been addressed.
When multiple devices are connected, the SDK now makes a greater effort to start them all at the same time. This should help to resolve some out-of-step data issues where one device would be 1 or 2 milliseconds 'ahead' of the other one.
The timing of multiple device data streams and command handling has been improved. Both the incoming data and outgoing commands (ex: ZeroNow) should now exhibit tighter interleaving under typical workloads.
The SDK now provides a optional separate data callback/.NET event that is invoked on a per-device basis instead of all at once. See bertec_ImmediateDeviceDataCallback in the .h file and the documentation for more information.
The bertec_DeviceTimestampCallback callback interface has been updated to match the other callback method patterns.
The SDK now supports sync and aux output pin frequency generation on hardware that allows it. See bertec_SetFrequencyGeneration in the .h file and the documentation for more information.
API header verbiage updated to more accurately reflect functionality.
Enum status values involving missing data sequence and sync loss have been removed, since this functionality has been replaced and these values have not been used for several major releases.
Handling of the FTD2XX.DLL has been improved - deploying this file in the same folder as your application's EXE is no longer needed. If you are loading the BertecDevice.DLL from a sub-folder (ex: Foo/Bar), you can place the FTD2XX.DLL in that same folder or your EXE's folder. If your current deployment strategy is to place the FTD2XX.DLL and BertecDevice.DLL files in your EXE's folder, that will continue to work. This is primarily to help with the .NET interface library.

The SDK now has preliminary support for frequency generation on the sync and aux pins via bertec_SetFrequencyGeneration. This is dependent on the firmware version loaded into the amplifier.
The SDK now supports additional sync and aux pin modes, and supports channel 7 and channel 8 pin modes on 68xx series amplifiers. This is dependent on the firmware version loaded into the amplifier.
Added the enums bertec_IOPins and bertec_PinModes, along with bertec_SetPinMode to support the new pin mode functionality.
Performance improvements and additional error logging.

Both the C++ and C# example files (the BertecExample command line programs) have been updated to document how to use the AUX channel as a simple on/off data capture switch, along with the Data Rate Resampling feature. Additional comments to the example code have been added, and existing comments have been improved.
Additional example files for C++ and C# are now part of the SDK package. These examples show how to use the Status callback or event handler to detect when devices are connected, and turn on/off a "can read data" flag. The device channel names are read to find the index to the "FZ" channel, which the Data callback/event handler uses to display the real-time FZ channel value. This example can serve as a jumping-off point for your own application.
Additional error checking has been added to the device initialization phase to detect possible connection issues.
The Library now supports the latest hardware and firmware revisions.
Functionality to turn on and off the timestamp alignment for multiple devices has been added. By default, the SDK will not attempt to align the data but if users wish to enable this feature, they can use bertec_SetTimestampAlignmentMode or the corresponding .NET property BertecDevice.TimestampAlignmentMode.
The ability to change the resampling rate of the incoming data has been exposed by the bertec_SetDataRateResampling and BertecDevice.SetDataRateResampling functions. This is a per-device method, and can be used with hardware that does not support external clocking.
The bertec_DataFrame pointer in the bertec_DataCallback handler has been marked as 'const', to indicate the application should not manipulate the passed data. The user void pointer is still non-const, as it is under the control of the application's memory space.
bertec_AdditionalData.auxData and bertec_AdditionalData.syncData now track the external clock pulse if one of the three external bertec_ClockSourceFlags enum values are passed to bertec_SetExternalClockMode. Previously, these were in an undefined state when an external clock source was being used (ex: calling bertec_SetExternalClockMode with CLOCK_SOURCE_EXT_RISE). When external clocking is being used (that is, data is only delivered when a high-low edge is detected on the Sync pin), the auxData value is either 0 or 255 (false/true) depending on the sampled state of the AUX pin at the point. The syncData value will be either 0 or 255 depending on which edge transition is being detected (0 for CLOCK_SOURCE_EXT_FALL, 255 for CLOCK_SOURCE_EXT_RISE, and cycling between 0/255 for CLOCK_SOURCE_EXT_BOTH). If the bertec_SetExternalClockMode is set to CLOCK_SOURCE_INTERNAL, then both the auxData and syncData will continue to be the same 8-bit sampled pattern from these hardware pins.
The SDK now does a better job in tracking and handling dropped input data, notably when using the external clock modes.
Both low pass filtering (bertec_SetLowpassFiltering) and averaging (bertec_SetAveraging) options now work with external clock sources (bertec_SetExternalClockMode), applying either or both of these two filters to the under or overclocked data. If external clocking is not turned on (bertec_ClockSourceFlags::CLOCK_SOURCE_INTERNAL), then these two filters behave as before.
The device info functions (bertec_GetDeviceCount, bertec_GetDeviceInfo, bertec_GetDeviceSerialNumber, bertec_GetDeviceModelNumber, bertec_GetDeviceChannels, bertec_GetDeviceChannelCount and bertec_GetDeviceChannelName) no longer block, resolving some deadlock issues that could occur inside user code.
The bertec_DeviceInfo structure now includes a Hardware ID field (hwid) that exposes the bertec_HardwareIDs enum value determined from device discovery and initialization. These hardware device enum values can be used by your code for advanced setup or detection functionality.
The version fields in the bertec_DeviceInfo structure have been renamed to better match what they are and how they should be used. These fields now encapsulate the device's firmware version and communication protocol.
The bertec_SyncModeFlags::SYNC_IN_STROBED value has been removed and will generate an error if used.
bertec_AllocateReadBufferedData now properly sets the output size value to the computed buffer size; this is designed to be used by bertec_ReadBufferedData.
bertec_AllocateReadBufferedDataForCount has been added, to preallocate a buffer for a given number of devices instead of relying on the current device count.
The bertec_DeviceDataRate function now takes a device index. Each connected device maintains their own effective data rate, which can be affected by the external clock signal. This computed data rate is updated every 2 seconds, and is designed primarily as a user interface monitoring device. Note that this is not the same as the Resampling Rate, which is seperate.
bertec_GetDeviceChannels and bertec_GetDeviceChannelName now behave in a manner consistent with the other methods, returning an error if the buffers are not set properly.
The .NET interface has been improved so that using the ReadBufferedData, ReadBufferedDataChannelsOnly, and ReadBufferedDataChannelsOnlyByRef functions work with multiple devices better.

During the device initialization phase, the SDK now does a more detailed check of the data coming back from the device. If the device data is incorrect in any fashion, the initialization sequence is retried. This helps to resolve a random issue with the force channel matrix computation data not being received in full from the device, resulting in missing channels or invalid force values being reported.
The Low Pass Filtering input was incorrectly limited to 19 instead of 20 as per the documentation.
A rare deadlock that could occur when calling some functions has been resolved.
Additional diagnostic logging has been added to the %temp%/bertec-device-logs files, including incorrect read events, zeroing command attempts, and overall timing.
Where possible, memory now allocates on appropriate architecture boundaries, improving performance.
Startup time for most devices has been improved. You should now see single-plate systems begin to deliver data via bertec_Callback within 300ms of bertec_Start being called.
The SDK example code has been updated to show more of what is going on during the initialization phase.

The SDK now supports an explicit "don't sync" mode via the bertec_SetUnifiedDataMode function. Only use this if your application requires it and your intend to handle the data alignment yourself.
Added a helper function bertec_GetDeviceChannelCount that returns the channel count value from the the device info structure.
Added a helper functions bertec_AllocateReadBufferedData and bertec_FreeAllocatedReadBufferedData for applications that wish to use the data polling. These functions allocate a properly sized buffer that your polling logic can then use.
Performance improvement to the data wait states so that the SDK is slightly more responsive to data arriving on the USB port, requests to exit, and requests to rescan the USB devices.

A crash that could occur with more than four devices has been resolved.
Older firmware would sometimes send extra data, resulting in data packets being rejected without first being processed. The SDK now performs introspection on these packets, rejecting only those that actually are corrupt.
SetSyncPinMode and related functions now allow certain values depending on the firmware version, and also check if the firmware being used allows the command to be issued while data is being read instead of blindly allowing it. This resolves a problem with older firmware data collection stopping when sync pin modes are used after data reading has started, and also allows the Master/Slave modes to work with both older and newer firmware.
The sync pin is now set to NONE when the device is initialized and before data reading is started.
Startup time has been improved, particularly with multiple devices.
The detected hardware device id is now exposed in the bertec_HardwareIDs and logged in the cyclic log file. These are currently not exposed in the bertec_DeviceInfo structure to maintain backwards compatibility.
A race condition between initializing the devices and returning the list of devices was resolved; this could be triggered by polling the device info array while the device list was being built.

The bertec_Start and bertec_Stop functions and corresponding BertecDevice.Start() and BertecDevice.Stop() methods now guard against rapid cycling, and will monitor and reject attempts to call Stop in the middle of a startup sequence and vice versa. This allows for more aggressive starting and stopping of the SDK without resorting to manually unloading and reloading the DLL.
The changes in build #644 to the .NET library BertecDevice.Start() and BertecDevice.Stop() methods have been removed, and they now work as before and are just thin calls to the base SDK. These methods now return a BertecDeviceNET.StatusErrors enum and not an int; your code may need adjusted.
Added additional error codes that Start and Stop will return indicating possible conditions; if your implementation cycles start and stop, you should check these values and react appropriately.
The stop function will now completely tear down the USB interface instead of leaving it for later when the DLL is unloaded or device redetection is triggered.
Triggering a device redetection now clears any buffered data first instead of later. Calling stop by design has always done the same by simply tearing down the USB reading subsystem.
The .NET library version now keeps in step with the base SDK DLL, removing a point of confusion when matching two DLL versions together.

Added in a redetect connected devices function that triggers an internal event to force the SDK to rescan and reinit all of the devices. This is the same as physically unplugging and then replugging all devices from the USB connection at the same time, and should be used in place of continually cycling the bertec_Stop and bertec_Start functions.
Added a new BERTEC_LOOKING_FOR_DEVICES enum for when devices are being detected; this will occur as part of the normal cycle and will be followed by either BERTEC_NO_DEVICES_FOUND or BERTEC_DEVICES_READY.
Changed how the .NET library BertecDevice.Start() and BertecDevice.Stop() work. These no longer map directly to bertec_Start and bertec_Stop, and instead set an internal flag that blocks any data from being processed and events being triggered.

Added in a callback function that SDK consumers can be used to manipulate the timestamp values in the datablock when it is being read from the USB. This is advanced functionality and should only be used with caution. See the bertec_DeviceTimestampCallback function signature for more information.

Fixed a possible race condition where the device count being presented to the SDK consumer would be valid before the device info was fully populated.
The SDK no longer supports multiple data or event callsbacks; if your project requires such functionality you will need to implicit it yourself.
The function signature for bertec_GetAutozeroState has changed from returning an INT value to return a bertec_AutozeroStates enum.

The SDK now has the ability to compute the subject's Center of Gravity and Sway Angle if the subject's height in MM is provided as optional computed channels. This is exposed via the bertec_SetComputedChannelsFlags function.
The SDK now supports dual plate aggregation, where a pair of plates are "bonded" together to make one large surface. This is exposed via the bertec_SetAggregateDeviceMode function. Using dual plates will affect the device count results.
Plate size and foot placement constants are now exposed as fixed ENUM values, covering all currently produces Bertec force plate/balance plate sizes.
Changed the addtionalData.timestamp value to always be 8x the device's timestamp even when not running in ext clock mode. This makes the data format consistent between the two. Updated the docs and samples to also make clear that using ext clock mode should also require clearing the data buffer after changing it.
The SDK now handles a case where disconnecting and reconnecting the plate rapidly will return incorrect data.
Data reading should now start slightly faster and consume less cpu cycles.
The SDK now reports the data reading frequency which can be used as status or diagnostic information.

The .NET wrapper was updated to support .NET "finalizers" which helps with using the SDK from products such as LabView.
The documentation has been updated to clarify some usage points and expand on others.
The bertec_SetExternalClockMode was always returning an error result even if the command was successful. bertec_SetExternalClockMode now returns UNSUPPORED_COMMAND if the hardware does not support the desired clock mode and NOERROR on success.
The COMMAND_FAILED constant was renamed to UNSUPPORED_COMMAND to better match what the error code actually means and how it is used.
If the external clock syncing feature is used and there is no sync pulse in over 3 seconds, the API would assume that the device was unplugged and reset the connection. This check is no longer done and instead only the presence of USB data on the wire is checked.

The DLL has been updated to Version 2.0. This version changes the API interface significantly, primarily to support external hardware synchronization and clocking. Please consult both the PDF documentation and the bertecif.h header file prior to use.
In particular, the data callback function structure has changed and is no longer a variable array but a fixed-size data structure.
The SDK will now attempt to load the FTD2XX.DLL at runtime and return an error if it cannot locate it; this change should allow for your application to detect installation problems and take the appropriate action.
The 64 bit version of the DLL no longer uses the _x64 suffix but instead can be found in the x64 folder inside of the SDK. This pattern matches common industry standards for 64-bit naming. Depending on your deployment you may need to copy this dll your exe's folder or add it to your path.

DLL now supports the latest series of force plates and devices.
Updated to current FTDI chipset drivers.

Added functionality to support re-ordering of plates.
Added functionality to allow thread priority changes.
Added 64-bit support.
Updated to current FTDI chipset drivers.

Improved handling of dual synced plates.
Removed function to get current sync drift since this no longer applies.
Added functions to check if sync cable connected and resetting of sync values.
Added code to resolve problems with certain mixes of system USB ports, amplifiers, and devices.
Other minor improvements.

Added advanced functionality to control USB thread priority.
Changes made to support control over the USB timeouts.
Now supports plates that have calibration matrixes that include + signs as part of the data.
Error logging in the %TEMP% folder now records more information which will assist in resolving device issues.

Removed Get/SetAcquirePortReadRate.
Added ClearPollBuffer to discard current buffered data.
Added GetZeroLevelNoiseValue for advanced filtering.
Changed how multiple plates are handled to prevent "stalling" on some systems.
CoP channel now uses a threshold value for better results.
Better handling of USB errors.
Updated to current chipset drivers.
Improvements to data reading to reduce "lag" on slower systems, noticeably older laptops.
No longer initializes devices twice.
Syncing with more than one device now works properly

Support for new firmware version that mitigates some USB port issues and data interference.
USB port reading speed has been improved, along with memory and resource management.

Improved support for more than two synchronized plates, including diagnostic function to get current offset.
Flow control has been improved
Support for newest firmware and data checksum functionality.
Changes in calibration matrix now handled better.
Improved the startup response time, no longer inits the devices twice on first start.
New functionality: get last set buffer size.
New functionality: set and get the low-level read size for fine control of device latency.
New functionality: able to clear the poll buffer.
Added JAVA bindings and example code.
.NET support library updated with TransducerStatus and better event support.
Updated examples to be more clear and less redundant.

Improved processor usage when no devices are connected.
Improved data sequence checking.
Improved the way fallbacks are done with regards to handling versions of the FTDI chipset.
Added support for more "generic" FTDI chipsets for wider range of device usage.
Added support for new firmware that allows for CRC checksum.
Devices are now always initialized on startup, instead of waiting for them.
Error logging is done to a %TEMP%\bertecdevicelog.txt file.
Multiple synchronized devices are now supported better.
Corrected handling of plates that report more channels than actually exist.
The USB controller now uses RTS/DTS flow control to improve latency on some systems.

For further information, please contact us at bertec.com.