drivers/boson: Add FLIR Boson IDD 4 Driver.

This commit is contained in:
Kwabena W. Agyeman 2024-12-08 23:56:49 -08:00
parent 19ec8b127a
commit 58e362f2f2
41 changed files with 47336 additions and 0 deletions

Binary file not shown.

View File

@ -0,0 +1,48 @@
# SPDX-License-Identifier: MIT
#
# Copyright (C) 2013-2024 OpenMV, LLC.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# BOSON Makefile
SRCS = $(wildcard src/*.c)
OBJS = $(addprefix $(BUILD)/, $(SRCS:.c=.o))
OBJ_DIRS = $(sort $(dir $(OBJS)))
override CFLAGS += -Wno-maybe-uninitialized \
-Wno-unused-variable \
-Wno-array-parameter \
-Wno-strict-aliasing \
-Wno-address-of-packed-member \
-Wno-uninitialized \
-Wno-format
all: | $(OBJ_DIRS) $(OBJS)
$(OBJ_DIRS):
$(MKDIR) -p $@
$(BUILD)/%.o : %.c
$(ECHO) "CC $<"
$(CC) $(CFLAGS) -c -o $@ $<
$(BUILD)/%.o : %.s
$(ECHO) "AS $<"
$(AS) $(AFLAGS) $< -o $@
-include $(OBJS:%.o=%.d)

View File

@ -0,0 +1,3 @@
patch_version = 27648
code_branch = ^/Components//tags/BOSON_R4.1_RC01_1
project_name = Boson

View File

@ -0,0 +1,850 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef CLIENT_API_H
#define CLIENT_API_H
#include <stdint.h>
#include "EnumTypes.h"
#include "ReturnCodes.h"
#include "Serializer_Struct.h"
#include "Client_Packager.h"
#define MAX_MEMORY_CHUNK 256
FLR_RESULT TLinearSetControl(const FLR_ENABLE_E data);
FLR_RESULT TLinearGetControl(FLR_ENABLE_E *data);
FLR_RESULT TLinearGetLUT(const FLR_BOSON_TABLETYPE_E mode, const uint16_t offset, float *a, float *b);
FLR_RESULT TLinearRefreshLUT(const FLR_BOSON_TABLETYPE_E mode);
FLR_RESULT agcSetPercentPerBin(const float data);
FLR_RESULT agcGetPercentPerBin(float *data);
FLR_RESULT agcSetLinearPercent(const float data);
FLR_RESULT agcGetLinearPercent(float *data);
FLR_RESULT agcSetOutlierCut(const float data);
FLR_RESULT agcGetOutlierCut(float *data);
FLR_RESULT agcGetDrOut(float *data);
FLR_RESULT agcSetMaxGain(const float data);
FLR_RESULT agcGetMaxGain(float *data);
FLR_RESULT agcSetdf(const float data);
FLR_RESULT agcGetdf(float *data);
FLR_RESULT agcSetGamma(const float data);
FLR_RESULT agcGetGamma(float *data);
FLR_RESULT agcGetFirstBin(uint32_t *data);
FLR_RESULT agcGetLastBin(uint32_t *data);
FLR_RESULT agcSetDetailHeadroom(const float data);
FLR_RESULT agcGetDetailHeadroom(float *data);
FLR_RESULT agcSetd2br(const float data);
FLR_RESULT agcGetd2br(float *data);
FLR_RESULT agcSetSigmaR(const float data);
FLR_RESULT agcGetSigmaR(float *data);
FLR_RESULT agcSetUseEntropy(const FLR_ENABLE_E data);
FLR_RESULT agcGetUseEntropy(FLR_ENABLE_E *data);
FLR_RESULT agcSetROI(const FLR_ROI_T roi);
FLR_RESULT agcGetROI(FLR_ROI_T *roi);
FLR_RESULT agcGetMaxGainApplied(float *data);
FLR_RESULT agcGetSigmaRApplied(float *data);
FLR_RESULT agcSetOutlierCutBalance(const float data);
FLR_RESULT agcGetOutlierCutBalance(float *data);
FLR_RESULT agcGetOutlierCutApplied(float *percentHigh, float *percentLow);
FLR_RESULT agcSetDetailHeadroomBalance(const float data);
FLR_RESULT agcGetDetailHeadroomBalance(float *data);
FLR_RESULT agcGetDetailHeadroomApplied(float *countsHigh, float *countsLow);
FLR_RESULT agcGetTfThresholds(uint16_t *tf_thresholdMin, uint16_t *tf_thresholdMax);
FLR_RESULT agcSetTfThresholds(const uint16_t tf_thresholdMin, const uint16_t tf_thresholdMax);
FLR_RESULT agcGetMode(FLR_AGC_MODE_E *mode);
FLR_RESULT agcSetMode(const FLR_AGC_MODE_E mode);
FLR_RESULT agcSetHighTempAlarmValues(const uint32_t lowGain, const uint32_t highGain, const uint32_t pixPopulation);
FLR_RESULT agcGetContrast(int32_t *contrast);
FLR_RESULT agcSetContrast(const int32_t contrast);
FLR_RESULT agcGetBrightnessBias(int32_t *brightnessBias);
FLR_RESULT agcSetBrightnessBias(const int32_t brightnessBias);
FLR_RESULT agcGetBrightness(int32_t *brightness);
FLR_RESULT agcSetBrightness(const int32_t brightness);
FLR_RESULT agcSetMaxGainForLowGain(const float data);
FLR_RESULT agcGetMaxGainForLowGain(float *data);
FLR_RESULT agcSetRadius(const uint32_t data);
FLR_RESULT agcGetRadius(uint32_t *data);
FLR_RESULT agcSetGmax(const float data);
FLR_RESULT agcGetGmax(float *data);
FLR_RESULT agcSetGmin(const float data);
FLR_RESULT agcGetGmin(float *data);
FLR_RESULT bosonGetCameraSN(uint32_t *data);
FLR_RESULT bosonGetCameraPN(FLR_BOSON_PARTNUMBER_T *data);
FLR_RESULT bosonGetSensorSN(uint32_t *data);
FLR_RESULT bosonRunFFC();
FLR_RESULT bosonSetFFCTempThreshold(const uint16_t data);
FLR_RESULT bosonGetFFCTempThreshold(uint16_t *data);
FLR_RESULT bosonSetFFCFrameThreshold(const uint32_t data);
FLR_RESULT bosonGetFFCFrameThreshold(uint32_t *data);
FLR_RESULT bosonGetFFCInProgress(int16_t *data);
FLR_RESULT bosonReboot();
FLR_RESULT bosonSetFFCMode(const FLR_BOSON_FFCMODE_E ffcMode);
FLR_RESULT bosonGetFFCMode(FLR_BOSON_FFCMODE_E *ffcMode);
FLR_RESULT bosonSetGainMode(const FLR_BOSON_GAINMODE_E gainMode);
FLR_RESULT bosonGetGainMode(FLR_BOSON_GAINMODE_E *gainMode);
FLR_RESULT bosonWriteDynamicHeaderToFlash();
FLR_RESULT bosonReadDynamicHeaderFromFlash();
FLR_RESULT bosonRestoreFactoryDefaultsFromFlash();
FLR_RESULT bosonRestoreFactoryBadPixelsFromFlash();
FLR_RESULT bosonWriteBadPixelsToFlash();
FLR_RESULT bosonGetSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT bosonSetBadPixelLocation(const uint32_t row, const uint32_t col);
FLR_RESULT bosonlookupFPATempDegCx10(int16_t *data);
FLR_RESULT bosonlookupFPATempDegKx10(uint16_t *data);
FLR_RESULT bosonWriteLensNvFfcToFlash();
FLR_RESULT bosonWriteLensGainToFlash();
FLR_RESULT bosonSetLensNumber(const uint32_t lensNumber);
FLR_RESULT bosonGetLensNumber(uint32_t *lensNumber);
FLR_RESULT bosonSetTableNumber(const uint32_t tableNumber);
FLR_RESULT bosonGetTableNumber(uint32_t *tableNumber);
FLR_RESULT bosonGetSensorPN(FLR_BOSON_SENSOR_PARTNUMBER_T *sensorPN);
FLR_RESULT bosonSetGainSwitchParams(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct);
FLR_RESULT bosonGetGainSwitchParams(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct);
FLR_RESULT bosonGetSwitchToHighGainFlag(uint8_t *switchToHighGainFlag);
FLR_RESULT bosonGetSwitchToLowGainFlag(uint8_t *switchToLowGainFlag);
FLR_RESULT bosonGetCLowToHighPercent(uint32_t *cLowToHighPercent);
FLR_RESULT bosonGetMaxNUCTables(uint32_t *maxNUCTables);
FLR_RESULT bosonGetMaxLensTables(uint32_t *maxLensTables);
FLR_RESULT bosonGetFfcWaitCloseFrames(uint16_t *data);
FLR_RESULT bosonSetFfcWaitCloseFrames(const uint16_t data);
FLR_RESULT bosonCheckForTableSwitch();
FLR_RESULT bosonGetDesiredTableNumber(uint32_t *desiredTableNumber);
FLR_RESULT bosonGetFfcStatus(FLR_BOSON_FFCSTATUS_E *ffcStatus);
FLR_RESULT bosonGetFfcDesired(uint32_t *ffcDesired);
FLR_RESULT bosonGetSwRevInHeader(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT bosonGetLastFFCFrameCount(uint32_t *frameCount);
FLR_RESULT bosonGetLastFFCTempDegKx10(uint16_t *temp);
FLR_RESULT bosonGetTableSwitchDesired(uint16_t *tableSwitchDesired);
FLR_RESULT bosonGetOverTempThreshold(float *temperatureInC);
FLR_RESULT bosonGetLowPowerMode(uint16_t *lowPowerMode);
FLR_RESULT bosonGetOverTempEventOccurred(uint16_t *overTempEventOccurred);
FLR_RESULT bosonSetPermitThermalShutdownOverride(const FLR_ENABLE_E permitThermalShutdownOverride);
FLR_RESULT bosonGetPermitThermalShutdownOverride(FLR_ENABLE_E *permitThermalShutdownOverride);
FLR_RESULT bosonGetMyriadTemp(float *myriadTemp);
FLR_RESULT bosonGetNvFFCNucTableNumberLens0(int32_t *nvFFCNucTableNumberLens0);
FLR_RESULT bosonGetNvFFCNucTableNumberLens1(int32_t *nvFFCNucTableNumberLens1);
FLR_RESULT bosonGetNvFFCFPATempDegKx10Lens0(uint16_t *nvFFCFPATempDegKx10Lens0);
FLR_RESULT bosonGetNvFFCFPATempDegKx10Lens1(uint16_t *nvFFCFPATempDegKx10Lens1);
FLR_RESULT bosonSetFFCWarnTimeInSecx10(const uint16_t ffcWarnTime);
FLR_RESULT bosonGetFFCWarnTimeInSecx10(uint16_t *ffcWarnTime);
FLR_RESULT bosonGetOverTempEventCounter(uint32_t *overTempEventCounter);
FLR_RESULT bosonSetOverTempTimerInSec(const uint16_t overTempTimerInSec);
FLR_RESULT bosonGetOverTempTimerInSec(uint16_t *overTempTimerInSec);
FLR_RESULT bosonUnloadCurrentLensCorrections();
FLR_RESULT bosonSetTimeForQuickFFCsInSecs(const uint32_t timeForQuickFFCsInSecs);
FLR_RESULT bosonGetTimeForQuickFFCsInSecs(uint32_t *timeForQuickFFCsInSecs);
FLR_RESULT bosonReloadCurrentLensCorrections();
FLR_RESULT bosonGetBootTimestamps(float *FirstLight, float *StartInit, float *BosonExecDone, float *Timestamp4);
FLR_RESULT bosonSetExtSyncMode(const FLR_BOSON_EXT_SYNC_MODE_E mode);
FLR_RESULT bosonGetExtSyncMode(FLR_BOSON_EXT_SYNC_MODE_E *mode);
FLR_RESULT bosonGetLastCommand(uint32_t *sequenceNum, uint32_t *cmdID);
FLR_RESULT bosonGetSensorHostCalVersion(uint32_t *version);
FLR_RESULT bosonSetDesiredStartupTableNumber(const int32_t table);
FLR_RESULT bosonGetDesiredStartupTableNumber(int32_t *table);
FLR_RESULT bosonSetNvFFCMeanValueLens0(const float meanValue);
FLR_RESULT bosonGetNvFFCMeanValueLens0(float *meanValue);
FLR_RESULT bosonSetNvFFCMeanValueLens1(const float meanValue);
FLR_RESULT bosonGetNvFFCMeanValueLens1(float *meanValue);
FLR_RESULT bosonSetInvertImage(const FLR_ENABLE_E invertImage);
FLR_RESULT bosonGetInvertImage(FLR_ENABLE_E *invertImage);
FLR_RESULT bosonSetRevertImage(const FLR_ENABLE_E revertImage);
FLR_RESULT bosonGetRevertImage(FLR_ENABLE_E *revertImage);
FLR_RESULT bosonGetTimeStamp(const FLR_BOSON_TIMESTAMPTYPE_E timeStampType, float *timeStamp);
FLR_RESULT bosonGetISPFrameCount(uint32_t *ispFrameCount);
FLR_RESULT bosonWriteUserBadPixelsToAllTables();
FLR_RESULT bosonWriteFactoryBadPixelsToAllTables();
FLR_RESULT bosonGetTempDiodeStatus(FLR_BOSON_TEMP_DIODE_STATUS_E *status);
FLR_RESULT bosonClearFactoryBadPixelsInDDR();
FLR_RESULT bosonGetFfcWaitOpenFrames(uint16_t *data);
FLR_RESULT bosonSetFfcWaitOpenFrames(const uint16_t data);
FLR_RESULT bosonGetFfcWaitOpenFlagSettleFrames(uint16_t *data);
FLR_RESULT bosonSetFfcWaitOpenFlagSettleFrames(const uint16_t data);
FLR_RESULT bosonGetTauExtFfcCompatibilityMode(FLR_ENABLE_E *data);
FLR_RESULT bosonSetTauExtFfcCompatibilityMode(const FLR_ENABLE_E data);
FLR_RESULT bosonGetInitialTableSelectionTempOffset(int16_t *data);
FLR_RESULT bosonSetInitialTableSelectionTempOffset(const int16_t data);
FLR_RESULT bosonGetImageValid(int16_t *data);
FLR_RESULT bosonGetCurrentTableType(FLR_BOSON_TABLETYPE_E *data);
FLR_RESULT bosonGetGainSwitchFrameThreshold(uint32_t *data);
FLR_RESULT bosonSetGainSwitchFrameThreshold(const uint32_t data);
FLR_RESULT bosonGetGainSwitchHysteresisTime(float *data);
FLR_RESULT bosonSetGainSwitchHysteresisTime(const float data);
FLR_RESULT bosonGetGainSwitchDesired(uint32_t *data);
FLR_RESULT bosonGetGainSwitchRadiometricParams(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct);
FLR_RESULT bosonSetGainSwitchRadiometricParams(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct);
FLR_RESULT bosonSetSaturationOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT bosonGetSaturationOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT bosonSetSaturationOverrideValue(const uint16_t data);
FLR_RESULT bosonGetSaturationOverrideValue(uint16_t *data);
FLR_RESULT bosonSetffcHighLowGainThresholdMode(const FLR_ENABLE_E data);
FLR_RESULT bosonGetffcHighLowGainThresholdMode(FLR_ENABLE_E *data);
FLR_RESULT bosonSetFFCTempThresholdLowGain(const uint16_t data);
FLR_RESULT bosonGetFFCTempThresholdLowGain(uint16_t *data);
FLR_RESULT bosonSetFFCFrameThresholdLowGain(const uint32_t data);
FLR_RESULT bosonGetFFCFrameThresholdLowGain(uint32_t *data);
FLR_RESULT bosonGetBoardID(uint32_t *data);
FLR_RESULT bosonSetAutoGainSwitchConditions(const FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E data);
FLR_RESULT bosonGetAutoGainSwitchConditions(FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E *data);
FLR_RESULT bosonSetGainSwitchParamsCATS(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct);
FLR_RESULT bosonGetGainSwitchParamsCATS(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct);
FLR_RESULT bosonGetGainSwitchRadiometricParamsCATS(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct);
FLR_RESULT bosonSetGainSwitchRadiometricParamsCATS(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct);
FLR_RESULT bosonGetCLowToHighPercentCATS(uint32_t *cLowToHighPercent);
FLR_RESULT bprGetState(FLR_ENABLE_E *data);
FLR_RESULT bprSetState(const FLR_ENABLE_E data);
FLR_RESULT bprGetStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used);
FLR_RESULT bprGetDisplayMode(FLR_BPR_DISPLAY_MODE_E *data);
FLR_RESULT bprSetDisplayMode(const FLR_BPR_DISPLAY_MODE_E data);
FLR_RESULT bprGetDisplayModeMinValue(uint16_t *data);
FLR_RESULT bprSetDisplayModeMinValue(const uint16_t data);
FLR_RESULT bprGetDisplayModeMaxValue(uint16_t *data);
FLR_RESULT bprSetDisplayModeMaxValue(const uint16_t data);
FLR_RESULT bprGetWorkBufIndex(uint32_t *data);
FLR_RESULT bprSetWorkBufIndex(const uint32_t data);
FLR_RESULT bprGetWorkBufStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used);
FLR_RESULT captureSingleFrame();
FLR_RESULT captureFrames(const FLR_CAPTURE_SETTINGS_T data);
FLR_RESULT captureSingleFrameWithSrc(const FLR_CAPTURE_SRC_E data);
FLR_RESULT captureSingleFrameToFile();
FLR_RESULT captureGetStatus(FLR_CAPTURE_STATUS_T *status);
FLR_RESULT colorLutSetControl(const FLR_ENABLE_E data);
FLR_RESULT colorLutGetControl(FLR_ENABLE_E *data);
FLR_RESULT colorLutSetId(const FLR_COLORLUT_ID_E data);
FLR_RESULT colorLutGetId(FLR_COLORLUT_ID_E *data);
FLR_RESULT colorLutSetOutlineColor(const uint8_t red, const uint8_t green, const uint8_t blue);
FLR_RESULT colorLutGetOutlineColor(uint8_t *red, uint8_t *green, uint8_t *blue);
FLR_RESULT dummyBadCommand();
FLR_RESULT dvoSetAnalogVideoState(const FLR_ENABLE_E analogVideoState);
FLR_RESULT dvoGetAnalogVideoState(FLR_ENABLE_E *analogVideoState);
FLR_RESULT dvoSetOutputFormat(const FLR_DVO_OUTPUT_FORMAT_E format);
FLR_RESULT dvoGetOutputFormat(FLR_DVO_OUTPUT_FORMAT_E *format);
FLR_RESULT dvoSetOutputYCbCrSettings(const FLR_DVO_YCBCR_SETTINGS_T settings);
FLR_RESULT dvoGetOutputYCbCrSettings(FLR_DVO_YCBCR_SETTINGS_T *settings);
FLR_RESULT dvoSetOutputRGBSettings(const FLR_DVO_RGB_SETTINGS_T settings);
FLR_RESULT dvoGetOutputRGBSettings(FLR_DVO_RGB_SETTINGS_T *settings);
FLR_RESULT dvoApplyCustomSettings();
FLR_RESULT dvoSetDisplayMode(const FLR_DVO_DISPLAY_MODE_E displayMode);
FLR_RESULT dvoGetDisplayMode(FLR_DVO_DISPLAY_MODE_E *displayMode);
FLR_RESULT dvoSetType(const FLR_DVO_TYPE_E tap);
FLR_RESULT dvoGetType(FLR_DVO_TYPE_E *tap);
FLR_RESULT dvoSetVideoStandard(const FLR_DVO_VIDEO_STANDARD_E videoStandard);
FLR_RESULT dvoGetVideoStandard(FLR_DVO_VIDEO_STANDARD_E *videoStandard);
FLR_RESULT dvoSetCheckVideoDacPresent(const FLR_ENABLE_E checkVideoDacPresent);
FLR_RESULT dvoGetCheckVideoDacPresent(FLR_ENABLE_E *checkVideoDacPresent);
FLR_RESULT dvoSetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, const FLR_DVO_LCD_CONFIG_T config);
FLR_RESULT dvoGetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, FLR_DVO_LCD_CONFIG_T *config);
FLR_RESULT dvoSetLCDConfig(const FLR_DVO_LCD_CONFIG_ID_E id);
FLR_RESULT dvoGetLCDConfig(FLR_DVO_LCD_CONFIG_ID_E *id);
FLR_RESULT dvoGetClockInfo(uint32_t *horizontalSyncWidth, uint32_t *verticalSyncWidth, uint32_t *clocksPerRowPeriod, uint32_t *horizontalFrontPorch, uint32_t *horizontalBackPorch, uint32_t *frontTelemetryPixels, uint32_t *rearTelemetryPixels, uint32_t *videoColumns, uint32_t *validColumns, uint32_t *telemetryRows, uint32_t *videoRows, uint32_t *validRows, uint32_t *verticalFrontPorch, uint32_t *verticalBackPorch, uint32_t *rowPeriodsPerFrame, uint32_t *clocksPerFrame, float *clockRateInMHz, float *frameRateInHz, uint32_t *validOnRisingEdge, uint32_t *dataWidthInBits);
FLR_RESULT dvoSetAllCustomLcdConfigs(const FLR_DVO_LCD_CONFIG_T config0, const FLR_DVO_LCD_CONFIG_T config1);
FLR_RESULT dvoGetAllCustomLcdConfigs(FLR_DVO_LCD_CONFIG_T *config0, FLR_DVO_LCD_CONFIG_T *config1);
FLR_RESULT dvoSetOutputIr16Format(const FLR_DVO_OUTPUT_IR16_FORMAT_E format);
FLR_RESULT dvoGetOutputIr16Format(FLR_DVO_OUTPUT_IR16_FORMAT_E *format);
FLR_RESULT dvoSetLcdClockRate(const FLR_DVO_LCD_CLOCK_RATE_E clockRate);
FLR_RESULT dvoGetLcdClockRate(FLR_DVO_LCD_CLOCK_RATE_E *clockRate);
FLR_RESULT dvoSetLcdVideoFrameRate(const uint32_t framerate);
FLR_RESULT dvoGetLcdVideoFrameRate(uint32_t *framerate);
FLR_RESULT dvoSetMipiStartState(const FLR_DVO_MIPI_STATE_E state);
FLR_RESULT dvoGetMipiStartState(FLR_DVO_MIPI_STATE_E *state);
FLR_RESULT dvoSetMipiState(const FLR_DVO_MIPI_STATE_E state);
FLR_RESULT dvoGetMipiState(FLR_DVO_MIPI_STATE_E *state);
FLR_RESULT dvoSetMipiClockLaneMode(const FLR_DVO_MIPI_CLOCK_LANE_MODE_E mode);
FLR_RESULT dvoGetMipiClockLaneMode(FLR_DVO_MIPI_CLOCK_LANE_MODE_E *mode);
FLR_RESULT dvoSetOutputInterface(const FLR_DVO_OUTPUT_INTERFACE_E format);
FLR_RESULT dvoGetOutputInterface(FLR_DVO_OUTPUT_INTERFACE_E *format);
FLR_RESULT dvoSetOutputFormatVC1(const FLR_DVO_OUTPUT_FORMAT_E format);
FLR_RESULT dvoGetOutputFormatVC1(FLR_DVO_OUTPUT_FORMAT_E *format);
FLR_RESULT dvoMuxSetType(const FLR_DVOMUX_OUTPUT_IF_E output, const FLR_DVOMUX_SOURCE_E source, const FLR_DVOMUX_TYPE_E type);
FLR_RESULT dvoMuxGetType(const FLR_DVOMUX_OUTPUT_IF_E output, FLR_DVOMUX_SOURCE_E *source, FLR_DVOMUX_TYPE_E *type);
FLR_RESULT fileOpsDir(uint8_t *dirent);
FLR_RESULT fileOpsCd(const uint8_t path[], uint8_t *pwd);
FLR_RESULT fileOpsMd(const uint8_t path[]);
FLR_RESULT fileOpsFopen(const uint8_t path[], const uint8_t mode[], uint32_t *id);
FLR_RESULT fileOpsFclose(const uint32_t id);
FLR_RESULT fileOpsFread(const uint32_t id, const uint32_t length, uint8_t *buf, uint32_t *ret);
FLR_RESULT fileOpsFwrite(const uint32_t id, const uint32_t length, const uint8_t buf[], uint32_t *ret);
FLR_RESULT fileOpsFtell(const uint32_t id, uint32_t *offset);
FLR_RESULT fileOpsFseek(const uint32_t id, const uint32_t offset, const uint32_t origin);
FLR_RESULT fileOpsFtruncate(const uint32_t id, const uint32_t length);
FLR_RESULT fileOpsRmdir(const uint8_t path[]);
FLR_RESULT fileOpsRm(const uint8_t path[]);
FLR_RESULT fileOpsRename(const uint8_t oldpath[], const uint8_t newpath[]);
FLR_RESULT fileOpsGetFileSize(const uint8_t path[], uint32_t *fileLength);
FLR_RESULT flashIOSetProtectionState(const FLR_ENABLE_E protectionState);
FLR_RESULT flashIOGetProtectionState(FLR_ENABLE_E *protectionState);
FLR_RESULT flashMapFsGetHeaderVersion(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT gaoSetGainState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetGainState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetFfcState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetFfcState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetTempCorrectionState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetTempCorrectionState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetIConstL(const int16_t data);
FLR_RESULT gaoGetIConstL(int16_t *data);
FLR_RESULT gaoSetIConstM(const int16_t data);
FLR_RESULT gaoGetIConstM(int16_t *data);
FLR_RESULT gaoSetAveragerState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetAveragerState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetNumFFCFrames(const uint16_t data);
FLR_RESULT gaoGetNumFFCFrames(uint16_t *data);
FLR_RESULT gaoGetAveragerThreshold(uint16_t *data);
FLR_RESULT gaoSetTestRampState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetTestRampState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetSffcState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetSffcState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetNucType(const FLR_GAO_NUC_TYPE_E nucType);
FLR_RESULT gaoGetNucType(FLR_GAO_NUC_TYPE_E *nucType);
FLR_RESULT gaoSetFfcZeroMeanState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetFfcZeroMeanState(FLR_ENABLE_E *data);
FLR_RESULT gaoGetAveragerDesiredState(FLR_ENABLE_E *data);
FLR_RESULT gaoGetAppliedClip(uint16_t *data);
FLR_RESULT gaoSetAppliedClipEnable(const FLR_ENABLE_E data);
FLR_RESULT gaoGetAppliedClipEnable(FLR_ENABLE_E *data);
FLR_RESULT gaoSetFfcShutterSimulationState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetFfcShutterSimulationState(FLR_ENABLE_E *data);
FLR_RESULT gaoSetFfcShutterSimulatorValue(const uint16_t value);
FLR_RESULT gaoGetFfcShutterSimulatorValue(uint16_t *value);
FLR_RESULT gaoSetBcnrState(const FLR_ENABLE_E data);
FLR_RESULT gaoGetBcnrState(FLR_ENABLE_E *data);
FLR_RESULT gaoGetAppliedSffcScaleFactor(float *data);
FLR_RESULT gaoSetSffcMode(const FLR_GAO_SFFC_MODE_E mode);
FLR_RESULT gaoGetSffcMode(FLR_GAO_SFFC_MODE_E *mode);
FLR_RESULT imageStatsGetTotalHistPixelsInROI(uint32_t *totalPixelsInROI);
FLR_RESULT imageStatsGetPopBelowLowToHighThresh(uint32_t *popBelowLowToHighThresh);
FLR_RESULT imageStatsGetPopAboveHighToLowThresh(uint32_t *popAboveHighToLowThresh);
FLR_RESULT imageStatsSetROI(const FLR_ROI_T roi);
FLR_RESULT imageStatsGetROI(FLR_ROI_T *roi);
FLR_RESULT imageStatsGetFirstBin(uint16_t *firstBin);
FLR_RESULT imageStatsGetLastBin(uint16_t *lastBin);
FLR_RESULT imageStatsGetMean(uint16_t *mean);
FLR_RESULT imageStatsGetFirstBinInROI(uint16_t *firstBinInROI);
FLR_RESULT imageStatsGetLastBinInROI(uint16_t *lastBinInROI);
FLR_RESULT imageStatsGetMeanInROI(uint16_t *meanInROI);
FLR_RESULT imageStatsGetImageStats(uint16_t *meanIntensity, uint16_t *peakIntensity, uint16_t *baseIntensity);
FLR_RESULT imageStatsGetPopAboveLowToHighThreshCATS(uint32_t *popAboveLowToHighThresh);
FLR_RESULT imageStatsGetPopBelowHighToLowThreshCATS(uint32_t *popBelowHighToLowThresh);
FLR_RESULT imageStatsGetPopBetweenLthCATSAndLthSATS(uint32_t *popBetweenCatsAndSats);
FLR_RESULT isothermGetEnable(FLR_ENABLE_E *isothermEnable);
FLR_RESULT isothermSetEnable(const FLR_ENABLE_E isothermEnable);
FLR_RESULT isothermSetTemps(const FLR_ISOTHERM_GAIN_E table, const int32_t thIsoT1, const int32_t thIsoT2, const int32_t thIsoT3, const int32_t thIsoT4, const int32_t thIsoT5);
FLR_RESULT isothermGetTemps(const FLR_ISOTHERM_GAIN_E table, int32_t *thIsoT1, int32_t *thIsoT2, int32_t *thIsoT3, int32_t *thIsoT4, int32_t *thIsoT5);
FLR_RESULT isothermSetIsoColorValues(const FLR_ISOTHERM_GAIN_E table, const FLR_ISOTHERM_COLORS_T region0, const FLR_ISOTHERM_COLORS_T region1, const FLR_ISOTHERM_COLORS_T region2, const FLR_ISOTHERM_COLORS_T region3, const FLR_ISOTHERM_COLORS_T region4, const FLR_ISOTHERM_COLORS_T region5);
FLR_RESULT isothermGetIsoColorValues(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_COLORS_T *region0, FLR_ISOTHERM_COLORS_T *region1, FLR_ISOTHERM_COLORS_T *region2, FLR_ISOTHERM_COLORS_T *region3, FLR_ISOTHERM_COLORS_T *region4, FLR_ISOTHERM_COLORS_T *region5);
FLR_RESULT isothermSetRegionMode(const FLR_ISOTHERM_GAIN_E table, const FLR_ISOTHERM_REGION_E region0, const FLR_ISOTHERM_REGION_E region1, const FLR_ISOTHERM_REGION_E region2, const FLR_ISOTHERM_REGION_E region3, const FLR_ISOTHERM_REGION_E region4, const FLR_ISOTHERM_REGION_E region5);
FLR_RESULT isothermGetRegionMode(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_REGION_E *region0, FLR_ISOTHERM_REGION_E *region1, FLR_ISOTHERM_REGION_E *region2, FLR_ISOTHERM_REGION_E *region3, FLR_ISOTHERM_REGION_E *region4, FLR_ISOTHERM_REGION_E *region5);
FLR_RESULT isothermGetUnit(FLR_ISOTHERM_UNIT_E *unit);
FLR_RESULT isothermSetUnit(const FLR_ISOTHERM_UNIT_E unit);
FLR_RESULT isothermGetSettingsLowGain(FLR_ISOTHERM_SETTINGS_T *settings);
FLR_RESULT isothermSetSettingsLowGain(const FLR_ISOTHERM_SETTINGS_T settings);
FLR_RESULT isothermGetSettingsHighGain(FLR_ISOTHERM_SETTINGS_T *settings);
FLR_RESULT isothermSetSettingsHighGain(const FLR_ISOTHERM_SETTINGS_T settings);
FLR_RESULT isothermSetColorLutId(const FLR_COLORLUT_ID_E colorLutIdLowGain, const FLR_COLORLUT_ID_E colorLutIdHighGain);
FLR_RESULT isothermGetColorLutId(FLR_COLORLUT_ID_E *colorLutIdLowGain, FLR_COLORLUT_ID_E *colorLutIdHighGain);
FLR_RESULT jffs2Mount();
FLR_RESULT jffs2Unmount();
FLR_RESULT jffs2GetState(FLR_JFFS2_STATE_E *state);
FLR_RESULT latencyCtrlSetLowLatencyState(const FLR_ENABLE_E data);
FLR_RESULT latencyCtrlGetLowLatencyState(FLR_ENABLE_E *data);
FLR_RESULT latencyCtrlSetJitterReduction(const FLR_ENABLE_E enable, const int32_t line);
FLR_RESULT latencyCtrlGetJitterReduction(FLR_ENABLE_E *enable, int32_t *line);
FLR_RESULT latencyCtrlLatencyResetStats();
FLR_RESULT latencyCtrlGetJitter(float *jitterMin, float *jitterMax);
FLR_RESULT latencyCtrlGetLatency(float *latencyMin, float *latencyMax);
FLR_RESULT latencyCtrlSetUsbVideoLatencyReduction(const int32_t line);
FLR_RESULT latencyCtrlGetUsbVideoLatencyReduction(int32_t *line);
FLR_RESULT lfsrSetApplyOffsetEnableState(const FLR_ENABLE_E data);
FLR_RESULT lfsrGetApplyOffsetEnableState(FLR_ENABLE_E *data);
FLR_RESULT lfsrSetMaxIterations(const uint32_t data);
FLR_RESULT lfsrGetMaxIterations(uint32_t *data);
FLR_RESULT lfsrSetDf(const uint32_t data);
FLR_RESULT lfsrGetDf(uint32_t *data);
FLR_RESULT lfsrSetLambda1(const float data);
FLR_RESULT lfsrGetLambda1(float *data);
FLR_RESULT lfsrSetLambda2(const float data);
FLR_RESULT lfsrGetLambda2(float *data);
FLR_RESULT lfsrSetHaltEnable(const FLR_ENABLE_E data);
FLR_RESULT lfsrGetHaltEnable(FLR_ENABLE_E *data);
FLR_RESULT lfsrSetRandomMethod(const uint32_t data);
FLR_RESULT lfsrGetRandomMethod(uint32_t *data);
FLR_RESULT lfsrSetSingleStepEnable(const FLR_ENABLE_E data);
FLR_RESULT lfsrGetSingleStepEnable(FLR_ENABLE_E *data);
FLR_RESULT lfsrSetR_LocalBump(const float data);
FLR_RESULT lfsrGetR_LocalBump(float *data);
FLR_RESULT lfsrSetR_CornerBump(const float data);
FLR_RESULT lfsrGetR_CornerBump(float *data);
FLR_RESULT lfsrSetFFC_ResetEnable(const FLR_ENABLE_E data);
FLR_RESULT lfsrGetFFC_ResetEnable(FLR_ENABLE_E *data);
FLR_RESULT lfsrSetNormalizeAtCenterSpotState(const FLR_ENABLE_E data);
FLR_RESULT lfsrGetNormalizeAtCenterSpotState(FLR_ENABLE_E *data);
FLR_RESULT memReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT memGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT memWriteFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT memReadFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT memGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes);
FLR_RESULT memEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index);
FLR_RESULT memEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length);
FLR_RESULT memReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT memGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT memGetCaptureSizeSrc(const FLR_CAPTURE_SRC_E src, uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT memReadCaptureSrc(const FLR_CAPTURE_SRC_E src, const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT radiometrySetTempStableEnable(const FLR_ENABLE_E data);
FLR_RESULT radiometryGetTempStableEnable(FLR_ENABLE_E *data);
FLR_RESULT radiometrySetFNumberLens0(const float data);
FLR_RESULT radiometryGetFNumberLens0(float *data);
FLR_RESULT radiometrySetFNumberLens1(const float data);
FLR_RESULT radiometryGetFNumberLens1(float *data);
FLR_RESULT radiometrySetTauLens0(const float data);
FLR_RESULT radiometryGetTauLens0(float *data);
FLR_RESULT radiometrySetTauLens1(const float data);
FLR_RESULT radiometryGetTauLens1(float *data);
FLR_RESULT radiometryGetGlobalGainDesired(float *data);
FLR_RESULT radiometryGetGlobalOffsetDesired(float *data);
FLR_RESULT radiometryGetGlobalGainApplied(float *data);
FLR_RESULT radiometryGetGlobalOffsetApplied(float *data);
FLR_RESULT radiometrySetTComponentOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT radiometryGetTComponentOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT radiometrySetGlobalGainOverride(const float data);
FLR_RESULT radiometryGetGlobalGainOverride(float *data);
FLR_RESULT radiometrySetGlobalOffsetOverride(const uint16_t data);
FLR_RESULT radiometryGetGlobalOffsetOverride(uint16_t *data);
FLR_RESULT radiometrySetGlobalParamOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT radiometryGetGlobalParamOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT radiometrySetRBFOHighGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT radiometryGetRBFOHighGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT radiometrySetRBFOLowGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT radiometryGetRBFOLowGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT radiometrySetRBFOHighGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT radiometryGetRBFOHighGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT radiometrySetRBFOLowGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT radiometryGetRBFOLowGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT radiometrySetDampingFactor(const float data);
FLR_RESULT radiometryGetDampingFactor(float *data);
FLR_RESULT radiometryGetGoMEQ(float *data);
FLR_RESULT radiometryGetGoMShutter(float *data);
FLR_RESULT radiometryGetGoMLens(float *data);
FLR_RESULT radiometryGetGoMLG(float *data);
FLR_RESULT radiometryGetGoMFFC(float *data);
FLR_RESULT radiometryGetTempLensHousing(float *data);
FLR_RESULT radiometryGetTempShutterHousing(float *data);
FLR_RESULT radiometryGetTempShutterPaddle(float *data);
FLR_RESULT radiometrySetFNumberShutterHousing(const float data);
FLR_RESULT radiometryGetFNumberShutterHousing(float *data);
FLR_RESULT radiometrySetEmissivityShutterHousing(const float data);
FLR_RESULT radiometryGetEmissivityShutterHousing(float *data);
FLR_RESULT radiometrySetM_DTfpa_Lens(const float data);
FLR_RESULT radiometryGetM_DTfpa_Lens(float *data);
FLR_RESULT radiometrySetOffset_Lens(const float data);
FLR_RESULT radiometryGetOffset_Lens(float *data);
FLR_RESULT radiometrySetM_Recursive_Lens(const float data);
FLR_RESULT radiometryGetM_Recursive_Lens(float *data);
FLR_RESULT radiometryGetGgFfc(float *data);
FLR_RESULT radiometryGetCountsFromTemp(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const float temp, uint16_t *counts);
FLR_RESULT radiometryGetTempFromCounts(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const uint16_t counts, float *temp);
FLR_RESULT radiometrySetTempLensHousingOverride(const float data);
FLR_RESULT radiometryGetTempLensHousingOverride(float *data);
FLR_RESULT radiometrySetTempShutterHousingOverride(const float data);
FLR_RESULT radiometryGetTempShutterHousingOverride(float *data);
FLR_RESULT radiometrySetTempShutterPaddleOverride(const float data);
FLR_RESULT radiometryGetTempShutterPaddleOverride(float *data);
FLR_RESULT radiometrySetSignalFactorLut(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T data);
FLR_RESULT radiometryGetSignalFactorLut(FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *data);
FLR_RESULT radiometrySetNoiseFactorLut(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T data);
FLR_RESULT radiometryGetNoiseFactorLut(FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *data);
FLR_RESULT radiometrySetM_tfpaK(const float data);
FLR_RESULT radiometryGetM_tfpaK(float *data);
FLR_RESULT radiometrySetB_tfpaK(const float data);
FLR_RESULT radiometryGetB_tfpaK(float *data);
FLR_RESULT radiometrySetTAuxParams(const FLR_RADIOMETRY_TAUX_PARAMS_T data);
FLR_RESULT radiometryGetTAuxParams(FLR_RADIOMETRY_TAUX_PARAMS_T *data);
FLR_RESULT radiometrySetM_tAux(const float data);
FLR_RESULT radiometryGetM_tAux(float *data);
FLR_RESULT radiometrySetB_tAux(const float data);
FLR_RESULT radiometryGetB_tAux(float *data);
FLR_RESULT radiometrySetTsource_FFC(const float data);
FLR_RESULT radiometryGetTsource_FFC(float *data);
FLR_RESULT radiometrySetM_DTfpa_Sh_h(const float data);
FLR_RESULT radiometryGetM_DTfpa_Sh_h(float *data);
FLR_RESULT radiometrySetOffset_Sh_h(const float data);
FLR_RESULT radiometryGetOffset_Sh_h(float *data);
FLR_RESULT radiometrySetM_Recursive_Sh_h(const float data);
FLR_RESULT radiometryGetM_Recursive_Sh_h(float *data);
FLR_RESULT radiometrySetM_DTfpa_Sh_p(const float data);
FLR_RESULT radiometryGetM_DTfpa_Sh_p(float *data);
FLR_RESULT radiometrySetOffset_Sh_p(const float data);
FLR_RESULT radiometryGetOffset_Sh_p(float *data);
FLR_RESULT radiometrySetM_Recursive_Sh_p(const float data);
FLR_RESULT radiometryGetM_Recursive_Sh_p(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_p(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_p(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_p(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_p(float *data);
FLR_RESULT radiometryGetDtTfpaK(float *data);
FLR_RESULT radiometryGetDtTfpaK_Damp(float *data);
FLR_RESULT radiometryGetTAuxK(float *data);
FLR_RESULT radiometrySetExternalFfcUpdateMode(const FLR_ENABLE_E data);
FLR_RESULT radiometryGetExternalFfcUpdateMode(FLR_ENABLE_E *data);
FLR_RESULT radiometryGetGG_scale(float *data);
FLR_RESULT radiometrySetTempWindow(const float data);
FLR_RESULT radiometryGetTempWindow(float *data);
FLR_RESULT radiometrySetTransmissionWindow(const float data);
FLR_RESULT radiometryGetTransmissionWindow(float *data);
FLR_RESULT radiometrySetReflectivityWindow(const float data);
FLR_RESULT radiometryGetReflectivityWindow(float *data);
FLR_RESULT radiometrySetTempWindowReflection(const float data);
FLR_RESULT radiometryGetTempWindowReflection(float *data);
FLR_RESULT radiometrySetTransmissionAtmosphere(const float data);
FLR_RESULT radiometryGetTransmissionAtmosphere(float *data);
FLR_RESULT radiometrySetTempAtmosphere(const float data);
FLR_RESULT radiometryGetTempAtmosphere(float *data);
FLR_RESULT radiometrySetEmissivityTarget(const float data);
FLR_RESULT radiometryGetEmissivityTarget(float *data);
FLR_RESULT radiometrySetTempBackground(const float data);
FLR_RESULT radiometryGetTempBackground(float *data);
FLR_RESULT radiometryGetRadiometryCapable(FLR_ENABLE_E *data);
FLR_RESULT radiometrySetdeltaTempDampingFactor(const float data);
FLR_RESULT radiometryGetdeltaTempDampingFactor(float *data);
FLR_RESULT radiometrySetdeltaTempIntervalTime(const float data);
FLR_RESULT radiometryGetdeltaTempIntervalTime(float *data);
FLR_RESULT radiometrySetdeltaTempMaxValue(const float data);
FLR_RESULT radiometryGetdeltaTempMaxValue(float *data);
FLR_RESULT radiometrySetdeltaTempMaxIncrement(const float data);
FLR_RESULT radiometryGetdeltaTempMaxIncrement(float *data);
FLR_RESULT radiometrySetdeltaTempDampingTime(const float data);
FLR_RESULT radiometryGetdeltaTempDampingTime(float *data);
FLR_RESULT radiometryGetResponsivityFpaTemp(float *data);
FLR_RESULT radiometrySetM_Delta_Lens(const float data);
FLR_RESULT radiometryGetM_Delta_Lens(float *data);
FLR_RESULT radiometrySetB_Delta_Lens(const float data);
FLR_RESULT radiometryGetB_Delta_Lens(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_h(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_h(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_h(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_h(float *data);
FLR_RESULT radiometrySetGG_Scale_HG(const float data);
FLR_RESULT radiometryGetGG_Scale_HG(float *data);
FLR_RESULT radiometrySetGG_Scale_LG(const float data);
FLR_RESULT radiometryGetGG_Scale_LG(float *data);
FLR_RESULT radiometrySetRbfoScaledMode(const FLR_ENABLE_E data);
FLR_RESULT radiometryGetRbfoScaledMode(FLR_ENABLE_E *data);
FLR_RESULT radiometryGetUncertaintyFactor(FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E *data);
FLR_RESULT radiometryGetTRoomMinThresh(float *data);
FLR_RESULT radiometryGetTRoomMaxThresh(float *data);
FLR_RESULT radiometryGetTOperatingMinThresh(float *data);
FLR_RESULT radiometryGetTOperatingMaxThresh(float *data);
FLR_RESULT radiometryGetStableTempThresh(float *data);
FLR_RESULT radiometryGetSlowDriftThresh(float *data);
FLR_RESULT radiometryGetFfcTempThresh(float *data);
FLR_RESULT radiometryGetTargetTempMinThreshLG(float *data);
FLR_RESULT radiometryGetTargetTempMaxThreshLG(float *data);
FLR_RESULT radiometryGetMFactorThresh(float *data);
FLR_RESULT radiometryGetTargetTempMinThreshHG(float *data);
FLR_RESULT radiometryGetTargetTempMaxThreshHG(float *data);
FLR_RESULT radiometryGetUncertaintyStatusBits(uint16_t *data);
FLR_RESULT radiometrySetTemperatureOffset_HG(const float data);
FLR_RESULT radiometryGetTemperatureOffset_HG(float *data);
FLR_RESULT radiometrySetTemperatureOffset_LG(const float data);
FLR_RESULT radiometryGetTemperatureOffset_LG(float *data);
FLR_RESULT radiometrySetM_Delta_Lens_HG(const float data);
FLR_RESULT radiometryGetM_Delta_Lens_HG(float *data);
FLR_RESULT radiometrySetB_Delta_Lens_HG(const float data);
FLR_RESULT radiometryGetB_Delta_Lens_HG(float *data);
FLR_RESULT radiometrySetM_Delta_Lens_LG(const float data);
FLR_RESULT radiometryGetM_Delta_Lens_LG(float *data);
FLR_RESULT radiometrySetB_Delta_Lens_LG(const float data);
FLR_RESULT radiometryGetB_Delta_Lens_LG(float *data);
FLR_RESULT radiometrySetOffset_Lens_HG(const float data);
FLR_RESULT radiometryGetOffset_Lens_HG(float *data);
FLR_RESULT radiometrySetOffset_Lens_LG(const float data);
FLR_RESULT radiometryGetOffset_Lens_LG(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_p_HG(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_p_HG(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_p_HG(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_p_HG(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_p_LG(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_p_LG(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_p_LG(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_p_LG(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_h_HG(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_h_HG(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_h_HG(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_h_HG(float *data);
FLR_RESULT radiometrySetM_Delta_Sh_h_LG(const float data);
FLR_RESULT radiometryGetM_Delta_Sh_h_LG(float *data);
FLR_RESULT radiometrySetB_Delta_Sh_h_LG(const float data);
FLR_RESULT radiometryGetB_Delta_Sh_h_LG(float *data);
FLR_RESULT radiometryGetGG_RoomTemp(float *data);
FLR_RESULT roicGetFPATemp(uint16_t *data);
FLR_RESULT roicGetFrameCount(uint32_t *data);
FLR_RESULT roicGetActiveNormalizationTarget(uint16_t *data);
FLR_RESULT roicSetFPARampState(const FLR_ENABLE_E state);
FLR_RESULT roicGetFPARampState(FLR_ENABLE_E *state);
FLR_RESULT roicGetSensorADC1(uint16_t *data);
FLR_RESULT roicGetSensorADC2(uint16_t *data);
FLR_RESULT roicSetFPATempOffset(const int16_t data);
FLR_RESULT roicGetFPATempOffset(int16_t *data);
FLR_RESULT roicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data);
FLR_RESULT roicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data);
FLR_RESULT roicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table);
FLR_RESULT roicSetFPATempValue(const uint16_t data);
FLR_RESULT roicGetFPATempValue(uint16_t *data);
FLR_RESULT roicGetPreambleError(uint32_t *preambleError);
FLR_RESULT roicInducePreambleError(const uint32_t everyNthFrame);
FLR_RESULT roicGetRoicStarted(FLR_ENABLE_E *roicStarted);
FLR_RESULT roicSetFrameSkip(const uint16_t data);
FLR_RESULT roicGetFrameSkip(uint16_t *data);
FLR_RESULT roicSetFrameOneShot();
FLR_RESULT scalerGetMaxZoom(uint32_t *zoom);
FLR_RESULT scalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams);
FLR_RESULT scalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams);
FLR_RESULT scalerSetFractionalZoom(const uint32_t zoomNumerator, const uint32_t zoomDenominator, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable);
FLR_RESULT scalerSetIndexZoom(const uint32_t zoomIndex, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable);
FLR_RESULT scnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT scnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT scnrSetThColSum(const uint16_t data);
FLR_RESULT scnrGetThColSum(uint16_t *data);
FLR_RESULT scnrSetThPixel(const uint16_t data);
FLR_RESULT scnrGetThPixel(uint16_t *data);
FLR_RESULT scnrSetMaxCorr(const uint16_t data);
FLR_RESULT scnrGetMaxCorr(uint16_t *data);
FLR_RESULT scnrGetThPixelApplied(uint16_t *data);
FLR_RESULT scnrGetMaxCorrApplied(uint16_t *data);
FLR_RESULT scnrSetThColSumSafe(const uint16_t data);
FLR_RESULT scnrGetThColSumSafe(uint16_t *data);
FLR_RESULT scnrSetThPixelSafe(const uint16_t data);
FLR_RESULT scnrGetThPixelSafe(uint16_t *data);
FLR_RESULT scnrSetMaxCorrSafe(const uint16_t data);
FLR_RESULT scnrGetMaxCorrSafe(uint16_t *data);
FLR_RESULT scnrSetCorrectionMethod(const FLR_SCNR_CORR_SELECT_E data);
FLR_RESULT scnrGetCorrectionMethod(FLR_SCNR_CORR_SELECT_E *data);
FLR_RESULT scnrSetStdThreshold(const uint16_t data);
FLR_RESULT scnrGetStdThreshold(uint16_t *data);
FLR_RESULT scnrSetNFrames(const uint32_t data);
FLR_RESULT scnrGetNFrames(uint32_t *data);
FLR_RESULT scnrSetResetDesired(const uint32_t data);
FLR_RESULT scnrGetResetDesired(uint32_t *data);
FLR_RESULT scnrSetM_modeOnly(const uint32_t data);
FLR_RESULT scnrGetM_modeOnly(uint32_t *data);
FLR_RESULT scnrGetMode(FLR_SCNR_MODE_E *data);
FLR_RESULT scnrSetSpecklesEnableState(const FLR_ENABLE_E data);
FLR_RESULT scnrGetSpecklesEnableState(FLR_ENABLE_E *data);
FLR_RESULT scnrSetSpecklesThreshold(const uint32_t data);
FLR_RESULT scnrGetSpecklesThreshold(uint32_t *data);
FLR_RESULT scnrSetSpecklesRatio(const float data);
FLR_RESULT scnrGetSpecklesRatio(float *data);
FLR_RESULT scnrSetSpecklesDF(const float data);
FLR_RESULT scnrGetSpecklesDF(float *data);
FLR_RESULT scnrGetSpecklesDiffsBufferAddr(uint32_t *data);
FLR_RESULT scnrGetSpecklesOffsBufferAddr(uint32_t *data);
FLR_RESULT scnrSetSpecklesResetDesired(const FLR_ENABLE_E data);
FLR_RESULT scnrGetSpecklesResetDesired(FLR_ENABLE_E *data);
FLR_RESULT sffcGetScaleFactor(float *data);
FLR_RESULT sffcGetDeltaTempLinearCoeff(float *data);
FLR_RESULT sffcSetDeltaTempLinearCoeff(const float data);
FLR_RESULT sffcGetDeltaTempOffsetCoeff(float *data);
FLR_RESULT sffcSetDeltaTempOffsetCoeff(const float data);
FLR_RESULT sffcGetFpaTempLinearCoeff(float *data);
FLR_RESULT sffcSetFpaTempLinearCoeff(const float data);
FLR_RESULT sffcGetFpaTempOffsetCoeff(float *data);
FLR_RESULT sffcSetFpaTempOffsetCoeff(const float data);
FLR_RESULT sffcGetDeltaTempTimeLimitInSecs(uint32_t *data);
FLR_RESULT sffcSetDeltaTempTimeLimitInSecs(const uint32_t data);
FLR_RESULT spnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT spnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT spnrGetState(FLR_SPNR_STATE_E *data);
FLR_RESULT spnrSetFrameDelay(const uint32_t data);
FLR_RESULT spnrGetFrameDelay(uint32_t *data);
FLR_RESULT spnrSetSF(const float sf);
FLR_RESULT spnrGetSF(float *sf);
FLR_RESULT spnrGetSFApplied(float *sf);
FLR_RESULT spnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data);
FLR_RESULT spnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data);
FLR_RESULT spnrSetSFMin(const float sfmin);
FLR_RESULT spnrGetSFMin(float *sfmin);
FLR_RESULT spnrSetSFMax(const float sfmax);
FLR_RESULT spnrGetSFMax(float *sfmax);
FLR_RESULT spnrSetDFMin(const float dfmin);
FLR_RESULT spnrGetDFMin(float *dfmin);
FLR_RESULT spnrSetDFMax(const float dfmax);
FLR_RESULT spnrGetDFMax(float *dfmax);
FLR_RESULT spnrSetNormTarget(const float normTarget);
FLR_RESULT spnrGetNormTarget(float *normTarget);
FLR_RESULT spnrGetNormTargetApplied(float *normTargetApplied);
FLR_RESULT spnrSetThPix(const uint16_t th_pix);
FLR_RESULT spnrGetThPix(uint16_t *th_pix);
FLR_RESULT spnrSetThPixSum(const uint16_t th_pixSum);
FLR_RESULT spnrGetThPixSum(uint16_t *th_pixSum);
FLR_RESULT spnrSetMaxcorr(const uint16_t maxcorr);
FLR_RESULT spnrGetMaxcorr(uint16_t *maxcorr);
FLR_RESULT spnrGetAlgorithm(FLR_SPNR_ALGORITHM_E *data);
FLR_RESULT spnrSetAlgorithmDesired(const FLR_SPNR_ALGORITHM_E data);
FLR_RESULT spnrGetAlgorithmDesired(FLR_SPNR_ALGORITHM_E *data);
FLR_RESULT spnrSetDFFast(const float dffast);
FLR_RESULT spnrGetDFFast(float *dffast);
FLR_RESULT spnrSetDFSlow(const float dfslow);
FLR_RESULT spnrGetDFSlow(float *dfslow);
FLR_RESULT spnrSetSensitivityThreshold(const float threshold);
FLR_RESULT spnrGetSensitivityThreshold(float *threshold);
FLR_RESULT spnrSetReset(const FLR_SPNR_RESET_E resetType);
FLR_RESULT spotMeterSetEnable(const FLR_ENABLE_E data);
FLR_RESULT spotMeterGetEnable(FLR_ENABLE_E *data);
FLR_RESULT spotMeterGetRoiMaxSize(uint16_t *width, uint16_t *height);
FLR_RESULT spotMeterSetRoi(const FLR_ROI_T roi);
FLR_RESULT spotMeterGetRoi(FLR_ROI_T *roi);
FLR_RESULT spotMeterGetSpotStats(uint16_t *mean, uint16_t *deviation, FLR_SPOTMETER_SPOT_PARAM_T *min, FLR_SPOTMETER_SPOT_PARAM_T *max);
FLR_RESULT spotMeterSetStatsMode(const FLR_SPOTMETER_STATS_TEMP_MODE_E mode);
FLR_RESULT spotMeterGetStatsMode(FLR_SPOTMETER_STATS_TEMP_MODE_E *mode);
FLR_RESULT spotMeterGetTempStats(float *mean, float *deviation, FLR_SPOTMETER_STAT_PARAM_TEMP_T *min, FLR_SPOTMETER_STAT_PARAM_TEMP_T *max);
FLR_RESULT srnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT srnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT srnrSetThRowSum(const uint16_t data);
FLR_RESULT srnrGetThRowSum(uint16_t *data);
FLR_RESULT srnrSetThPixel(const uint16_t data);
FLR_RESULT srnrGetThPixel(uint16_t *data);
FLR_RESULT srnrSetMaxCorr(const uint16_t data);
FLR_RESULT srnrGetMaxCorr(uint16_t *data);
FLR_RESULT srnrGetThPixelApplied(uint16_t *data);
FLR_RESULT srnrGetMaxCorrApplied(uint16_t *data);
FLR_RESULT symbologySetEnable(const FLR_ENABLE_E draw_symbols);
FLR_RESULT symbologyCreateBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height);
FLR_RESULT symbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[]);
FLR_RESULT symbologyCreateArc(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const float start_angle, const float end_angle, const uint32_t color);
FLR_RESULT symbologyCreateText(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint8_t text[]);
FLR_RESULT symbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT symbologyAddToGroup(const uint8_t ID, const uint8_t group_ID);
FLR_RESULT symbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID);
FLR_RESULT symbologyUpdateAndShow(const uint8_t ID, const uint8_t visible);
FLR_RESULT symbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible);
FLR_RESULT symbologyDelete(const uint8_t ID);
FLR_RESULT symbologyDeleteGroup(const uint8_t group_ID);
FLR_RESULT symbologyCreateFilledRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT symbologyCreateOutlinedRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT symbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size);
FLR_RESULT symbologyCreateCompressedBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height);
FLR_RESULT symbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[]);
FLR_RESULT symbologyCreateBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType);
FLR_RESULT symbologyResetWritePosition(const uint8_t ID);
FLR_RESULT symbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y);
FLR_RESULT symbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y);
FLR_RESULT symbologyCreateFilledEllipse(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT symbologyCreateLine(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color);
FLR_RESULT symbologySetZorder(const uint8_t ID, const uint8_t zorder);
FLR_RESULT symbologySaveConfiguration();
FLR_RESULT symbologyReloadConfiguration();
FLR_RESULT symbologyGetEnable(FLR_ENABLE_E *draw_symbols);
FLR_RESULT symbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones);
FLR_RESULT symbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT symbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT symbologySetTransformation(const FLR_SYMBOLOGY_TRANSFORMATION_E transformation);
FLR_RESULT symbologyUpdateAllVisible();
FLR_RESULT symbologySetSizeAndScalingMode(const uint8_t ID, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode);
FLR_RESULT symbologyCreateLineHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color1, const uint32_t color2, const uint16_t dashLen, const uint16_t thickness);
FLR_RESULT symbologyCreateTextHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color1, const uint32_t color2, const uint8_t dashLen, const uint8_t text[]);
FLR_RESULT symbologyCreateTextBg(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint32_t bgColor, const uint8_t text[]);
FLR_RESULT symbologyCreateScaledBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode, const uint8_t path[], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType);
FLR_RESULT symbologyGetLocation(const uint8_t ID, int16_t *pos_X, int16_t *pos_Y);
FLR_RESULT symbologyGetSize(const uint8_t ID, int16_t *width, int16_t *height);
FLR_RESULT symbologyGetZorder(const uint8_t ID, uint8_t *zorder);
FLR_RESULT symbologyGetColor(const uint8_t ID, uint32_t *color);
FLR_RESULT symbologyGetType(const uint8_t ID, FLR_SYMBOLOGY_TYPE_E *type);
FLR_RESULT symbologyCopySymbol(const uint8_t source, const uint8_t destination);
FLR_RESULT symbologyGetTextFontSize(const uint8_t ID, int16_t *size);
FLR_RESULT sysctrlSetFreezeState(const FLR_ENABLE_E data);
FLR_RESULT sysctrlGetFreezeState(FLR_ENABLE_E *data);
FLR_RESULT sysctrlGetCameraFrameRate(uint32_t *frameRate);
FLR_RESULT sysctrlGetUptimeSecs(uint32_t *uptime);
FLR_RESULT sysctrlSetUsbVideoIR16Mode(const FLR_SYSCTRL_USBIR16_MODE_E data);
FLR_RESULT sysctrlGetUsbVideoIR16Mode(FLR_SYSCTRL_USBIR16_MODE_E *data);
FLR_RESULT sysctrlSetOperatingMode(const FLR_SYSCTRL_OPERATING_MODE_E data);
FLR_RESULT sysctrlGetOperatingMode(FLR_SYSCTRL_OPERATING_MODE_E *data);
FLR_RESULT sysctrlGetAvgFpaTempCounts(float *data);
FLR_RESULT sysctrlSetFpaTempFrames(const uint16_t data);
FLR_RESULT sysctrlGetFpaTempFrames(uint16_t *data);
FLR_RESULT sysinfoGetMonitorSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT sysinfoGetMonitorBuildVariant(FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *monitorBuildVariant);
FLR_RESULT sysinfoGetProductName(uint8_t *name);
FLR_RESULT sysinfoGetCameraSN(uint8_t *number);
FLR_RESULT sysinfoGetBootLocation(uint32_t *bootSwLocation);
FLR_RESULT sysinfoGetSwConfigID(FLR_SYSINFO_SW_CONFIG_ID_E *swConfigID);
FLR_RESULT sysinfoGetSwPermissions(FLR_SYSINFO_SW_PERMISSIONS_E *swPermissions);
FLR_RESULT sysinfoGetIs9HzBuild(uint32_t *is9HzBuild);
FLR_RESULT sysinfoGetProductVersion(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT sysinfoGetMonitorProductRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT sysinfoGetOpticalRevision(uint16_t *revision);
FLR_RESULT sysinfoGetSensorRevision(uint16_t *revision);
FLR_RESULT sysinfoGetProbeTipSN(uint8_t *number);
FLR_RESULT sysinfoGetMechanicalRevision(uint16_t *revision);
FLR_RESULT sysinfoGetProbeTipType(FLR_SYSINFO_PROBE_TIP_TYPE *type);
FLR_RESULT systemSymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type);
FLR_RESULT systemSymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type);
FLR_RESULT systemSymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled);
FLR_RESULT systemSymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled);
FLR_RESULT systemSymbolsGetSpotConfig(FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *config);
FLR_RESULT systemSymbolsSetSpotConfig(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T config);
FLR_RESULT systemSymbolsGetIsoConfig(FLR_SYSTEMSYMBOLS_ISOCONFIG_T *config);
FLR_RESULT systemSymbolsSetIsoConfig(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T config);
FLR_RESULT systemSymbolsGetBarConfig(FLR_SYSTEMSYMBOLS_BARCONFIG_T *lowGainConfig, FLR_SYSTEMSYMBOLS_BARCONFIG_T *highGainConfig, FLR_TEMPERATURE_UNIT_E *unit);
FLR_RESULT systemSymbolsSetBarConfig(const FLR_SYSTEMSYMBOLS_BARCONFIG_T lowGainConfig, const FLR_SYSTEMSYMBOLS_BARCONFIG_T highGainConfig, const FLR_TEMPERATURE_UNIT_E unit);
FLR_RESULT systemSymbolsGetSpotConfigIds(FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *config);
FLR_RESULT systemSymbolsSetSpotConfigIds(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T config);
FLR_RESULT systemSymbolsGetIsoConfigIds(FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *config);
FLR_RESULT systemSymbolsSetIsoConfigIds(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T config);
FLR_RESULT telemetrySetState(const FLR_ENABLE_E data);
FLR_RESULT telemetryGetState(FLR_ENABLE_E *data);
FLR_RESULT telemetrySetLocation(const FLR_TELEMETRY_LOC_E data);
FLR_RESULT telemetryGetLocation(FLR_TELEMETRY_LOC_E *data);
FLR_RESULT telemetrySetPacking(const FLR_TELEMETRY_PACKING_E data);
FLR_RESULT telemetryGetPacking(FLR_TELEMETRY_PACKING_E *data);
FLR_RESULT telemetrySetOrder(const FLR_TELEMETRY_ORDER_E data);
FLR_RESULT telemetryGetOrder(FLR_TELEMETRY_ORDER_E *data);
FLR_RESULT telemetrySetPackingVC1(const FLR_TELEMETRY_PACKING_E data);
FLR_RESULT telemetryGetPackingVC1(FLR_TELEMETRY_PACKING_E *data);
FLR_RESULT telemetrySetMipiEmbeddedDataTag(const FLR_ENABLE_E data);
FLR_RESULT telemetryGetMipiEmbeddedDataTag(FLR_ENABLE_E *data);
FLR_RESULT testRampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data);
FLR_RESULT testRampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data);
FLR_RESULT testRampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data);
FLR_RESULT testRampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data);
FLR_RESULT testRampSetMotionState(const FLR_ENABLE_E data);
FLR_RESULT testRampGetMotionState(FLR_ENABLE_E *data);
FLR_RESULT testRampSetIndex(const uint8_t data);
FLR_RESULT testRampGetIndex(uint8_t *data);
FLR_RESULT testRampGetMaxIndex(uint8_t *data);
FLR_RESULT testRampSetPN9ContinuousMode(const FLR_ENABLE_E data);
FLR_RESULT testRampGetPN9ContinuousMode(FLR_ENABLE_E *data);
FLR_RESULT testRampSetAnimationSettings(const FLR_TESTRAMP_ANIMATION_SETTINGS_T settings);
FLR_RESULT testRampGetAnimationSettings(FLR_TESTRAMP_ANIMATION_SETTINGS_T *settings);
FLR_RESULT tfSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT tfGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT tfSetDelta_nf(const uint16_t data);
FLR_RESULT tfGetDelta_nf(uint16_t *data);
FLR_RESULT tfSetTHDeltaMotion(const uint16_t data);
FLR_RESULT tfGetTHDeltaMotion(uint16_t *data);
FLR_RESULT tfSetWLut(const FLR_TF_WLUT_T data);
FLR_RESULT tfGetWLut(FLR_TF_WLUT_T *data);
FLR_RESULT tfGetMotionCount(uint32_t *data);
FLR_RESULT tfSetMotionThreshold(const uint32_t data);
FLR_RESULT tfGetMotionThreshold(uint32_t *data);
FLR_RESULT tfGetDelta_nfApplied(uint16_t *data);
FLR_RESULT tfGetTHDeltaMotionApplied(uint16_t *data);
FLR_RESULT tfSetTempSignalCompFactorLut(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T data);
FLR_RESULT tfGetTempSignalCompFactorLut(FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *data);
FLR_RESULT tfGetRnf(uint16_t *rnf);
FLR_RESULT uartSetStartupBaudRate(const FLR_UART_STARTUP_BAUDRATE_E data);
FLR_RESULT uartGetStartupBaudRate(FLR_UART_STARTUP_BAUDRATE_E *data);
#endif

View File

@ -0,0 +1,33 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef CLIENT_DISPATCHER_H
#define CLIENT_DISPATCHER_H
#include <stdint.h>
#include "ReturnCodes.h"
#include "Serializer_Struct.h"
#include "FunctionCodes.h"
#include "Client_Interface.h"
FLR_RESULT CLIENT_dispatcher_Tx(uint32_t seqNum, FLR_FUNCTION fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes);
FLR_RESULT CLIENT_dispatcher_Rx(uint32_t *seqNum, uint32_t *fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes);
FLR_RESULT CLIENT_dispatcher(uint32_t seqNum, FLR_FUNCTION fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes);
FLR_RESULT CheckReadyDataCommandId(uint32_t receiveBytes, const uint8_t *receiveData, uint32_t *commandId);
#endif

View File

@ -0,0 +1,28 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef CLIENT_INTERFACE_H
#define CLIENT_INTERFACE_H
#include <stdint.h>
#include <stdlib.h>
#include "ReturnCodes.h"
FLR_RESULT CLIENT_interface_readFrame(uint8_t *readData, uint32_t *readBytes);
FLR_RESULT CLIENT_interface_writeFrame(uint8_t *writeData, uint32_t writeBytes);
#endif

View File

@ -0,0 +1,959 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef CLIENT_PACKAGER_H
#define CLIENT_PACKAGER_H
#include <stdint.h>
#include "EnumTypes.h"
#include "ReturnCodes.h"
#include "Serializer_Struct.h"
#include "FunctionCodes.h"
#include "Client_Dispatcher.h"
// Begin Module: TLinear
FLR_RESULT CLIENT_pkgTlinearSetControl(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTlinearGetControl(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgTlinearGetLUT(const FLR_BOSON_TABLETYPE_E mode, const uint16_t offset, float a[], float b[]);
FLR_RESULT CLIENT_pkgTlinearRefreshLUT(const FLR_BOSON_TABLETYPE_E mode);
// End Module: TLinear
// Begin Module: agc
FLR_RESULT CLIENT_pkgAgcSetPercentPerBin(const float data);
FLR_RESULT CLIENT_pkgAgcGetPercentPerBin(float *data);
FLR_RESULT CLIENT_pkgAgcSetLinearPercent(const float data);
FLR_RESULT CLIENT_pkgAgcGetLinearPercent(float *data);
FLR_RESULT CLIENT_pkgAgcSetOutlierCut(const float data);
FLR_RESULT CLIENT_pkgAgcGetOutlierCut(float *data);
FLR_RESULT CLIENT_pkgAgcGetDrOut(float *data);
FLR_RESULT CLIENT_pkgAgcSetMaxGain(const float data);
FLR_RESULT CLIENT_pkgAgcGetMaxGain(float *data);
FLR_RESULT CLIENT_pkgAgcSetdf(const float data);
FLR_RESULT CLIENT_pkgAgcGetdf(float *data);
FLR_RESULT CLIENT_pkgAgcSetGamma(const float data);
FLR_RESULT CLIENT_pkgAgcGetGamma(float *data);
FLR_RESULT CLIENT_pkgAgcGetFirstBin(uint32_t *data);
FLR_RESULT CLIENT_pkgAgcGetLastBin(uint32_t *data);
FLR_RESULT CLIENT_pkgAgcSetDetailHeadroom(const float data);
FLR_RESULT CLIENT_pkgAgcGetDetailHeadroom(float *data);
FLR_RESULT CLIENT_pkgAgcSetd2br(const float data);
FLR_RESULT CLIENT_pkgAgcGetd2br(float *data);
FLR_RESULT CLIENT_pkgAgcSetSigmaR(const float data);
FLR_RESULT CLIENT_pkgAgcGetSigmaR(float *data);
FLR_RESULT CLIENT_pkgAgcSetUseEntropy(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgAgcGetUseEntropy(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgAgcSetROI(const FLR_ROI_T roi);
FLR_RESULT CLIENT_pkgAgcGetROI(FLR_ROI_T *roi);
FLR_RESULT CLIENT_pkgAgcGetMaxGainApplied(float *data);
FLR_RESULT CLIENT_pkgAgcGetSigmaRApplied(float *data);
FLR_RESULT CLIENT_pkgAgcSetOutlierCutBalance(const float data);
FLR_RESULT CLIENT_pkgAgcGetOutlierCutBalance(float *data);
FLR_RESULT CLIENT_pkgAgcGetOutlierCutApplied(float *percentHigh, float *percentLow);
FLR_RESULT CLIENT_pkgAgcSetDetailHeadroomBalance(const float data);
FLR_RESULT CLIENT_pkgAgcGetDetailHeadroomBalance(float *data);
FLR_RESULT CLIENT_pkgAgcGetDetailHeadroomApplied(float *countsHigh, float *countsLow);
FLR_RESULT CLIENT_pkgAgcGetTfThresholds(uint16_t *tf_thresholdMin, uint16_t *tf_thresholdMax);
FLR_RESULT CLIENT_pkgAgcSetTfThresholds(const uint16_t tf_thresholdMin, const uint16_t tf_thresholdMax);
FLR_RESULT CLIENT_pkgAgcGetMode(FLR_AGC_MODE_E *mode);
FLR_RESULT CLIENT_pkgAgcSetMode(const FLR_AGC_MODE_E mode);
FLR_RESULT CLIENT_pkgAgcSetHighTempAlarmValues(const uint32_t lowGain, const uint32_t highGain, const uint32_t pixPopulation);
FLR_RESULT CLIENT_pkgAgcGetContrast(int32_t *contrast);
FLR_RESULT CLIENT_pkgAgcSetContrast(const int32_t contrast);
FLR_RESULT CLIENT_pkgAgcGetBrightnessBias(int32_t *brightnessBias);
FLR_RESULT CLIENT_pkgAgcSetBrightnessBias(const int32_t brightnessBias);
FLR_RESULT CLIENT_pkgAgcGetBrightness(int32_t *brightness);
FLR_RESULT CLIENT_pkgAgcSetBrightness(const int32_t brightness);
FLR_RESULT CLIENT_pkgAgcSetMaxGainForLowGain(const float data);
FLR_RESULT CLIENT_pkgAgcGetMaxGainForLowGain(float *data);
FLR_RESULT CLIENT_pkgAgcSetRadius(const uint32_t data);
FLR_RESULT CLIENT_pkgAgcGetRadius(uint32_t *data);
FLR_RESULT CLIENT_pkgAgcSetGmax(const float data);
FLR_RESULT CLIENT_pkgAgcGetGmax(float *data);
FLR_RESULT CLIENT_pkgAgcSetGmin(const float data);
FLR_RESULT CLIENT_pkgAgcGetGmin(float *data);
// End Module: agc
// Begin Module: boson
FLR_RESULT CLIENT_pkgBosonGetCameraSN(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonGetCameraPN(FLR_BOSON_PARTNUMBER_T *data);
FLR_RESULT CLIENT_pkgBosonGetSensorSN(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonRunFFC();
FLR_RESULT CLIENT_pkgBosonSetFFCTempThreshold(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonGetFFCTempThreshold(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetFFCFrameThreshold(const uint32_t data);
FLR_RESULT CLIENT_pkgBosonGetFFCFrameThreshold(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonGetFFCInProgress(int16_t *data);
FLR_RESULT CLIENT_pkgBosonReboot();
FLR_RESULT CLIENT_pkgBosonSetFFCMode(const FLR_BOSON_FFCMODE_E ffcMode);
FLR_RESULT CLIENT_pkgBosonGetFFCMode(FLR_BOSON_FFCMODE_E *ffcMode);
FLR_RESULT CLIENT_pkgBosonSetGainMode(const FLR_BOSON_GAINMODE_E gainMode);
FLR_RESULT CLIENT_pkgBosonGetGainMode(FLR_BOSON_GAINMODE_E *gainMode);
FLR_RESULT CLIENT_pkgBosonWriteDynamicHeaderToFlash();
FLR_RESULT CLIENT_pkgBosonReadDynamicHeaderFromFlash();
FLR_RESULT CLIENT_pkgBosonRestoreFactoryDefaultsFromFlash();
FLR_RESULT CLIENT_pkgBosonRestoreFactoryBadPixelsFromFlash();
FLR_RESULT CLIENT_pkgBosonWriteBadPixelsToFlash();
FLR_RESULT CLIENT_pkgBosonGetSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT CLIENT_pkgBosonSetBadPixelLocation(const uint32_t row, const uint32_t col);
FLR_RESULT CLIENT_pkgBosonlookupFPATempDegCx10(int16_t *data);
FLR_RESULT CLIENT_pkgBosonlookupFPATempDegKx10(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonWriteLensNvFfcToFlash();
FLR_RESULT CLIENT_pkgBosonWriteLensGainToFlash();
FLR_RESULT CLIENT_pkgBosonSetLensNumber(const uint32_t lensNumber);
FLR_RESULT CLIENT_pkgBosonGetLensNumber(uint32_t *lensNumber);
FLR_RESULT CLIENT_pkgBosonSetTableNumber(const uint32_t tableNumber);
FLR_RESULT CLIENT_pkgBosonGetTableNumber(uint32_t *tableNumber);
FLR_RESULT CLIENT_pkgBosonGetSensorPN(FLR_BOSON_SENSOR_PARTNUMBER_T *sensorPN);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchParams(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchParams(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct);
FLR_RESULT CLIENT_pkgBosonGetSwitchToHighGainFlag(uint8_t *switchToHighGainFlag);
FLR_RESULT CLIENT_pkgBosonGetSwitchToLowGainFlag(uint8_t *switchToLowGainFlag);
FLR_RESULT CLIENT_pkgBosonGetCLowToHighPercent(uint32_t *cLowToHighPercent);
FLR_RESULT CLIENT_pkgBosonGetMaxNUCTables(uint32_t *maxNUCTables);
FLR_RESULT CLIENT_pkgBosonGetMaxLensTables(uint32_t *maxLensTables);
FLR_RESULT CLIENT_pkgBosonGetFfcWaitCloseFrames(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetFfcWaitCloseFrames(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonCheckForTableSwitch();
FLR_RESULT CLIENT_pkgBosonGetDesiredTableNumber(uint32_t *desiredTableNumber);
FLR_RESULT CLIENT_pkgBosonGetFfcStatus(FLR_BOSON_FFCSTATUS_E *ffcStatus);
FLR_RESULT CLIENT_pkgBosonGetFfcDesired(uint32_t *ffcDesired);
FLR_RESULT CLIENT_pkgBosonGetSwRevInHeader(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT CLIENT_pkgBosonGetLastFFCFrameCount(uint32_t *frameCount);
FLR_RESULT CLIENT_pkgBosonGetLastFFCTempDegKx10(uint16_t *temp);
FLR_RESULT CLIENT_pkgBosonGetTableSwitchDesired(uint16_t *tableSwitchDesired);
FLR_RESULT CLIENT_pkgBosonGetOverTempThreshold(float *temperatureInC);
FLR_RESULT CLIENT_pkgBosonGetLowPowerMode(uint16_t *lowPowerMode);
FLR_RESULT CLIENT_pkgBosonGetOverTempEventOccurred(uint16_t *overTempEventOccurred);
FLR_RESULT CLIENT_pkgBosonSetPermitThermalShutdownOverride(const FLR_ENABLE_E permitThermalShutdownOverride);
FLR_RESULT CLIENT_pkgBosonGetPermitThermalShutdownOverride(FLR_ENABLE_E *permitThermalShutdownOverride);
FLR_RESULT CLIENT_pkgBosonGetMyriadTemp(float *myriadTemp);
FLR_RESULT CLIENT_pkgBosonGetNvFFCNucTableNumberLens0(int32_t *nvFFCNucTableNumberLens0);
FLR_RESULT CLIENT_pkgBosonGetNvFFCNucTableNumberLens1(int32_t *nvFFCNucTableNumberLens1);
FLR_RESULT CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens0(uint16_t *nvFFCFPATempDegKx10Lens0);
FLR_RESULT CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens1(uint16_t *nvFFCFPATempDegKx10Lens1);
FLR_RESULT CLIENT_pkgBosonSetFFCWarnTimeInSecx10(const uint16_t ffcWarnTime);
FLR_RESULT CLIENT_pkgBosonGetFFCWarnTimeInSecx10(uint16_t *ffcWarnTime);
FLR_RESULT CLIENT_pkgBosonGetOverTempEventCounter(uint32_t *overTempEventCounter);
FLR_RESULT CLIENT_pkgBosonSetOverTempTimerInSec(const uint16_t overTempTimerInSec);
FLR_RESULT CLIENT_pkgBosonGetOverTempTimerInSec(uint16_t *overTempTimerInSec);
FLR_RESULT CLIENT_pkgBosonUnloadCurrentLensCorrections();
FLR_RESULT CLIENT_pkgBosonSetTimeForQuickFFCsInSecs(const uint32_t timeForQuickFFCsInSecs);
FLR_RESULT CLIENT_pkgBosonGetTimeForQuickFFCsInSecs(uint32_t *timeForQuickFFCsInSecs);
FLR_RESULT CLIENT_pkgBosonReloadCurrentLensCorrections();
FLR_RESULT CLIENT_pkgBosonGetBootTimestamps(float *FirstLight, float *StartInit, float *BosonExecDone, float *Timestamp4);
FLR_RESULT CLIENT_pkgBosonSetExtSyncMode(const FLR_BOSON_EXT_SYNC_MODE_E mode);
FLR_RESULT CLIENT_pkgBosonGetExtSyncMode(FLR_BOSON_EXT_SYNC_MODE_E *mode);
FLR_RESULT CLIENT_pkgBosonGetLastCommand(uint32_t *sequenceNum, uint32_t *cmdID);
FLR_RESULT CLIENT_pkgBosonGetSensorHostCalVersion(uint32_t *version);
FLR_RESULT CLIENT_pkgBosonSetDesiredStartupTableNumber(const int32_t table);
FLR_RESULT CLIENT_pkgBosonGetDesiredStartupTableNumber(int32_t *table);
FLR_RESULT CLIENT_pkgBosonSetNvFFCMeanValueLens0(const float meanValue);
FLR_RESULT CLIENT_pkgBosonGetNvFFCMeanValueLens0(float *meanValue);
FLR_RESULT CLIENT_pkgBosonSetNvFFCMeanValueLens1(const float meanValue);
FLR_RESULT CLIENT_pkgBosonGetNvFFCMeanValueLens1(float *meanValue);
FLR_RESULT CLIENT_pkgBosonSetInvertImage(const FLR_ENABLE_E invertImage);
FLR_RESULT CLIENT_pkgBosonGetInvertImage(FLR_ENABLE_E *invertImage);
FLR_RESULT CLIENT_pkgBosonSetRevertImage(const FLR_ENABLE_E revertImage);
FLR_RESULT CLIENT_pkgBosonGetRevertImage(FLR_ENABLE_E *revertImage);
FLR_RESULT CLIENT_pkgBosonGetTimeStamp(const FLR_BOSON_TIMESTAMPTYPE_E timeStampType, float *timeStamp);
FLR_RESULT CLIENT_pkgBosonGetISPFrameCount(uint32_t *ispFrameCount);
FLR_RESULT CLIENT_pkgBosonWriteUserBadPixelsToAllTables();
FLR_RESULT CLIENT_pkgBosonWriteFactoryBadPixelsToAllTables();
FLR_RESULT CLIENT_pkgBosonGetTempDiodeStatus(FLR_BOSON_TEMP_DIODE_STATUS_E *status);
FLR_RESULT CLIENT_pkgBosonClearFactoryBadPixelsInDDR();
FLR_RESULT CLIENT_pkgBosonGetFfcWaitOpenFrames(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetFfcWaitOpenFrames(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonGetFfcWaitOpenFlagSettleFrames(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetFfcWaitOpenFlagSettleFrames(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonGetTauExtFfcCompatibilityMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgBosonSetTauExtFfcCompatibilityMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgBosonGetInitialTableSelectionTempOffset(int16_t *data);
FLR_RESULT CLIENT_pkgBosonSetInitialTableSelectionTempOffset(const int16_t data);
FLR_RESULT CLIENT_pkgBosonGetImageValid(int16_t *data);
FLR_RESULT CLIENT_pkgBosonGetCurrentTableType(FLR_BOSON_TABLETYPE_E *data);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchFrameThreshold(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchFrameThreshold(const uint32_t data);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchHysteresisTime(float *data);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchHysteresisTime(const float data);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchDesired(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchRadiometricParams(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchRadiometricParams(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct);
FLR_RESULT CLIENT_pkgBosonSetSaturationOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgBosonGetSaturationOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgBosonSetSaturationOverrideValue(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonGetSaturationOverrideValue(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetffcHighLowGainThresholdMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgBosonGetffcHighLowGainThresholdMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgBosonSetFFCTempThresholdLowGain(const uint16_t data);
FLR_RESULT CLIENT_pkgBosonGetFFCTempThresholdLowGain(uint16_t *data);
FLR_RESULT CLIENT_pkgBosonSetFFCFrameThresholdLowGain(const uint32_t data);
FLR_RESULT CLIENT_pkgBosonGetFFCFrameThresholdLowGain(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonGetBoardID(uint32_t *data);
FLR_RESULT CLIENT_pkgBosonSetAutoGainSwitchConditions(const FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E data);
FLR_RESULT CLIENT_pkgBosonGetAutoGainSwitchConditions(FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E *data);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchParamsCATS(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchParamsCATS(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct);
FLR_RESULT CLIENT_pkgBosonGetGainSwitchRadiometricParamsCATS(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct);
FLR_RESULT CLIENT_pkgBosonSetGainSwitchRadiometricParamsCATS(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct);
FLR_RESULT CLIENT_pkgBosonGetCLowToHighPercentCATS(uint32_t *cLowToHighPercent);
// End Module: boson
// Begin Module: bpr
FLR_RESULT CLIENT_pkgBprGetState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgBprSetState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgBprGetStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used);
FLR_RESULT CLIENT_pkgBprGetDisplayMode(FLR_BPR_DISPLAY_MODE_E *data);
FLR_RESULT CLIENT_pkgBprSetDisplayMode(const FLR_BPR_DISPLAY_MODE_E data);
FLR_RESULT CLIENT_pkgBprGetDisplayModeMinValue(uint16_t *data);
FLR_RESULT CLIENT_pkgBprSetDisplayModeMinValue(const uint16_t data);
FLR_RESULT CLIENT_pkgBprGetDisplayModeMaxValue(uint16_t *data);
FLR_RESULT CLIENT_pkgBprSetDisplayModeMaxValue(const uint16_t data);
FLR_RESULT CLIENT_pkgBprGetWorkBufIndex(uint32_t *data);
FLR_RESULT CLIENT_pkgBprSetWorkBufIndex(const uint32_t data);
FLR_RESULT CLIENT_pkgBprGetWorkBufStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used);
// End Module: bpr
// Begin Module: capture
FLR_RESULT CLIENT_pkgCaptureSingleFrame();
FLR_RESULT CLIENT_pkgCaptureFrames(const FLR_CAPTURE_SETTINGS_T data);
FLR_RESULT CLIENT_pkgCaptureSingleFrameWithSrc(const FLR_CAPTURE_SRC_E data);
FLR_RESULT CLIENT_pkgCaptureSingleFrameToFile();
FLR_RESULT CLIENT_pkgCaptureGetStatus(FLR_CAPTURE_STATUS_T *status);
// End Module: capture
// Begin Module: colorLut
FLR_RESULT CLIENT_pkgColorlutSetControl(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgColorlutGetControl(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgColorlutSetId(const FLR_COLORLUT_ID_E data);
FLR_RESULT CLIENT_pkgColorlutGetId(FLR_COLORLUT_ID_E *data);
FLR_RESULT CLIENT_pkgColorlutSetOutlineColor(const uint8_t red, const uint8_t green, const uint8_t blue);
FLR_RESULT CLIENT_pkgColorlutGetOutlineColor(uint8_t *red, uint8_t *green, uint8_t *blue);
// End Module: colorLut
// Begin Module: dummy
FLR_RESULT CLIENT_pkgDummyBadCommand();
// End Module: dummy
// Begin Module: dvo
FLR_RESULT CLIENT_pkgDvoSetAnalogVideoState(const FLR_ENABLE_E analogVideoState);
FLR_RESULT CLIENT_pkgDvoGetAnalogVideoState(FLR_ENABLE_E *analogVideoState);
FLR_RESULT CLIENT_pkgDvoSetOutputFormat(const FLR_DVO_OUTPUT_FORMAT_E format);
FLR_RESULT CLIENT_pkgDvoGetOutputFormat(FLR_DVO_OUTPUT_FORMAT_E *format);
FLR_RESULT CLIENT_pkgDvoSetOutputYCbCrSettings(const FLR_DVO_YCBCR_SETTINGS_T settings);
FLR_RESULT CLIENT_pkgDvoGetOutputYCbCrSettings(FLR_DVO_YCBCR_SETTINGS_T *settings);
FLR_RESULT CLIENT_pkgDvoSetOutputRGBSettings(const FLR_DVO_RGB_SETTINGS_T settings);
FLR_RESULT CLIENT_pkgDvoGetOutputRGBSettings(FLR_DVO_RGB_SETTINGS_T *settings);
FLR_RESULT CLIENT_pkgDvoApplyCustomSettings();
FLR_RESULT CLIENT_pkgDvoSetDisplayMode(const FLR_DVO_DISPLAY_MODE_E displayMode);
FLR_RESULT CLIENT_pkgDvoGetDisplayMode(FLR_DVO_DISPLAY_MODE_E *displayMode);
FLR_RESULT CLIENT_pkgDvoSetType(const FLR_DVO_TYPE_E tap);
FLR_RESULT CLIENT_pkgDvoGetType(FLR_DVO_TYPE_E *tap);
FLR_RESULT CLIENT_pkgDvoSetVideoStandard(const FLR_DVO_VIDEO_STANDARD_E videoStandard);
FLR_RESULT CLIENT_pkgDvoGetVideoStandard(FLR_DVO_VIDEO_STANDARD_E *videoStandard);
FLR_RESULT CLIENT_pkgDvoSetCheckVideoDacPresent(const FLR_ENABLE_E checkVideoDacPresent);
FLR_RESULT CLIENT_pkgDvoGetCheckVideoDacPresent(FLR_ENABLE_E *checkVideoDacPresent);
FLR_RESULT CLIENT_pkgDvoSetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, const FLR_DVO_LCD_CONFIG_T config);
FLR_RESULT CLIENT_pkgDvoGetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, FLR_DVO_LCD_CONFIG_T *config);
FLR_RESULT CLIENT_pkgDvoSetLCDConfig(const FLR_DVO_LCD_CONFIG_ID_E id);
FLR_RESULT CLIENT_pkgDvoGetLCDConfig(FLR_DVO_LCD_CONFIG_ID_E *id);
FLR_RESULT CLIENT_pkgDvoGetClockInfo(uint32_t *horizontalSyncWidth, uint32_t *verticalSyncWidth, uint32_t *clocksPerRowPeriod, uint32_t *horizontalFrontPorch, uint32_t *horizontalBackPorch, uint32_t *frontTelemetryPixels, uint32_t *rearTelemetryPixels, uint32_t *videoColumns, uint32_t *validColumns, uint32_t *telemetryRows, uint32_t *videoRows, uint32_t *validRows, uint32_t *verticalFrontPorch, uint32_t *verticalBackPorch, uint32_t *rowPeriodsPerFrame, uint32_t *clocksPerFrame, float *clockRateInMHz, float *frameRateInHz, uint32_t *validOnRisingEdge, uint32_t *dataWidthInBits);
FLR_RESULT CLIENT_pkgDvoSetAllCustomLcdConfigs(const FLR_DVO_LCD_CONFIG_T config0, const FLR_DVO_LCD_CONFIG_T config1);
FLR_RESULT CLIENT_pkgDvoGetAllCustomLcdConfigs(FLR_DVO_LCD_CONFIG_T *config0, FLR_DVO_LCD_CONFIG_T *config1);
FLR_RESULT CLIENT_pkgDvoSetOutputIr16Format(const FLR_DVO_OUTPUT_IR16_FORMAT_E format);
FLR_RESULT CLIENT_pkgDvoGetOutputIr16Format(FLR_DVO_OUTPUT_IR16_FORMAT_E *format);
FLR_RESULT CLIENT_pkgDvoSetLcdClockRate(const FLR_DVO_LCD_CLOCK_RATE_E clockRate);
FLR_RESULT CLIENT_pkgDvoGetLcdClockRate(FLR_DVO_LCD_CLOCK_RATE_E *clockRate);
FLR_RESULT CLIENT_pkgDvoSetLcdVideoFrameRate(const uint32_t framerate);
FLR_RESULT CLIENT_pkgDvoGetLcdVideoFrameRate(uint32_t *framerate);
FLR_RESULT CLIENT_pkgDvoSetMipiStartState(const FLR_DVO_MIPI_STATE_E state);
FLR_RESULT CLIENT_pkgDvoGetMipiStartState(FLR_DVO_MIPI_STATE_E *state);
FLR_RESULT CLIENT_pkgDvoSetMipiState(const FLR_DVO_MIPI_STATE_E state);
FLR_RESULT CLIENT_pkgDvoGetMipiState(FLR_DVO_MIPI_STATE_E *state);
FLR_RESULT CLIENT_pkgDvoSetMipiClockLaneMode(const FLR_DVO_MIPI_CLOCK_LANE_MODE_E mode);
FLR_RESULT CLIENT_pkgDvoGetMipiClockLaneMode(FLR_DVO_MIPI_CLOCK_LANE_MODE_E *mode);
FLR_RESULT CLIENT_pkgDvoSetOutputInterface(const FLR_DVO_OUTPUT_INTERFACE_E format);
FLR_RESULT CLIENT_pkgDvoGetOutputInterface(FLR_DVO_OUTPUT_INTERFACE_E *format);
FLR_RESULT CLIENT_pkgDvoSetOutputFormatVC1(const FLR_DVO_OUTPUT_FORMAT_E format);
FLR_RESULT CLIENT_pkgDvoGetOutputFormatVC1(FLR_DVO_OUTPUT_FORMAT_E *format);
// End Module: dvo
// Begin Module: dvoMux
FLR_RESULT CLIENT_pkgDvomuxSetType(const FLR_DVOMUX_OUTPUT_IF_E output, const FLR_DVOMUX_SOURCE_E source, const FLR_DVOMUX_TYPE_E type);
FLR_RESULT CLIENT_pkgDvomuxGetType(const FLR_DVOMUX_OUTPUT_IF_E output, FLR_DVOMUX_SOURCE_E *source, FLR_DVOMUX_TYPE_E *type);
// End Module: dvoMux
// Begin Module: fileOps
FLR_RESULT CLIENT_pkgFileopsDir(uint8_t dirent[]);
FLR_RESULT CLIENT_pkgFileopsCd(const uint8_t path[128], uint8_t pwd[]);
FLR_RESULT CLIENT_pkgFileopsMd(const uint8_t path[128]);
FLR_RESULT CLIENT_pkgFileopsFopen(const uint8_t path[128], const uint8_t mode[128], uint32_t *id);
FLR_RESULT CLIENT_pkgFileopsFclose(const uint32_t id);
FLR_RESULT CLIENT_pkgFileopsFread(const uint32_t id, const uint32_t length, uint8_t buf[], uint32_t *ret);
FLR_RESULT CLIENT_pkgFileopsFwrite(const uint32_t id, const uint32_t length, const uint8_t buf[128], uint32_t *ret);
FLR_RESULT CLIENT_pkgFileopsFtell(const uint32_t id, uint32_t *offset);
FLR_RESULT CLIENT_pkgFileopsFseek(const uint32_t id, const uint32_t offset, const uint32_t origin);
FLR_RESULT CLIENT_pkgFileopsFtruncate(const uint32_t id, const uint32_t length);
FLR_RESULT CLIENT_pkgFileopsRmdir(const uint8_t path[128]);
FLR_RESULT CLIENT_pkgFileopsRm(const uint8_t path[128]);
FLR_RESULT CLIENT_pkgFileopsRename(const uint8_t oldpath[128], const uint8_t newpath[128]);
FLR_RESULT CLIENT_pkgFileopsGetFileSize(const uint8_t path[128], uint32_t *fileLength);
// End Module: fileOps
// Begin Module: flashIO
FLR_RESULT CLIENT_pkgFlashioSetProtectionState(const FLR_ENABLE_E protectionState);
FLR_RESULT CLIENT_pkgFlashioGetProtectionState(FLR_ENABLE_E *protectionState);
// End Module: flashIO
// Begin Module: flashMapFs
FLR_RESULT CLIENT_pkgFlashmapfsGetHeaderVersion(uint32_t *major, uint32_t *minor, uint32_t *patch);
// End Module: flashMapFs
// Begin Module: gao
FLR_RESULT CLIENT_pkgGaoSetGainState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetGainState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetFfcState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetFfcState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetTempCorrectionState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetTempCorrectionState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetIConstL(const int16_t data);
FLR_RESULT CLIENT_pkgGaoGetIConstL(int16_t *data);
FLR_RESULT CLIENT_pkgGaoSetIConstM(const int16_t data);
FLR_RESULT CLIENT_pkgGaoGetIConstM(int16_t *data);
FLR_RESULT CLIENT_pkgGaoSetAveragerState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetAveragerState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetNumFFCFrames(const uint16_t data);
FLR_RESULT CLIENT_pkgGaoGetNumFFCFrames(uint16_t *data);
FLR_RESULT CLIENT_pkgGaoGetAveragerThreshold(uint16_t *data);
FLR_RESULT CLIENT_pkgGaoSetTestRampState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetTestRampState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetSffcState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetSffcState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetNucType(const FLR_GAO_NUC_TYPE_E nucType);
FLR_RESULT CLIENT_pkgGaoGetNucType(FLR_GAO_NUC_TYPE_E *nucType);
FLR_RESULT CLIENT_pkgGaoSetFfcZeroMeanState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetFfcZeroMeanState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoGetAveragerDesiredState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoGetAppliedClip(uint16_t *data);
FLR_RESULT CLIENT_pkgGaoSetAppliedClipEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetAppliedClipEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetFfcShutterSimulationState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetFfcShutterSimulationState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoSetFfcShutterSimulatorValue(const uint16_t value);
FLR_RESULT CLIENT_pkgGaoGetFfcShutterSimulatorValue(uint16_t *value);
FLR_RESULT CLIENT_pkgGaoSetBcnrState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgGaoGetBcnrState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgGaoGetAppliedSffcScaleFactor(float *data);
FLR_RESULT CLIENT_pkgGaoSetSffcMode(const FLR_GAO_SFFC_MODE_E mode);
FLR_RESULT CLIENT_pkgGaoGetSffcMode(FLR_GAO_SFFC_MODE_E *mode);
// End Module: gao
// Begin Module: imageStats
FLR_RESULT CLIENT_pkgImagestatsGetTotalHistPixelsInROI(uint32_t *totalPixelsInROI);
FLR_RESULT CLIENT_pkgImagestatsGetPopBelowLowToHighThresh(uint32_t *popBelowLowToHighThresh);
FLR_RESULT CLIENT_pkgImagestatsGetPopAboveHighToLowThresh(uint32_t *popAboveHighToLowThresh);
FLR_RESULT CLIENT_pkgImagestatsSetROI(const FLR_ROI_T roi);
FLR_RESULT CLIENT_pkgImagestatsGetROI(FLR_ROI_T *roi);
FLR_RESULT CLIENT_pkgImagestatsGetFirstBin(uint16_t *firstBin);
FLR_RESULT CLIENT_pkgImagestatsGetLastBin(uint16_t *lastBin);
FLR_RESULT CLIENT_pkgImagestatsGetMean(uint16_t *mean);
FLR_RESULT CLIENT_pkgImagestatsGetFirstBinInROI(uint16_t *firstBinInROI);
FLR_RESULT CLIENT_pkgImagestatsGetLastBinInROI(uint16_t *lastBinInROI);
FLR_RESULT CLIENT_pkgImagestatsGetMeanInROI(uint16_t *meanInROI);
FLR_RESULT CLIENT_pkgImagestatsGetImageStats(uint16_t *meanIntensity, uint16_t *peakIntensity, uint16_t *baseIntensity);
FLR_RESULT CLIENT_pkgImagestatsGetPopAboveLowToHighThreshCATS(uint32_t *popAboveLowToHighThresh);
FLR_RESULT CLIENT_pkgImagestatsGetPopBelowHighToLowThreshCATS(uint32_t *popBelowHighToLowThresh);
FLR_RESULT CLIENT_pkgImagestatsGetPopBetweenLthCATSAndLthSATS(uint32_t *popBetweenCatsAndSats);
// End Module: imageStats
// Begin Module: isotherm
FLR_RESULT CLIENT_pkgIsothermGetEnable(FLR_ENABLE_E *isothermEnable);
FLR_RESULT CLIENT_pkgIsothermSetEnable(const FLR_ENABLE_E isothermEnable);
FLR_RESULT CLIENT_pkgIsothermSetTemps(const FLR_ISOTHERM_GAIN_E table, const int32_t thIsoT1, const int32_t thIsoT2, const int32_t thIsoT3, const int32_t thIsoT4, const int32_t thIsoT5);
FLR_RESULT CLIENT_pkgIsothermGetTemps(const FLR_ISOTHERM_GAIN_E table, int32_t *thIsoT1, int32_t *thIsoT2, int32_t *thIsoT3, int32_t *thIsoT4, int32_t *thIsoT5);
FLR_RESULT CLIENT_pkgIsothermSetIsoColorValues(const FLR_ISOTHERM_GAIN_E table, const FLR_ISOTHERM_COLORS_T region0, const FLR_ISOTHERM_COLORS_T region1, const FLR_ISOTHERM_COLORS_T region2, const FLR_ISOTHERM_COLORS_T region3, const FLR_ISOTHERM_COLORS_T region4, const FLR_ISOTHERM_COLORS_T region5);
FLR_RESULT CLIENT_pkgIsothermGetIsoColorValues(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_COLORS_T *region0, FLR_ISOTHERM_COLORS_T *region1, FLR_ISOTHERM_COLORS_T *region2, FLR_ISOTHERM_COLORS_T *region3, FLR_ISOTHERM_COLORS_T *region4, FLR_ISOTHERM_COLORS_T *region5);
FLR_RESULT CLIENT_pkgIsothermSetRegionMode(const FLR_ISOTHERM_GAIN_E table, const FLR_ISOTHERM_REGION_E region0, const FLR_ISOTHERM_REGION_E region1, const FLR_ISOTHERM_REGION_E region2, const FLR_ISOTHERM_REGION_E region3, const FLR_ISOTHERM_REGION_E region4, const FLR_ISOTHERM_REGION_E region5);
FLR_RESULT CLIENT_pkgIsothermGetRegionMode(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_REGION_E *region0, FLR_ISOTHERM_REGION_E *region1, FLR_ISOTHERM_REGION_E *region2, FLR_ISOTHERM_REGION_E *region3, FLR_ISOTHERM_REGION_E *region4, FLR_ISOTHERM_REGION_E *region5);
FLR_RESULT CLIENT_pkgIsothermGetUnit(FLR_ISOTHERM_UNIT_E *unit);
FLR_RESULT CLIENT_pkgIsothermSetUnit(const FLR_ISOTHERM_UNIT_E unit);
FLR_RESULT CLIENT_pkgIsothermGetSettingsLowGain(FLR_ISOTHERM_SETTINGS_T *settings);
FLR_RESULT CLIENT_pkgIsothermSetSettingsLowGain(const FLR_ISOTHERM_SETTINGS_T settings);
FLR_RESULT CLIENT_pkgIsothermGetSettingsHighGain(FLR_ISOTHERM_SETTINGS_T *settings);
FLR_RESULT CLIENT_pkgIsothermSetSettingsHighGain(const FLR_ISOTHERM_SETTINGS_T settings);
FLR_RESULT CLIENT_pkgIsothermSetColorLutId(const FLR_COLORLUT_ID_E colorLutIdLowGain, const FLR_COLORLUT_ID_E colorLutIdHighGain);
FLR_RESULT CLIENT_pkgIsothermGetColorLutId(FLR_COLORLUT_ID_E *colorLutIdLowGain, FLR_COLORLUT_ID_E *colorLutIdHighGain);
// End Module: isotherm
// Begin Module: jffs2
FLR_RESULT CLIENT_pkgJffs2Mount();
FLR_RESULT CLIENT_pkgJffs2Unmount();
FLR_RESULT CLIENT_pkgJffs2GetState(FLR_JFFS2_STATE_E *state);
// End Module: jffs2
// Begin Module: lagrange
// End Module: lagrange
// Begin Module: latencyCtrl
FLR_RESULT CLIENT_pkgLatencyctrlSetLowLatencyState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLatencyctrlGetLowLatencyState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgLatencyctrlSetJitterReduction(const FLR_ENABLE_E enable, const int32_t line);
FLR_RESULT CLIENT_pkgLatencyctrlGetJitterReduction(FLR_ENABLE_E *enable, int32_t *line);
FLR_RESULT CLIENT_pkgLatencyctrlLatencyResetStats();
FLR_RESULT CLIENT_pkgLatencyctrlGetJitter(float *jitterMin, float *jitterMax);
FLR_RESULT CLIENT_pkgLatencyctrlGetLatency(float *latencyMin, float *latencyMax);
FLR_RESULT CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction(const int32_t line);
FLR_RESULT CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction(int32_t *line);
// End Module: latencyCtrl
// Begin Module: lfsr
FLR_RESULT CLIENT_pkgLfsrSetApplyOffsetEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLfsrGetApplyOffsetEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgLfsrSetMaxIterations(const uint32_t data);
FLR_RESULT CLIENT_pkgLfsrGetMaxIterations(uint32_t *data);
FLR_RESULT CLIENT_pkgLfsrSetDf(const uint32_t data);
FLR_RESULT CLIENT_pkgLfsrGetDf(uint32_t *data);
FLR_RESULT CLIENT_pkgLfsrSetLambda1(const float data);
FLR_RESULT CLIENT_pkgLfsrGetLambda1(float *data);
FLR_RESULT CLIENT_pkgLfsrSetLambda2(const float data);
FLR_RESULT CLIENT_pkgLfsrGetLambda2(float *data);
FLR_RESULT CLIENT_pkgLfsrSetHaltEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLfsrGetHaltEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgLfsrSetRandomMethod(const uint32_t data);
FLR_RESULT CLIENT_pkgLfsrGetRandomMethod(uint32_t *data);
FLR_RESULT CLIENT_pkgLfsrSetSingleStepEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLfsrGetSingleStepEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgLfsrSetR_LocalBump(const float data);
FLR_RESULT CLIENT_pkgLfsrGetR_LocalBump(float *data);
FLR_RESULT CLIENT_pkgLfsrSetR_CornerBump(const float data);
FLR_RESULT CLIENT_pkgLfsrGetR_CornerBump(float *data);
FLR_RESULT CLIENT_pkgLfsrSetFFC_ResetEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLfsrGetFFC_ResetEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgLfsrSetNormalizeAtCenterSpotState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgLfsrGetNormalizeAtCenterSpotState(FLR_ENABLE_E *data);
// End Module: lfsr
// Begin Module: mem
FLR_RESULT CLIENT_pkgMemReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT CLIENT_pkgMemGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT CLIENT_pkgMemWriteFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT CLIENT_pkgMemReadFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT CLIENT_pkgMemGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes);
FLR_RESULT CLIENT_pkgMemEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index);
FLR_RESULT CLIENT_pkgMemEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length);
FLR_RESULT CLIENT_pkgMemReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
FLR_RESULT CLIENT_pkgMemGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT CLIENT_pkgMemGetCaptureSizeSrc(const FLR_CAPTURE_SRC_E src, uint32_t *bytes, uint16_t *rows, uint16_t *columns);
FLR_RESULT CLIENT_pkgMemReadCaptureSrc(const FLR_CAPTURE_SRC_E src, const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data);
// End Module: mem
// Begin Module: normalize
// End Module: normalize
// Begin Module: radiometry
FLR_RESULT CLIENT_pkgRadiometrySetTempStableEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgRadiometryGetTempStableEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens0(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens0(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens1(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens1(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTauLens0(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTauLens0(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTauLens1(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTauLens1(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainDesired(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetDesired(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainApplied(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetApplied(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTComponentOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgRadiometryGetTComponentOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometrySetGlobalGainOverride(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainOverride(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetGlobalOffsetOverride(const uint16_t data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetOverride(uint16_t *data);
FLR_RESULT CLIENT_pkgRadiometrySetGlobalParamOverrideMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgRadiometryGetGlobalParamOverrideMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data);
FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetDampingFactor(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetDampingFactor(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGoMEQ(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGoMShutter(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGoMLens(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGoMLG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGoMFFC(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousing(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousing(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddle(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetFNumberShutterHousing(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetFNumberShutterHousing(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetEmissivityShutterHousing(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetEmissivityShutterHousing(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Lens(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Lens(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Lens(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Lens(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGgFfc(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetCountsFromTemp(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const float temp, uint16_t *counts);
FLR_RESULT CLIENT_pkgRadiometryGetTempFromCounts(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const uint16_t counts, float *temp);
FLR_RESULT CLIENT_pkgRadiometrySetTempLensHousingOverride(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousingOverride(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempShutterHousingOverride(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousingOverride(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempShutterPaddleOverride(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddleOverride(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetSignalFactorLut(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T data);
FLR_RESULT CLIENT_pkgRadiometryGetSignalFactorLut(FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetNoiseFactorLut(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T data);
FLR_RESULT CLIENT_pkgRadiometryGetNoiseFactorLut(FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_tfpaK(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_tfpaK(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_tfpaK(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_tfpaK(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTAuxParams(const FLR_RADIOMETRY_TAUX_PARAMS_T data);
FLR_RESULT CLIENT_pkgRadiometryGetTAuxParams(FLR_RADIOMETRY_TAUX_PARAMS_T *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_tAux(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_tAux(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_tAux(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_tAux(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTsource_FFC(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTsource_FFC(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_h(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_h(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_h(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_h(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_h(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_h(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_p(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_p(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_p(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_p(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_p(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_p(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK_Damp(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTAuxK(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetExternalFfcUpdateMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgRadiometryGetExternalFfcUpdateMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometryGetGG_scale(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempWindow(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempWindow(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTransmissionWindow(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTransmissionWindow(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetReflectivityWindow(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetReflectivityWindow(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempWindowReflection(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempWindowReflection(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTransmissionAtmosphere(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTransmissionAtmosphere(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempAtmosphere(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempAtmosphere(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetEmissivityTarget(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetEmissivityTarget(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTempBackground(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTempBackground(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetRadiometryCapable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingFactor(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingFactor(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempIntervalTime(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempIntervalTime(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxValue(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxValue(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxIncrement(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxIncrement(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingTime(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingTime(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetResponsivityFpaTemp(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetRbfoScaledMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgRadiometryGetRbfoScaledMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyFactor(FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E *data);
FLR_RESULT CLIENT_pkgRadiometryGetTRoomMinThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTRoomMaxThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMinThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMaxThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetStableTempThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetSlowDriftThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetFfcTempThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshLG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshLG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetMFactorThresh(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshHG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshHG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyStatusBits(uint16_t *data);
FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG(const float data);
FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG(float *data);
FLR_RESULT CLIENT_pkgRadiometryGetGG_RoomTemp(float *data);
// End Module: radiometry
// Begin Module: roic
FLR_RESULT CLIENT_pkgRoicGetFPATemp(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicGetFrameCount(uint32_t *data);
FLR_RESULT CLIENT_pkgRoicGetActiveNormalizationTarget(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicSetFPARampState(const FLR_ENABLE_E state);
FLR_RESULT CLIENT_pkgRoicGetFPARampState(FLR_ENABLE_E *state);
FLR_RESULT CLIENT_pkgRoicGetSensorADC1(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicGetSensorADC2(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicSetFPATempOffset(const int16_t data);
FLR_RESULT CLIENT_pkgRoicGetFPATempOffset(int16_t *data);
FLR_RESULT CLIENT_pkgRoicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data);
FLR_RESULT CLIENT_pkgRoicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data);
FLR_RESULT CLIENT_pkgRoicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table);
FLR_RESULT CLIENT_pkgRoicSetFPATempValue(const uint16_t data);
FLR_RESULT CLIENT_pkgRoicGetFPATempValue(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicGetPreambleError(uint32_t *preambleError);
FLR_RESULT CLIENT_pkgRoicInducePreambleError(const uint32_t everyNthFrame);
FLR_RESULT CLIENT_pkgRoicGetRoicStarted(FLR_ENABLE_E *roicStarted);
FLR_RESULT CLIENT_pkgRoicSetFrameSkip(const uint16_t data);
FLR_RESULT CLIENT_pkgRoicGetFrameSkip(uint16_t *data);
FLR_RESULT CLIENT_pkgRoicSetFrameOneShot();
// End Module: roic
// Begin Module: scaler
FLR_RESULT CLIENT_pkgScalerGetMaxZoom(uint32_t *zoom);
FLR_RESULT CLIENT_pkgScalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams);
FLR_RESULT CLIENT_pkgScalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams);
FLR_RESULT CLIENT_pkgScalerSetFractionalZoom(const uint32_t zoomNumerator, const uint32_t zoomDenominator, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable);
FLR_RESULT CLIENT_pkgScalerSetIndexZoom(const uint32_t zoomIndex, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable);
// End Module: scaler
// Begin Module: scnr
FLR_RESULT CLIENT_pkgScnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgScnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgScnrSetThColSum(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetThColSum(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetThPixel(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetThPixel(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetMaxCorr(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetMaxCorr(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrGetThPixelApplied(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrGetMaxCorrApplied(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetThColSumSafe(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetThColSumSafe(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetThPixelSafe(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetThPixelSafe(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetMaxCorrSafe(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetMaxCorrSafe(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetCorrectionMethod(const FLR_SCNR_CORR_SELECT_E data);
FLR_RESULT CLIENT_pkgScnrGetCorrectionMethod(FLR_SCNR_CORR_SELECT_E *data);
FLR_RESULT CLIENT_pkgScnrSetStdThreshold(const uint16_t data);
FLR_RESULT CLIENT_pkgScnrGetStdThreshold(uint16_t *data);
FLR_RESULT CLIENT_pkgScnrSetNFrames(const uint32_t data);
FLR_RESULT CLIENT_pkgScnrGetNFrames(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrSetResetDesired(const uint32_t data);
FLR_RESULT CLIENT_pkgScnrGetResetDesired(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrSetM_modeOnly(const uint32_t data);
FLR_RESULT CLIENT_pkgScnrGetM_modeOnly(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrGetMode(FLR_SCNR_MODE_E *data);
FLR_RESULT CLIENT_pkgScnrSetSpecklesEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgScnrSetSpecklesThreshold(const uint32_t data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesThreshold(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrSetSpecklesRatio(const float data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesRatio(float *data);
FLR_RESULT CLIENT_pkgScnrSetSpecklesDF(const float data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesDF(float *data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesDiffsBufferAddr(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesOffsBufferAddr(uint32_t *data);
FLR_RESULT CLIENT_pkgScnrSetSpecklesResetDesired(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgScnrGetSpecklesResetDesired(FLR_ENABLE_E *data);
// End Module: scnr
// Begin Module: sffc
FLR_RESULT CLIENT_pkgSffcGetScaleFactor(float *data);
FLR_RESULT CLIENT_pkgSffcGetDeltaTempLinearCoeff(float *data);
FLR_RESULT CLIENT_pkgSffcSetDeltaTempLinearCoeff(const float data);
FLR_RESULT CLIENT_pkgSffcGetDeltaTempOffsetCoeff(float *data);
FLR_RESULT CLIENT_pkgSffcSetDeltaTempOffsetCoeff(const float data);
FLR_RESULT CLIENT_pkgSffcGetFpaTempLinearCoeff(float *data);
FLR_RESULT CLIENT_pkgSffcSetFpaTempLinearCoeff(const float data);
FLR_RESULT CLIENT_pkgSffcGetFpaTempOffsetCoeff(float *data);
FLR_RESULT CLIENT_pkgSffcSetFpaTempOffsetCoeff(const float data);
FLR_RESULT CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs(uint32_t *data);
FLR_RESULT CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs(const uint32_t data);
// End Module: sffc
// Begin Module: spnr
FLR_RESULT CLIENT_pkgSpnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgSpnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgSpnrGetState(FLR_SPNR_STATE_E *data);
FLR_RESULT CLIENT_pkgSpnrSetFrameDelay(const uint32_t data);
FLR_RESULT CLIENT_pkgSpnrGetFrameDelay(uint32_t *data);
FLR_RESULT CLIENT_pkgSpnrSetSF(const float sf);
FLR_RESULT CLIENT_pkgSpnrGetSF(float *sf);
FLR_RESULT CLIENT_pkgSpnrGetSFApplied(float *sf);
FLR_RESULT CLIENT_pkgSpnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data);
FLR_RESULT CLIENT_pkgSpnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data);
FLR_RESULT CLIENT_pkgSpnrSetSFMin(const float sfmin);
FLR_RESULT CLIENT_pkgSpnrGetSFMin(float *sfmin);
FLR_RESULT CLIENT_pkgSpnrSetSFMax(const float sfmax);
FLR_RESULT CLIENT_pkgSpnrGetSFMax(float *sfmax);
FLR_RESULT CLIENT_pkgSpnrSetDFMin(const float dfmin);
FLR_RESULT CLIENT_pkgSpnrGetDFMin(float *dfmin);
FLR_RESULT CLIENT_pkgSpnrSetDFMax(const float dfmax);
FLR_RESULT CLIENT_pkgSpnrGetDFMax(float *dfmax);
FLR_RESULT CLIENT_pkgSpnrSetNormTarget(const float normTarget);
FLR_RESULT CLIENT_pkgSpnrGetNormTarget(float *normTarget);
FLR_RESULT CLIENT_pkgSpnrGetNormTargetApplied(float *normTargetApplied);
FLR_RESULT CLIENT_pkgSpnrSetThPix(const uint16_t th_pix);
FLR_RESULT CLIENT_pkgSpnrGetThPix(uint16_t *th_pix);
FLR_RESULT CLIENT_pkgSpnrSetThPixSum(const uint16_t th_pixSum);
FLR_RESULT CLIENT_pkgSpnrGetThPixSum(uint16_t *th_pixSum);
FLR_RESULT CLIENT_pkgSpnrSetMaxcorr(const uint16_t maxcorr);
FLR_RESULT CLIENT_pkgSpnrGetMaxcorr(uint16_t *maxcorr);
FLR_RESULT CLIENT_pkgSpnrGetAlgorithm(FLR_SPNR_ALGORITHM_E *data);
FLR_RESULT CLIENT_pkgSpnrSetAlgorithmDesired(const FLR_SPNR_ALGORITHM_E data);
FLR_RESULT CLIENT_pkgSpnrGetAlgorithmDesired(FLR_SPNR_ALGORITHM_E *data);
FLR_RESULT CLIENT_pkgSpnrSetDFFast(const float dffast);
FLR_RESULT CLIENT_pkgSpnrGetDFFast(float *dffast);
FLR_RESULT CLIENT_pkgSpnrSetDFSlow(const float dfslow);
FLR_RESULT CLIENT_pkgSpnrGetDFSlow(float *dfslow);
FLR_RESULT CLIENT_pkgSpnrSetSensitivityThreshold(const float threshold);
FLR_RESULT CLIENT_pkgSpnrGetSensitivityThreshold(float *threshold);
FLR_RESULT CLIENT_pkgSpnrSetReset(const FLR_SPNR_RESET_E resetType);
// End Module: spnr
// Begin Module: spotMeter
FLR_RESULT CLIENT_pkgSpotmeterSetEnable(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgSpotmeterGetEnable(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgSpotmeterGetRoiMaxSize(uint16_t *width, uint16_t *height);
FLR_RESULT CLIENT_pkgSpotmeterSetRoi(const FLR_ROI_T roi);
FLR_RESULT CLIENT_pkgSpotmeterGetRoi(FLR_ROI_T *roi);
FLR_RESULT CLIENT_pkgSpotmeterGetSpotStats(uint16_t *mean, uint16_t *deviation, FLR_SPOTMETER_SPOT_PARAM_T *min, FLR_SPOTMETER_SPOT_PARAM_T *max);
FLR_RESULT CLIENT_pkgSpotmeterSetStatsMode(const FLR_SPOTMETER_STATS_TEMP_MODE_E mode);
FLR_RESULT CLIENT_pkgSpotmeterGetStatsMode(FLR_SPOTMETER_STATS_TEMP_MODE_E *mode);
FLR_RESULT CLIENT_pkgSpotmeterGetTempStats(float *mean, float *deviation, FLR_SPOTMETER_STAT_PARAM_TEMP_T *min, FLR_SPOTMETER_STAT_PARAM_TEMP_T *max);
// End Module: spotMeter
// Begin Module: srnr
FLR_RESULT CLIENT_pkgSrnrSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgSrnrGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgSrnrSetThRowSum(const uint16_t data);
FLR_RESULT CLIENT_pkgSrnrGetThRowSum(uint16_t *data);
FLR_RESULT CLIENT_pkgSrnrSetThPixel(const uint16_t data);
FLR_RESULT CLIENT_pkgSrnrGetThPixel(uint16_t *data);
FLR_RESULT CLIENT_pkgSrnrSetMaxCorr(const uint16_t data);
FLR_RESULT CLIENT_pkgSrnrGetMaxCorr(uint16_t *data);
FLR_RESULT CLIENT_pkgSrnrGetThPixelApplied(uint16_t *data);
FLR_RESULT CLIENT_pkgSrnrGetMaxCorrApplied(uint16_t *data);
// End Module: srnr
// Begin Module: symbology
FLR_RESULT CLIENT_pkgSymbologySetEnable(const FLR_ENABLE_E draw_symbols);
FLR_RESULT CLIENT_pkgSymbologyCreateBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height);
FLR_RESULT CLIENT_pkgSymbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[128]);
FLR_RESULT CLIENT_pkgSymbologyCreateArc(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const float start_angle, const float end_angle, const uint32_t color);
FLR_RESULT CLIENT_pkgSymbologyCreateText(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint8_t text[128]);
FLR_RESULT CLIENT_pkgSymbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT CLIENT_pkgSymbologyAddToGroup(const uint8_t ID, const uint8_t group_ID);
FLR_RESULT CLIENT_pkgSymbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID);
FLR_RESULT CLIENT_pkgSymbologyUpdateAndShow(const uint8_t ID, const uint8_t visible);
FLR_RESULT CLIENT_pkgSymbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible);
FLR_RESULT CLIENT_pkgSymbologyDelete(const uint8_t ID);
FLR_RESULT CLIENT_pkgSymbologyDeleteGroup(const uint8_t group_ID);
FLR_RESULT CLIENT_pkgSymbologyCreateFilledRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT CLIENT_pkgSymbologyCreateOutlinedRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size);
FLR_RESULT CLIENT_pkgSymbologyCreateCompressedBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height);
FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[128]);
FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[128], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType);
FLR_RESULT CLIENT_pkgSymbologyResetWritePosition(const uint8_t ID);
FLR_RESULT CLIENT_pkgSymbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y);
FLR_RESULT CLIENT_pkgSymbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y);
FLR_RESULT CLIENT_pkgSymbologyCreateFilledEllipse(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color);
FLR_RESULT CLIENT_pkgSymbologyCreateLine(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color);
FLR_RESULT CLIENT_pkgSymbologySetZorder(const uint8_t ID, const uint8_t zorder);
FLR_RESULT CLIENT_pkgSymbologySaveConfiguration();
FLR_RESULT CLIENT_pkgSymbologyReloadConfiguration();
FLR_RESULT CLIENT_pkgSymbologyGetEnable(FLR_ENABLE_E *draw_symbols);
FLR_RESULT CLIENT_pkgSymbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones);
FLR_RESULT CLIENT_pkgSymbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT CLIENT_pkgSymbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y);
FLR_RESULT CLIENT_pkgSymbologySetTransformation(const FLR_SYMBOLOGY_TRANSFORMATION_E transformation);
FLR_RESULT CLIENT_pkgSymbologyUpdateAllVisible();
FLR_RESULT CLIENT_pkgSymbologySetSizeAndScalingMode(const uint8_t ID, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode);
FLR_RESULT CLIENT_pkgSymbologyCreateLineHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color1, const uint32_t color2, const uint16_t dashLen, const uint16_t thickness);
FLR_RESULT CLIENT_pkgSymbologyCreateTextHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color1, const uint32_t color2, const uint8_t dashLen, const uint8_t text[128]);
FLR_RESULT CLIENT_pkgSymbologyCreateTextBg(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint32_t bgColor, const uint8_t text[128]);
FLR_RESULT CLIENT_pkgSymbologyCreateScaledBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode, const uint8_t path[128], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType);
FLR_RESULT CLIENT_pkgSymbologyGetLocation(const uint8_t ID, int16_t *pos_X, int16_t *pos_Y);
FLR_RESULT CLIENT_pkgSymbologyGetSize(const uint8_t ID, int16_t *width, int16_t *height);
FLR_RESULT CLIENT_pkgSymbologyGetZorder(const uint8_t ID, uint8_t *zorder);
FLR_RESULT CLIENT_pkgSymbologyGetColor(const uint8_t ID, uint32_t *color);
FLR_RESULT CLIENT_pkgSymbologyGetType(const uint8_t ID, FLR_SYMBOLOGY_TYPE_E *type);
FLR_RESULT CLIENT_pkgSymbologyCopySymbol(const uint8_t source, const uint8_t destination);
FLR_RESULT CLIENT_pkgSymbologyGetTextFontSize(const uint8_t ID, int16_t *size);
// End Module: symbology
// Begin Module: sysctrl
FLR_RESULT CLIENT_pkgSysctrlSetFreezeState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgSysctrlGetFreezeState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgSysctrlGetCameraFrameRate(uint32_t *frameRate);
FLR_RESULT CLIENT_pkgSysctrlGetUptimeSecs(uint32_t *uptime);
FLR_RESULT CLIENT_pkgSysctrlSetUsbVideoIR16Mode(const FLR_SYSCTRL_USBIR16_MODE_E data);
FLR_RESULT CLIENT_pkgSysctrlGetUsbVideoIR16Mode(FLR_SYSCTRL_USBIR16_MODE_E *data);
FLR_RESULT CLIENT_pkgSysctrlSetOperatingMode(const FLR_SYSCTRL_OPERATING_MODE_E data);
FLR_RESULT CLIENT_pkgSysctrlGetOperatingMode(FLR_SYSCTRL_OPERATING_MODE_E *data);
FLR_RESULT CLIENT_pkgSysctrlGetAvgFpaTempCounts(float *data);
FLR_RESULT CLIENT_pkgSysctrlSetFpaTempFrames(const uint16_t data);
FLR_RESULT CLIENT_pkgSysctrlGetFpaTempFrames(uint16_t *data);
// End Module: sysctrl
// Begin Module: sysinfo
FLR_RESULT CLIENT_pkgSysinfoGetMonitorSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT CLIENT_pkgSysinfoGetMonitorBuildVariant(FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *monitorBuildVariant);
FLR_RESULT CLIENT_pkgSysinfoGetProductName(uint8_t name[]);
FLR_RESULT CLIENT_pkgSysinfoGetCameraSN(uint8_t number[]);
FLR_RESULT CLIENT_pkgSysinfoGetBootLocation(uint32_t *bootSwLocation);
FLR_RESULT CLIENT_pkgSysinfoGetSwConfigID(FLR_SYSINFO_SW_CONFIG_ID_E *swConfigID);
FLR_RESULT CLIENT_pkgSysinfoGetSwPermissions(FLR_SYSINFO_SW_PERMISSIONS_E *swPermissions);
FLR_RESULT CLIENT_pkgSysinfoGetIs9HzBuild(uint32_t *is9HzBuild);
FLR_RESULT CLIENT_pkgSysinfoGetProductVersion(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT CLIENT_pkgSysinfoGetMonitorProductRev(uint32_t *major, uint32_t *minor, uint32_t *patch);
FLR_RESULT CLIENT_pkgSysinfoGetOpticalRevision(uint16_t *revision);
FLR_RESULT CLIENT_pkgSysinfoGetSensorRevision(uint16_t *revision);
FLR_RESULT CLIENT_pkgSysinfoGetProbeTipSN(uint8_t number[]);
FLR_RESULT CLIENT_pkgSysinfoGetMechanicalRevision(uint16_t *revision);
FLR_RESULT CLIENT_pkgSysinfoGetProbeTipType(FLR_SYSINFO_PROBE_TIP_TYPE *type);
// End Module: sysinfo
// Begin Module: systemSymbols
FLR_RESULT CLIENT_pkgSystemsymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type);
FLR_RESULT CLIENT_pkgSystemsymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type);
FLR_RESULT CLIENT_pkgSystemsymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled);
FLR_RESULT CLIENT_pkgSystemsymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled);
FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfig(FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *config);
FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfig(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T config);
FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfig(FLR_SYSTEMSYMBOLS_ISOCONFIG_T *config);
FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfig(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T config);
FLR_RESULT CLIENT_pkgSystemsymbolsGetBarConfig(FLR_SYSTEMSYMBOLS_BARCONFIG_T *lowGainConfig, FLR_SYSTEMSYMBOLS_BARCONFIG_T *highGainConfig, FLR_TEMPERATURE_UNIT_E *unit);
FLR_RESULT CLIENT_pkgSystemsymbolsSetBarConfig(const FLR_SYSTEMSYMBOLS_BARCONFIG_T lowGainConfig, const FLR_SYSTEMSYMBOLS_BARCONFIG_T highGainConfig, const FLR_TEMPERATURE_UNIT_E unit);
FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfigIds(FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *config);
FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfigIds(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T config);
FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfigIds(FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *config);
FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfigIds(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T config);
// End Module: systemSymbols
// Begin Module: telemetry
FLR_RESULT CLIENT_pkgTelemetrySetState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTelemetryGetState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgTelemetrySetLocation(const FLR_TELEMETRY_LOC_E data);
FLR_RESULT CLIENT_pkgTelemetryGetLocation(FLR_TELEMETRY_LOC_E *data);
FLR_RESULT CLIENT_pkgTelemetrySetPacking(const FLR_TELEMETRY_PACKING_E data);
FLR_RESULT CLIENT_pkgTelemetryGetPacking(FLR_TELEMETRY_PACKING_E *data);
FLR_RESULT CLIENT_pkgTelemetrySetOrder(const FLR_TELEMETRY_ORDER_E data);
FLR_RESULT CLIENT_pkgTelemetryGetOrder(FLR_TELEMETRY_ORDER_E *data);
FLR_RESULT CLIENT_pkgTelemetrySetPackingVC1(const FLR_TELEMETRY_PACKING_E data);
FLR_RESULT CLIENT_pkgTelemetryGetPackingVC1(FLR_TELEMETRY_PACKING_E *data);
FLR_RESULT CLIENT_pkgTelemetrySetMipiEmbeddedDataTag(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTelemetryGetMipiEmbeddedDataTag(FLR_ENABLE_E *data);
// End Module: telemetry
// Begin Module: testRamp
FLR_RESULT CLIENT_pkgTestrampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data);
FLR_RESULT CLIENT_pkgTestrampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data);
FLR_RESULT CLIENT_pkgTestrampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data);
FLR_RESULT CLIENT_pkgTestrampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data);
FLR_RESULT CLIENT_pkgTestrampSetMotionState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTestrampGetMotionState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgTestrampSetIndex(const uint8_t data);
FLR_RESULT CLIENT_pkgTestrampGetIndex(uint8_t *data);
FLR_RESULT CLIENT_pkgTestrampGetMaxIndex(uint8_t *data);
FLR_RESULT CLIENT_pkgTestrampSetPN9ContinuousMode(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTestrampGetPN9ContinuousMode(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgTestrampSetAnimationSettings(const FLR_TESTRAMP_ANIMATION_SETTINGS_T settings);
FLR_RESULT CLIENT_pkgTestrampGetAnimationSettings(FLR_TESTRAMP_ANIMATION_SETTINGS_T *settings);
// End Module: testRamp
// Begin Module: tf
FLR_RESULT CLIENT_pkgTfSetEnableState(const FLR_ENABLE_E data);
FLR_RESULT CLIENT_pkgTfGetEnableState(FLR_ENABLE_E *data);
FLR_RESULT CLIENT_pkgTfSetDelta_nf(const uint16_t data);
FLR_RESULT CLIENT_pkgTfGetDelta_nf(uint16_t *data);
FLR_RESULT CLIENT_pkgTfSetTHDeltaMotion(const uint16_t data);
FLR_RESULT CLIENT_pkgTfGetTHDeltaMotion(uint16_t *data);
FLR_RESULT CLIENT_pkgTfSetWLut(const FLR_TF_WLUT_T data);
FLR_RESULT CLIENT_pkgTfGetWLut(FLR_TF_WLUT_T *data);
FLR_RESULT CLIENT_pkgTfGetMotionCount(uint32_t *data);
FLR_RESULT CLIENT_pkgTfSetMotionThreshold(const uint32_t data);
FLR_RESULT CLIENT_pkgTfGetMotionThreshold(uint32_t *data);
FLR_RESULT CLIENT_pkgTfGetDelta_nfApplied(uint16_t *data);
FLR_RESULT CLIENT_pkgTfGetTHDeltaMotionApplied(uint16_t *data);
FLR_RESULT CLIENT_pkgTfSetTempSignalCompFactorLut(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T data);
FLR_RESULT CLIENT_pkgTfGetTempSignalCompFactorLut(FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *data);
FLR_RESULT CLIENT_pkgTfGetRnf(uint16_t *rnf);
// End Module: tf
// Begin Module: uart
FLR_RESULT CLIENT_pkgUartSetStartupBaudRate(const FLR_UART_STARTUP_BAUDRATE_E data);
FLR_RESULT CLIENT_pkgUartGetStartupBaudRate(FLR_UART_STARTUP_BAUDRATE_E *data);
// End Module: uart
#endif // CLIENT_PACKAGER_H

View File

@ -0,0 +1,720 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef ENUM_TYPES_H
#define ENUM_TYPES_H
#include <stdint.h>
enum e_FLR_ENABLE_E {
FLR_DISABLE = (int32_t) 0,
FLR_ENABLE = (int32_t) 1,
FLR_ENABLE_END = (int32_t) 2,
};
typedef enum e_FLR_ENABLE_E FLR_ENABLE_E;
enum e_FLR_TEMPERATURE_UNIT_E {
FLR_TEMPERATURE_UNIT_KELVIN = (int32_t) 0,
FLR_TEMPERATURE_UNIT_CELSIUS = (int32_t) 1,
FLR_TEMPERATURE_UNIT_FAHRENHEIT = (int32_t) 2,
FLR_TEMPERATURE_UNIT_LAST = (int32_t) 3,
};
typedef enum e_FLR_TEMPERATURE_UNIT_E FLR_TEMPERATURE_UNIT_E;
enum e_FLR_AGC_MODE_E {
FLR_AGC_MODE_NORMAL = (int32_t) 0,
FLR_AGC_MODE_HOLD = (int32_t) 1,
FLR_AGC_MODE_THRESHOLD = (int32_t) 2,
FLR_AGC_MODE_AUTO_BRIGHT = (int32_t) 3,
FLR_AGC_MODE_AUTO_LINEAR = (int32_t) 4,
FLR_AGC_MODE_MANUAL = (int32_t) 5,
FLR_AGC_MODE_END = (int32_t) 6,
};
typedef enum e_FLR_AGC_MODE_E FLR_AGC_MODE_E;
enum e_FLR_BOSON_GAINMODE_E {
FLR_BOSON_HIGH_GAIN = (int32_t) 0,
FLR_BOSON_LOW_GAIN = (int32_t) 1,
FLR_BOSON_AUTO_GAIN = (int32_t) 2,
FLR_BOSON_DUAL_GAIN = (int32_t) 3,
FLR_BOSON_MANUAL_GAIN = (int32_t) 4,
FLR_BOSON_GAINMODE_END = (int32_t) 5,
};
typedef enum e_FLR_BOSON_GAINMODE_E FLR_BOSON_GAINMODE_E;
enum e_FLR_BOSON_FFCMODE_E {
FLR_BOSON_MANUAL_FFC = (int32_t) 0,
FLR_BOSON_AUTO_FFC = (int32_t) 1,
FLR_BOSON_EXTERNAL_FFC = (int32_t) 2,
FLR_BOSON_SHUTTER_TEST_FFC = (int32_t) 3,
FLR_BOSON_FFCMODE_END = (int32_t) 4,
};
typedef enum e_FLR_BOSON_FFCMODE_E FLR_BOSON_FFCMODE_E;
enum e_FLR_BOSON_TIMESTAMPTYPE_E {
FLR_BOSON_UARTINIT = (int32_t) 0,
FLR_BOSON_PIXELCLOCKINIT = (int32_t) 1,
FLR_BOSON_AUTHEVENT = (int32_t) 2,
FLR_BOSON_FIRSTVALIDIMAGE = (int32_t) 3,
FLR_BOSON_TIMESTAMPTYPE_END = (int32_t) 4,
};
typedef enum e_FLR_BOSON_TIMESTAMPTYPE_E FLR_BOSON_TIMESTAMPTYPE_E;
enum e_FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E {
FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_RELATIVE_HOT = (int32_t) 0,
FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_RELATIVE_COLD = (int32_t) 1,
FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_RELATIVE_HOT_OR_COLD = (int32_t) 2,
FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_END = (int32_t) 3,
};
typedef enum e_FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E;
enum e_FLR_BOSON_FFCSTATUS_E {
FLR_BOSON_NO_FFC_PERFORMED = (int32_t) 0,
FLR_BOSON_FFC_IMMINENT = (int32_t) 1,
FLR_BOSON_FFC_IN_PROGRESS = (int32_t) 2,
FLR_BOSON_FFC_COMPLETE = (int32_t) 3,
FLR_BOSON_FFCSTATUS_END = (int32_t) 4,
};
typedef enum e_FLR_BOSON_FFCSTATUS_E FLR_BOSON_FFCSTATUS_E;
enum e_FLR_BOSON_MYRIADTEMPMODE_E {
FLR_BOSON_NORMAL_MYRIADTEMP_MODE = (int32_t) 0,
FLR_BOSON_STATIC_MYRIADTEMP_MODE = (int32_t) 1,
};
typedef enum e_FLR_BOSON_MYRIADTEMPMODE_E FLR_BOSON_MYRIADTEMPMODE_E;
enum e_FLR_BOSON_EXT_SYNC_MODE_E {
FLR_BOSON_EXT_SYNC_DISABLE_MODE = (int32_t) 0,
FLR_BOSON_EXT_SYNC_MASTER_MODE = (int32_t) 1,
FLR_BOSON_EXT_SYNC_SLAVE_MODE = (int32_t) 2,
FLR_BOSON_EXT_SYNC_END = (int32_t) 3,
};
typedef enum e_FLR_BOSON_EXT_SYNC_MODE_E FLR_BOSON_EXT_SYNC_MODE_E;
enum e_FLR_BOSON_TEMP_DIODE_STATUS_E {
FLR_BOSON_TEMP_DIODE_NORMAL = (int32_t) 0,
FLR_BOSON_TEMP_DIODE_FAULT = (int32_t) 1,
FLR_BOSON_TEMP_DIODE_END = (int32_t) 2,
};
typedef enum e_FLR_BOSON_TEMP_DIODE_STATUS_E FLR_BOSON_TEMP_DIODE_STATUS_E;
enum e_FLR_BOSON_TABLETYPE_E {
FLR_BOSON_LOWGAIN_TABLE = (int32_t) 0,
FLR_BOSON_HIGHGAIN_TABLE = (int32_t) 1,
FLR_BOSON_TABLETYPE_END = (int32_t) 2,
};
typedef enum e_FLR_BOSON_TABLETYPE_E FLR_BOSON_TABLETYPE_E;
enum e_FLR_BPR_DISPLAY_MODE_E {
FLR_BPR_NORMAL_DISPLAY_MODE = (int32_t) 0,
FLR_BPR_MIN_VALUE_ONLY_MODE = (int32_t) 1,
FLR_BPR_MAX_VALUE_ONLY_MODE = (int32_t) 2,
FLR_BPR_MIN_MAX_TOGGLE_MODE = (int32_t) 3,
FLR_BPR_BPR_DISPLAY_MODE_END = (int32_t) 4,
};
typedef enum e_FLR_BPR_DISPLAY_MODE_E FLR_BPR_DISPLAY_MODE_E;
enum e_FLR_CAPTURE_SRC_E {
FLR_CAPTURE_SRC_NUC = (int32_t) 1,
FLR_CAPTURE_SRC_RESERVED = (int32_t) 2,
FLR_CAPTURE_SRC_TNF = (int32_t) 3,
FLR_CAPTURE_SRC_BLEND = (int32_t) 4,
FLR_CAPTURE_SRC_VIS = (int32_t) 5,
FLR_CAPTURE_SRC_MSX = (int32_t) 6,
FLR_CAPTURE_SRC_RAW = (int32_t) 7,
FLR_CAPTURE_SRC_TLINEAR = (int32_t) 8,
FLR_CAPTURE_SRC_END = (int32_t) 9,
};
typedef enum e_FLR_CAPTURE_SRC_E FLR_CAPTURE_SRC_E;
enum e_FLR_CAPTURE_FILE_TYPE_E {
FLR_CAPTURE_NONE = (int32_t) 0,
FLR_CAPTURE_JPEG = (int32_t) 1,
FLR_CAPTURE_PNG = (int32_t) 2,
};
typedef enum e_FLR_CAPTURE_FILE_TYPE_E FLR_CAPTURE_FILE_TYPE_E;
enum e_FLR_CAPTURE_STATE_E {
FLR_CAPTURE_READY = (int32_t) 0,
FLR_CAPTURE_IN_PROGRESS = (int32_t) 1,
};
typedef enum e_FLR_CAPTURE_STATE_E FLR_CAPTURE_STATE_E;
enum e_FLR_COLORLUT_ID_E {
FLR_COLORLUT_0 = (int32_t) 0,
FLR_COLORLUT_DEFAULT = (int32_t) 0,
FLR_COLORLUT_WHITEHOT = (int32_t) 0,
FLR_COLORLUT_1 = (int32_t) 1,
FLR_COLORLUT_BLACKHOT = (int32_t) 1,
FLR_COLORLUT_2 = (int32_t) 2,
FLR_COLORLUT_RAINBOW = (int32_t) 2,
FLR_COLORLUT_3 = (int32_t) 3,
FLR_COLORLUT_RAINBOW_HC = (int32_t) 3,
FLR_COLORLUT_4 = (int32_t) 4,
FLR_COLORLUT_IRONBOW = (int32_t) 4,
FLR_COLORLUT_5 = (int32_t) 5,
FLR_COLORLUT_LAVA = (int32_t) 5,
FLR_COLORLUT_6 = (int32_t) 6,
FLR_COLORLUT_ARCTIC = (int32_t) 6,
FLR_COLORLUT_7 = (int32_t) 7,
FLR_COLORLUT_GLOBOW = (int32_t) 7,
FLR_COLORLUT_8 = (int32_t) 8,
FLR_COLORLUT_GRADEDFIRE = (int32_t) 8,
FLR_COLORLUT_9 = (int32_t) 9,
FLR_COLORLUT_HOTTEST = (int32_t) 9,
FLR_COLORLUT_10 = (int32_t) 10,
FLR_COLORLUT_EMBERGLOW = (int32_t) 10,
FLR_COLORLUT_11 = (int32_t) 11,
FLR_COLORLUT_AURORA = (int32_t) 11,
FLR_COLORLUT_ID_END = (int32_t) 12,
};
typedef enum e_FLR_COLORLUT_ID_E FLR_COLORLUT_ID_E;
enum e_FLR_DVO_OUTPUT_FORMAT_E {
FLR_DVO_RGB = (int32_t) 0,
FLR_DVO_YCBCR = (int32_t) 1,
FLR_DVO_DEFAULT_FORMAT = (int32_t) 2,
FLR_DVO_IR16 = (int32_t) 3,
FLR_DVO_OUTPUT_FORMAT_END = (int32_t) 4,
};
typedef enum e_FLR_DVO_OUTPUT_FORMAT_E FLR_DVO_OUTPUT_FORMAT_E;
enum e_FLR_DVO_OUTPUT_RGB_FORMAT_E {
FLR_DVO_RGB888 = (int32_t) 0,
FLR_DVO_MRGB888 = (int32_t) 1,
FLR_DVO_RGB565 = (int32_t) 2,
FLR_DVO_MRGB565 = (int32_t) 3,
FLR_DVO_OUTPUT_RGB_FORMAT_END = (int32_t) 4,
};
typedef enum e_FLR_DVO_OUTPUT_RGB_FORMAT_E FLR_DVO_OUTPUT_RGB_FORMAT_E;
enum e_FLR_DVO_OUTPUT_YCBCR_FORMAT_E {
FLR_DVO_YCBCR422_8B = (int32_t) 0,
FLR_DVO_MYCBCR422_8B = (int32_t) 1,
FLR_DVO_OUTPUT_YCBCR_FORMAT_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_YCBCR_FORMAT_E FLR_DVO_OUTPUT_YCBCR_FORMAT_E;
enum e_FLR_DVO_OUTPUT_IR16_FORMAT_E {
FLR_DVO_IR16_16B = (int32_t) 0,
FLR_DVO_MIR16_8B = (int32_t) 1,
FLR_DVO_OUTPUT_IR16_FORMAT_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_IR16_FORMAT_E FLR_DVO_OUTPUT_IR16_FORMAT_E;
enum e_FLR_DVO_OUTPUT_CBCR_ORDER_E {
FLR_DVO_CRCB = (int32_t) 0,
FLR_DVO_CBCR = (int32_t) 1,
FLR_DVO_OUTPUT_CBCR_ORDER_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_CBCR_ORDER_E FLR_DVO_OUTPUT_CBCR_ORDER_E;
enum e_FLR_DVO_OUTPUT_Y_ORDER_E {
FLR_DVO_YFIRST = (int32_t) 0,
FLR_DVO_YLAST = (int32_t) 1,
FLR_DVO_OUTPUT_Y_ORDER_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_Y_ORDER_E FLR_DVO_OUTPUT_Y_ORDER_E;
enum e_FLR_DVO_OUTPUT_RGB_ORDER_E {
FLR_DVO_ORDER_RGB = (int32_t) 0,
FLR_DVO_ORDER_BGR = (int32_t) 1,
FLR_DVO_OUTPUT_RGB_ORDER_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_RGB_ORDER_E FLR_DVO_OUTPUT_RGB_ORDER_E;
enum e_FLR_DVO_TYPE_E {
FLR_DVO_TYPE_MONO16 = (int32_t) 0,
FLR_DVO_TYPE_MONO8 = (int32_t) 1,
FLR_DVO_TYPE_COLOR = (int32_t) 2,
FLR_DVO_TYPE_ANALOG = (int32_t) 3,
FLR_DVO_TYPE_RAW = (int32_t) 4,
FLR_DVO_TYPE_MONO14 = (int32_t) 5,
FLR_DVO_TYPE_TLINEAR = (int32_t) 6,
FLR_DVO_TYPE_MONO12 = (int32_t) 7,
FLR_DVO_TYPE_MONO8MONO14 = (int32_t) 8,
FLR_DVO_TYPE_MONO8MONO12 = (int32_t) 9,
FLR_DVO_TYPE_COLORMONO14 = (int32_t) 10,
FLR_DVO_TYPE_COLORMONO12 = (int32_t) 11,
FLR_DVO_TYPE_COLORMONO8 = (int32_t) 12,
FLR_DVO_TYPE_COLORTLINEAR = (int32_t) 13,
FLR_DVO_TYPE_MONO8TLINEAR = (int32_t) 14,
FLR_DVO_TYPE_END = (int32_t) 15,
};
typedef enum e_FLR_DVO_TYPE_E FLR_DVO_TYPE_E;
enum e_FLR_DVO_OUTPUT_INTERFACE_E {
FLR_DVO_CMOS = (int32_t) 0,
FLR_DVO_MIPI = (int32_t) 1,
FLR_DVO_OUTPUT_INTERFACE_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_OUTPUT_INTERFACE_E FLR_DVO_OUTPUT_INTERFACE_E;
enum e_FLR_DVO_DISPLAY_MODE_E {
FLR_DVO_CONTINUOUS = (int32_t) 0,
FLR_DVO_ONE_SHOT = (int32_t) 1,
FLR_DVO_DISPLAY_MODE_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_DISPLAY_MODE_E FLR_DVO_DISPLAY_MODE_E;
enum e_FLR_DVO_VIDEO_STANDARD_E {
FLR_DVO_NTSC = (int32_t) 0,
FLR_DVO_PAL = (int32_t) 1,
FLR_DVO_VIDEO_STANDARD_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_VIDEO_STANDARD_E FLR_DVO_VIDEO_STANDARD_E;
enum e_FLR_DVO_LCD_CONFIG_ID_E {
FLR_DVO_DEFAULT = (int32_t) 0,
FLR_DVO_CUSTOM1 = (int32_t) 1,
FLR_DVO_CUSTOM2 = (int32_t) 2,
FLR_DVO_CONFIG1 = (int32_t) 3,
FLR_DVO_CONFIG2 = (int32_t) 4,
};
typedef enum e_FLR_DVO_LCD_CONFIG_ID_E FLR_DVO_LCD_CONFIG_ID_E;
enum e_FLR_DVO_LCD_CLOCK_RATE_E {
FLR_DVO_LCD_CLOCK_DEFAULT = (int32_t) 0,
FLR_DVO_LCD_CLOCK_27MHZ = (int32_t) 1,
FLR_DVO_LCD_CLOCK_13_5MHZ = (int32_t) 2,
FLR_DVO_LCD_CLOCK_48MHZ = (int32_t) 3,
FLR_DVO_LCD_CLOCK_60MHZ = (int32_t) 4,
FLR_DVO_LCD_CLOCK_END = (int32_t) 5,
};
typedef enum e_FLR_DVO_LCD_CLOCK_RATE_E FLR_DVO_LCD_CLOCK_RATE_E;
enum e_FLR_DVO_MIPI_STATE_E {
FLR_DVO_MIPI_STATE_OFF = (int32_t) 0,
FLR_DVO_MIPI_STATE_PAUSED = (int32_t) 1,
FLR_DVO_MIPI_STATE_ACTIVE = (int32_t) 2,
FLR_DVO_MIPI_STATE_END = (int32_t) 3,
};
typedef enum e_FLR_DVO_MIPI_STATE_E FLR_DVO_MIPI_STATE_E;
enum e_FLR_DVO_MIPI_CLOCK_LANE_MODE_E {
FLR_DVO_MIPI_CLOCK_LANE_MODE_NON_CONTINUOUS = (int32_t) 0,
FLR_DVO_MIPI_CLOCK_LANE_MODE_CONTINUOUS = (int32_t) 1,
FLR_DVO_MIPI_CLOCK_LANE_MODE_END = (int32_t) 2,
};
typedef enum e_FLR_DVO_MIPI_CLOCK_LANE_MODE_E FLR_DVO_MIPI_CLOCK_LANE_MODE_E;
enum e_FLR_DVOMUX_TYPE_E {
FLR_DVOMUX_TYPE_MONO16 = (int32_t) 0,
FLR_DVOMUX_TYPE_MONO8 = (int32_t) 1,
FLR_DVOMUX_TYPE_COLOR = (int32_t) 2,
FLR_DVOMUX_TYPE_ANALOG = (int32_t) 3,
FLR_DVOMUX_TYPE_MONO14 = (int32_t) 4,
FLR_DVOMUX_TYPE_END = (int32_t) 5,
};
typedef enum e_FLR_DVOMUX_TYPE_E FLR_DVOMUX_TYPE_E;
enum e_FLR_DVOMUX_SOURCE_E {
FLR_DVOMUX_SRC_IR = (int32_t) 0,
FLR_DVOMUX_SRC_VIS = (int32_t) 1,
FLR_DVOMUX_SRC_H264DEC = (int32_t) 2,
FLR_DVOMUX_SRC_END = (int32_t) 3,
};
typedef enum e_FLR_DVOMUX_SOURCE_E FLR_DVOMUX_SOURCE_E;
enum e_FLR_DVOMUX_OUTPUT_IF_E {
FLR_DVOMUX_OUTPUT_IF_DVO = (int32_t) 0,
FLR_DVOMUX_OUTPUT_IF_UVC = (int32_t) 1,
FLR_DVOMUX_OUTPUT_IF_CAPTURE = (int32_t) 2,
FLR_DVOMUX_OUTPUT_IF_MIPITX = (int32_t) 3,
FLR_DVOMUX_OUTPUT_IF_H264ENC = (int32_t) 4,
FLR_DVOMUX_OUTPUT_IF_END = (int32_t) 5,
};
typedef enum e_FLR_DVOMUX_OUTPUT_IF_E FLR_DVOMUX_OUTPUT_IF_E;
enum e_FLR_GAO_NUC_TYPE_E {
FLR_GAO_NUC_TYPE_ONE_POINT_FFC = (int32_t) 0,
FLR_GAO_NUC_TYPE_TWO_POINT_FIELD = (int32_t) 1,
FLR_GAO_NUC_TYPE_TWO_POINT_FACTORY = (int32_t) 2,
FLR_GAO_NUC_TYPE_END = (int32_t) 3,
};
typedef enum e_FLR_GAO_NUC_TYPE_E FLR_GAO_NUC_TYPE_E;
enum e_FLR_GAO_SFFC_MODE_E {
FLR_GAO_SFFC_MODE_TRADITIONAL = (int32_t) 0,
FLR_GAO_SFFC_MODE_BOSS = (int32_t) 1,
FLR_GAO_SFFC_MODE_END = (int32_t) 3,
};
typedef enum e_FLR_GAO_SFFC_MODE_E FLR_GAO_SFFC_MODE_E;
enum e_FLR_ISOTHERM_REGION_E {
FLR_ISOTHERM_REGION_DISABLED = (int32_t) 0,
FLR_ISOTHERM_REGION_CORRELATED = (int32_t) 1,
FLR_ISOTHERM_REGION_NON_CORRELATED = (int32_t) 2,
FLR_ISOTHERM_REGION_COLORIZE = (int32_t) 3,
FLR_ISOTHERM_REGION_BLEND = (int32_t) 4,
FLR_ISOTHERM_REGION_CORRELATED_HSV = (int32_t) 5,
FLR_ISOTHERM_REGION_NON_CORRELATED_HSV = (int32_t) 6,
FLR_ISOTHERM_REGION_COMMON = (int32_t) 7,
FLR_ISOTHERM_REGION_LAST = (int32_t) 8,
};
typedef enum e_FLR_ISOTHERM_REGION_E FLR_ISOTHERM_REGION_E;
enum e_FLR_ISOTHERM_GAIN_E {
FLR_ISOTHERM_GAIN_LOW = (int32_t) 0,
FLR_ISOTHERM_GAIN_HIGH = (int32_t) 1,
FLR_ISOTHERM_GAIN_LAST = (int32_t) 2,
};
typedef enum e_FLR_ISOTHERM_GAIN_E FLR_ISOTHERM_GAIN_E;
enum e_FLR_ISOTHERM_UNIT_E {
FLR_ISOTHERM_UNIT_KELVIN = (int32_t) 0,
FLR_ISOTHERM_UNIT_CELSIUS = (int32_t) 1,
FLR_ISOTHERM_UNIT_FAHRENHEIT = (int32_t) 4,
FLR_ISOTHERM_UNIT_PERCENT = (int32_t) 5,
FLR_ISOTHERM_UNIT_RAW = (int32_t) 6,
FLR_ISOTHERM_UNIT_LAST = (int32_t) 7,
};
typedef enum e_FLR_ISOTHERM_UNIT_E FLR_ISOTHERM_UNIT_E;
enum e_FLR_JFFS2_STATE_E {
FLR_JFFS2_INITIAL = (int32_t) 0,
FLR_JFFS2_CONFIGURED = (int32_t) 1,
FLR_JFFS2_MOUNTING = (int32_t) 2,
FLR_JFFS2_MOUNTED = (int32_t) 3,
FLR_JFFS2_UNMOUNTING = (int32_t) 4,
FLR_JFFS2_UNMOUNTED = (int32_t) 5,
FLR_JFFS2_FAILED_MOUNT = (int32_t) 6,
FLR_JFFS2_FAILED_UNMOUNT = (int32_t) 7,
FLR_JFFS2_FAILED_CONFIG = (int32_t) 8,
FLR_JFFS2_DISABLED = (int32_t) 9,
FLR_JFFS2_STATE_END = (int32_t) 10,
};
typedef enum e_FLR_JFFS2_STATE_E FLR_JFFS2_STATE_E;
enum e_FLR_MEM_LOCATION_E {
FLR_MEM_INVALID = (int32_t) 0,
FLR_MEM_BOOTLOADER = (int32_t) 1,
FLR_MEM_UPGRADE_APP = (int32_t) 2,
FLR_MEM_LENS_NVFFC = (int32_t) 3,
FLR_MEM_LENS_SFFC = (int32_t) 4,
FLR_MEM_LENS_GAIN = (int32_t) 5,
FLR_MEM_LENS_DISTORTION = (int32_t) 6,
FLR_MEM_USER_SPACE = (int32_t) 7,
FLR_MEM_RUN_CMDS = (int32_t) 8,
FLR_MEM_JFFS2 = (int32_t) 9,
FLR_MEM_MEMTEST_APP = (int32_t) 10,
FLR_MEM_LAST = (int32_t) 11,
};
typedef enum e_FLR_MEM_LOCATION_E FLR_MEM_LOCATION_E;
enum e_FLR_RADIOMETRY_RBFO_TYPE_E {
FLR_RADIOMETRY_DEFAULT_RBFO = (int32_t) 0,
FLR_RADIOMETRY_FACTORY_RBFO = (int32_t) 1,
};
typedef enum e_FLR_RADIOMETRY_RBFO_TYPE_E FLR_RADIOMETRY_RBFO_TYPE_E;
enum e_FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E {
FLR_RADIOMETRY_UNCERTAINTY_FACTOR_1 = (int32_t) 1,
FLR_RADIOMETRY_UNCERTAINTY_FACTOR_2 = (int32_t) 2,
FLR_RADIOMETRY_UNCERTAINTY_FACTOR_3 = (int32_t) 3,
FLR_RADIOMETRY_UNCERTAINTY_FACTOR_4 = (int32_t) 4,
FLR_RADIOMETRY_UNCERTAINTY_FACTOR_5 = (int32_t) 5,
};
typedef enum e_FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E;
enum e_FLR_ROIC_TEMP_MODE_E {
FLR_ROIC_TEMP_NORMAL_MODE = (int32_t) 0,
FLR_ROIC_TEMP_OFFSET_MODE = (int32_t) 1,
FLR_ROIC_TEMP_STATIC_MODE = (int32_t) 2,
FLR_ROIC_TEMP_MODE_END = (int32_t) 3,
};
typedef enum e_FLR_ROIC_TEMP_MODE_E FLR_ROIC_TEMP_MODE_E;
enum e_FLR_ROIC_EXT_SYNC_MODE_E {
FLR_ROIC_EXT_SYNC_DISABLE_MODE = (int32_t) 0,
FLR_ROIC_EXT_SYNC_MASTER_MODE = (int32_t) 1,
FLR_ROIC_EXT_SYNC_SLAVE_MODE = (int32_t) 2,
FLR_ROIC_EXT_SYNC_END = (int32_t) 3,
};
typedef enum e_FLR_ROIC_EXT_SYNC_MODE_E FLR_ROIC_EXT_SYNC_MODE_E;
enum e_FLR_SCNR_CORR_SELECT_E {
FLR_SCNR_STD_CORR = (int32_t) 0,
FLR_SCNR_ABS_DIFF_CORR = (int32_t) 1,
FLR_SCNR_CORR_END = (int32_t) 2,
};
typedef enum e_FLR_SCNR_CORR_SELECT_E FLR_SCNR_CORR_SELECT_E;
enum e_FLR_SCNR_MODE_E {
FLR_SCNR_MODE_M = (int32_t) 0,
FLR_SCNR_MODE_I = (int32_t) 1,
FLR_SCNR_MODE_DIFFS = (int32_t) 2,
FLR_SCNR_MODE_OFFSETS = (int32_t) 3,
FLR_SCNR_MODE_END = (int32_t) 4,
};
typedef enum e_FLR_SCNR_MODE_E FLR_SCNR_MODE_E;
enum e_FLR_SPNR_STATE_E {
FLR_SPNR_READY = (int32_t) 0,
FLR_SPNR_DESIRED = (int32_t) 1,
FLR_SPNR_IN_PROGRESS = (int32_t) 2,
FLR_SPNR_COMPLETE = (int32_t) 3,
};
typedef enum e_FLR_SPNR_STATE_E FLR_SPNR_STATE_E;
enum e_FLR_SPNR_ALGORITHM_E {
FLR_SPNR_ALGO_DWT = (int32_t) 0,
FLR_SPNR_ALGO_DEFAULT = (int32_t) 0,
FLR_SPNR_ALGO_ITER = (int32_t) 1,
};
typedef enum e_FLR_SPNR_ALGORITHM_E FLR_SPNR_ALGORITHM_E;
enum e_FLR_SPNR_RESET_E {
FLR_SPNR_HARD_RESET = (int32_t) 0,
FLR_SPNR_SOFT_RESET = (int32_t) 1,
};
typedef enum e_FLR_SPNR_RESET_E FLR_SPNR_RESET_E;
enum e_FLR_SPOTMETER_STATS_TEMP_MODE_E {
FLR_SPOTMETER_CELCIUS = (int32_t) 0,
FLR_SPOTMETER_FAHRENHEIT = (int32_t) 1,
FLR_SPOTMETER_KELVIN = (int32_t) 2,
FLR_SPOTMETER_END = (int32_t) 3,
};
typedef enum e_FLR_SPOTMETER_STATS_TEMP_MODE_E FLR_SPOTMETER_STATS_TEMP_MODE_E;
enum e_FLR_SYMBOLOGY_TEXT_ALIGNMENT_E {
FLR_SYMBOLOGY_LEFT_TOP = (int16_t) 17,
FLR_SYMBOLOGY_CENTER_TOP = (int16_t) 18,
FLR_SYMBOLOGY_RIGHT_TOP = (int16_t) 19,
FLR_SYMBOLOGY_LEFT_MIDDLE = (int16_t) 33,
FLR_SYMBOLOGY_CENTER_MIDDLE = (int16_t) 34,
FLR_SYMBOLOGY_RIGHT_MIDDLE = (int16_t) 35,
FLR_SYMBOLOGY_LEFT_BOTTOM = (int16_t) 49,
FLR_SYMBOLOGY_CENTER_BOTTOM = (int16_t) 50,
FLR_SYMBOLOGY_RIGHT_BOTTOM = (int16_t) 51,
FLR_SYMBOLOGY_ALIGNMENT_LAST = (int16_t) 64,
};
typedef enum e_FLR_SYMBOLOGY_TEXT_ALIGNMENT_E FLR_SYMBOLOGY_TEXT_ALIGNMENT_E;
enum e_FLR_SYMBOLOGY_TRANSFORMATION_E {
FLR_SYMBOLOGY_TRANSFORMATION_NONE = (int16_t) 0,
FLR_SYMBOLOGY_TRANSFORMATION_FLIP_BOTH = (int16_t) 1,
FLR_SYMBOLOGY_TRANSFORMATION_FLIP_HORIZONTAL = (int16_t) 2,
FLR_SYMBOLOGY_TRANSFORMATION_FLIP_VERTICAL = (int16_t) 3,
};
typedef enum e_FLR_SYMBOLOGY_TRANSFORMATION_E FLR_SYMBOLOGY_TRANSFORMATION_E;
enum e_FLR_SYMBOLOGY_IMAGE_TYPE_E {
FLR_SYMBOLOGY_RAW_IMAGE = (int16_t) 0,
FLR_SYMBOLOGY_PNG_IMAGE = (int16_t) 1,
FLR_SYMBOLOGY_JPEG_IMAGE = (int16_t) 2,
FLR_SYMBOLOGY_BMP_IMAGE = (int16_t) 3,
};
typedef enum e_FLR_SYMBOLOGY_IMAGE_TYPE_E FLR_SYMBOLOGY_IMAGE_TYPE_E;
enum e_FLR_SYMBOLOGY_SCALING_MODE_E {
FLR_SYMBOLOGY_SCALING_MODE_NONE = (int16_t) 0,
FLR_SYMBOLOGY_SCALING_MODE_FIT = (int16_t) 1,
FLR_SYMBOLOGY_SCALING_MODE_CROP = (int16_t) 2,
FLR_SYMBOLOGY_SCALING_MODE_FILL = (int16_t) 3,
};
typedef enum e_FLR_SYMBOLOGY_SCALING_MODE_E FLR_SYMBOLOGY_SCALING_MODE_E;
enum e_FLR_SYMBOLOGY_TYPE_E {
FLR_SYMBOLOGY_EMPTY = (int16_t) 0,
FLR_SYMBOLOGY_BITMAP = (int16_t) 1,
FLR_SYMBOLOGY_ARC = (int16_t) 2,
FLR_SYMBOLOGY_TEXT = (int16_t) 3,
FLR_SYMBOLOGY_FILLEDRECTANGLE = (int16_t) 4,
FLR_SYMBOLOGY_RECTANGLE = (int16_t) 5,
FLR_SYMBOLOGY_FILLEDELLIPSE = (int16_t) 6,
FLR_SYMBOLOGY_LINE = (int16_t) 7,
FLR_SYMBOLOGY_SPRITE = (int16_t) 8,
};
typedef enum e_FLR_SYMBOLOGY_TYPE_E FLR_SYMBOLOGY_TYPE_E;
enum e_FLR_SYSCTRL_USBIR16_MODE_E {
FLR_SYSCTRL_USBIR16_MODE_16 = (int32_t) 0,
FLR_SYSCTRL_USBIR16_MODE_14 = (int32_t) 1,
FLR_SYSCTRL_USBIR16_MODE_TLINEAR = (int32_t) 2,
FLR_SYSCTRL_USBIR16_MODE_LAST = (int32_t) 3,
};
typedef enum e_FLR_SYSCTRL_USBIR16_MODE_E FLR_SYSCTRL_USBIR16_MODE_E;
enum e_FLR_SYSCTRL_OPERATING_MODE_E {
FLR_SYSCTRL_MODE_UNKNOWN = (int32_t) -1,
FLR_SYSCTRL_MODE_STARTUP = (int32_t) 0,
FLR_SYSCTRL_MODE_NORMAL_IMAGING = (int32_t) 1,
FLR_SYSCTRL_MODE_UPDATE = (int32_t) 2,
FLR_SYSCTRL_MODE_LOW_POWER_IMAGING = (int32_t) 3,
FLR_SYSCTRL_MODE_LOW_POWER = (int32_t) 4,
FLR_SYSCTRL_MODE_TESTRAMP = (int32_t) 5,
FLR_SYSCTRL_MODE_LENS_GAIN_CAL = (int32_t) 6,
FLR_SYSCTRL_MODE_SFFC_CAL = (int32_t) 7,
FLR_SYSCTRL_MODE_END = (int32_t) 8,
};
typedef enum e_FLR_SYSCTRL_OPERATING_MODE_E FLR_SYSCTRL_OPERATING_MODE_E;
enum e_FLR_SYSINFO_SW_CONFIG_ID_E {
FLR_SYSINFO_UNKNOWN = (int32_t) 0,
FLR_SYSINFO_BOSON_1406 = (int32_t) 1,
FLR_SYSINFO_BOSON_1407 = (int32_t) 2,
FLR_SYSINFO_BOSON_1403 = (int32_t) 3,
FLR_SYSINFO_BOSON_BLENDED = (int32_t) 4,
FLR_SYSINFO_BOSON_OTS = (int32_t) 5,
FLR_SYSINFO_BOSON_MARITIME = (int32_t) 6,
FLR_SYSINFO_NV4 = (int32_t) 7,
FLR_SYSINFO_BOSON_SWIR = (int32_t) 8,
FLR_SYSINFO_SENSORTEST_1406 = (int32_t) 9,
FLR_SYSINFO_SENSORTEST_1407 = (int32_t) 10,
FLR_SYSINFO_NEUTRINOLC = (int32_t) 11,
FLR_SYSINFO_GLUON_1406 = (int32_t) 12,
FLR_SYSINFO_GLUON_1407 = (int32_t) 13,
FLR_SYSINFO_GRAVITON_1407 = (int32_t) 14,
FLR_SYSINFO_BOSON_1904 = (int32_t) 15,
FLR_SYSINFO_BOSON_OUTLINE_1406 = (int32_t) 16,
FLR_SYSINFO_GRAVITON_1406 = (int32_t) 17,
FLR_SYSINFO_BOSON_OUTLINE_1407 = (int32_t) 18,
FLR_SYSINFO_SENSORTEST_1904 = (int32_t) 19,
FLR_SYSINFO_BOSON_MIPI_1407 = (int32_t) 20,
FLR_SYSINFO_BOSON_MIPI_1406 = (int32_t) 21,
FLR_SYSINFO_BOSON_BASE_1407 = (int32_t) 22,
FLR_SYSINFO_BOSON_BASE_1406 = (int32_t) 23,
FLR_SYSINFO_BOSON_MIPI_1904 = (int32_t) 24,
};
typedef enum e_FLR_SYSINFO_SW_CONFIG_ID_E FLR_SYSINFO_SW_CONFIG_ID_E;
enum e_FLR_SYSINFO_SW_PERMISSIONS_E {
FLR_SYSINFO_FACTORY = (int32_t) 0,
FLR_SYSINFO_USER = (int32_t) 1,
};
typedef enum e_FLR_SYSINFO_SW_PERMISSIONS_E FLR_SYSINFO_SW_PERMISSIONS_E;
enum e_FLR_SYSINFO_PROBE_TIP_MODEL_E {
FLR_SYSINFO_PTM_UNKNOWN = (int32_t) 0,
FLR_SYSINFO_PTM_VSC_IR32 = (int32_t) 1,
FLR_SYSINFO_PTM_VSC_IR21 = (int32_t) 2,
FLR_SYSINFO_PTM_VS80CIR_21 = (int32_t) 3,
FLR_SYSINFO_PTM_VSC_IR33 = (int32_t) 4,
FLR_SYSINFO_PTM_LAST = (int32_t) 5,
};
typedef enum e_FLR_SYSINFO_PROBE_TIP_MODEL_E FLR_SYSINFO_PROBE_TIP_MODEL_E;
enum e_FLR_SYSTEMSYMBOLS_SYMBOL_E {
FLR_SYSTEMSYMBOLS_FFC_IMMINENT = (int32_t) 0,
FLR_SYSTEMSYMBOLS_FFC_DESIRED = (int32_t) 1,
FLR_SYSTEMSYMBOLS_TABLE_SWITCH_DESIRED = (int32_t) 2,
FLR_SYSTEMSYMBOLS_LOW_GAIN = (int32_t) 3,
FLR_SYSTEMSYMBOLS_OVERTEMP = (int32_t) 4,
FLR_SYSTEMSYMBOLS_SPOTMETER = (int32_t) 5,
FLR_SYSTEMSYMBOLS_ISOTHERM = (int32_t) 6,
FLR_SYSTEMSYMBOLS_SYMBOL_LAST = (int32_t) 7,
};
typedef enum e_FLR_SYSTEMSYMBOLS_SYMBOL_E FLR_SYSTEMSYMBOLS_SYMBOL_E;
enum e_FLR_SYSTEMSYMBOLS_ID_TYPE_E {
FLR_SYSTEMSYMBOLS_ELEMENT = (int32_t) 0,
FLR_SYSTEMSYMBOLS_GROUP = (int32_t) 1,
FLR_SYSTEMSYMBOLS_ID_LAST = (int32_t) 2,
};
typedef enum e_FLR_SYSTEMSYMBOLS_ID_TYPE_E FLR_SYSTEMSYMBOLS_ID_TYPE_E;
enum e_FLR_SYSTEMSYMBOLS_STATE_E {
FLR_SYSTEMSYMBOLS_ENTERED = (int32_t) 0,
FLR_SYSTEMSYMBOLS_EXITED = (int32_t) 1,
FLR_SYSTEMSYMBOLS_STATE_LAST = (int32_t) 2,
};
typedef enum e_FLR_SYSTEMSYMBOLS_STATE_E FLR_SYSTEMSYMBOLS_STATE_E;
enum e_FLR_TELEMETRY_LOC_E {
FLR_TELEMETRY_LOC_TOP = (int32_t) 0,
FLR_TELEMETRY_LOC_BOTTOM = (int32_t) 1,
FLR_TELEMETRY_LOC_END = (int32_t) 2,
};
typedef enum e_FLR_TELEMETRY_LOC_E FLR_TELEMETRY_LOC_E;
enum e_FLR_TELEMETRY_PACKING_E {
FLR_TELEMETRY_PACKING_DEFAULT = (int32_t) 0,
FLR_TELEMETRY_PACKING_Y = (int32_t) 1,
FLR_TELEMETRY_PACKING_8BITS = (int32_t) 2,
FLR_TELEMETRY_PACKING_END = (int32_t) 3,
};
typedef enum e_FLR_TELEMETRY_PACKING_E FLR_TELEMETRY_PACKING_E;
enum e_FLR_TELEMETRY_ORDER_E {
FLR_TELEMETRY_ORDER_DEFAULT = (int32_t) 0,
FLR_TELEMETRY_ORDER_SWAP16B = (int32_t) 1,
FLR_TELEMETRY_ORDER_END = (int32_t) 2,
};
typedef enum e_FLR_TELEMETRY_ORDER_E FLR_TELEMETRY_ORDER_E;
enum e_FLR_TESTRAMP_TYPE_E {
FLR_TESTRAMP_ZERO = (int32_t) 0,
FLR_TESTRAMP_INCREMENTING = (int32_t) 1,
FLR_TESTRAMP_VERT_SHADE = (int32_t) 2,
FLR_TESTRAMP_HORIZ_SHADE = (int32_t) 3,
FLR_TESTRAMP_BIG_VERT_SHADE = (int32_t) 4,
FLR_TESTRAMP_SIMPLE_VERTICAL = (int32_t) 5,
FLR_TESTRAMP_VTST_CHECKERBOARD = (int32_t) 6,
FLR_TESTRAMP_VTST_DIAGONAL_STRIPE = (int32_t) 7,
FLR_TESTRAMP_VTST_MOVING_LINE_BLACK = (int32_t) 8,
FLR_TESTRAMP_VTST_DIAGONAL_LR = (int32_t) 9,
FLR_TESTRAMP_VTST_DIAGONAL_RL = (int32_t) 10,
FLR_TESTRAMP_PN9_FILL = (int32_t) 11,
FLR_TESTRAMP_HORIZ_BARS = (int32_t) 12,
FLR_TESTRAMP_VERT_BARS = (int32_t) 13,
FLR_TESTRAMP_BPR_MAP = (int32_t) 14,
FLR_TESTRAMP_CORN_2_CORN = (int32_t) 15,
FLR_TESTRAMP_PN9_CONTINUOUS = (int32_t) 16,
FLR_TESTRAMP_PSEUDORANDOM = (int32_t) 17,
FLR_TESTRAMP_DMA_LAST = (int32_t) 18,
FLR_TESTRAMP_ONSHAVE_START = (int32_t) 30,
FLR_TESTRAMP_ONSHAVE_VERT_SHADE = (int32_t) 30,
FLR_TESTRAMP_ONSHAVE_HORIZ_SHADE = (int32_t) 31,
FLR_TESTRAMP_ONSHAVE_DIAG_SHADE = (int32_t) 32,
FLR_TESTRAMP_ONSHAVE_ANIMATION = (int32_t) 33,
FLR_TESTRAMP_TYPE_LAST = (int32_t) 34,
};
typedef enum e_FLR_TESTRAMP_TYPE_E FLR_TESTRAMP_TYPE_E;
enum e_FLR_TF_MOTION_MODE_E {
FLR_TF_MOTION_MODE_FRAME_BASED = (int32_t) 0,
FLR_TF_MOTION_MODE_MOTION_BASED = (int32_t) 1,
FLR_TF_MOTION_MODE_END = (int32_t) 2,
};
typedef enum e_FLR_TF_MOTION_MODE_E FLR_TF_MOTION_MODE_E;
enum e_FLR_UART_STARTUP_BAUDRATE_E {
FLR_UART_921600_BAUD = (int32_t) 0,
FLR_UART_460800_BAUD = (int32_t) 1,
FLR_UART_230400_BAUD = (int32_t) 2,
FLR_UART_115200_BAUD = (int32_t) 3,
FLR_UART_57600_BAUD = (int32_t) 4,
FLR_UART_38400_BAUD = (int32_t) 5,
FLR_UART_19200_BAUD = (int32_t) 6,
FLR_UART_14400_BAUD = (int32_t) 7,
FLR_UART_9600_BAUD = (int32_t) 8,
FLR_UART_4800_BAUD = (int32_t) 9,
FLR_UART_2400_BAUD = (int32_t) 10,
FLR_UART_1200_BAUD = (int32_t) 11,
FLR_UART_600_BAUD = (int32_t) 12,
FLR_UART_300_BAUD = (int32_t) 13,
FLR_UART_110_BAUD = (int32_t) 14,
FLR_UART_BAUDRATE_END = (int32_t) 15,
};
typedef enum e_FLR_UART_STARTUP_BAUDRATE_E FLR_UART_STARTUP_BAUDRATE_E;
#endif //ENUM_TYPES_H

View File

@ -0,0 +1,28 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef _FSLP_H
#define _FSLP_H
#include <stdint.h>
#include "serialPortAdapter.h"
void FSLP_send_to_camera(uint8_t channel_ID, uint32_t sendBytes, uint8_t *sendPayload);//, uint32_t *receiveBytes, uint8_t *receivePayload);
// void read_command(uint8_t channel_ID, uint32_t sendBytes, uint8_t *sendPayload, uint32_t *receiveBytes, uint8_t *receivePayload);
int32_t FSLP_read_frame(uint8_t channel_ID, uint16_t start_byte_ms,uint32_t *receiveBytes, uint8_t *receiveBuffer);
void FSLP_read_unframed(uint16_t start_byte_ms,uint32_t *receiveBytes, uint8_t *receiveBuffer);
int32_t FSLP_check_data_ready(uint8_t *channel_ID, uint16_t start_byte_ms, uint32_t *receiveBytes, const uint8_t **receiveBuffer);
#endif //_FSLP_H

View File

@ -0,0 +1,882 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef FUNCTION_CODES_H
#define FUNCTION_CODES_H
enum _functionCodes {
MAXFUNCCODE = 0xFFFFFFFF,
// Module TLinear
TLINEAR_SETCONTROL = 4063233, // 0x003E0001
TLINEAR_GETCONTROL = 4063234, // 0x003E0002
TLINEAR_GETLUT = 4063235, // 0x003E0003
TLINEAR_REFRESHLUT = 4063239, // 0x003E0007
// Module agc
AGC_SETPERCENTPERBIN = 589825, // 0x00090001
AGC_GETPERCENTPERBIN = 589826, // 0x00090002
AGC_SETLINEARPERCENT = 589827, // 0x00090003
AGC_GETLINEARPERCENT = 589828, // 0x00090004
AGC_SETOUTLIERCUT = 589829, // 0x00090005
AGC_GETOUTLIERCUT = 589830, // 0x00090006
AGC_GETDROUT = 589832, // 0x00090008
AGC_SETMAXGAIN = 589833, // 0x00090009
AGC_GETMAXGAIN = 589834, // 0x0009000A
AGC_SETDF = 589835, // 0x0009000B
AGC_GETDF = 589836, // 0x0009000C
AGC_SETGAMMA = 589837, // 0x0009000D
AGC_GETGAMMA = 589838, // 0x0009000E
AGC_GETFIRSTBIN = 589840, // 0x00090010
AGC_GETLASTBIN = 589842, // 0x00090012
AGC_SETDETAILHEADROOM = 589843, // 0x00090013
AGC_GETDETAILHEADROOM = 589844, // 0x00090014
AGC_SETD2BR = 589845, // 0x00090015
AGC_GETD2BR = 589846, // 0x00090016
AGC_SETSIGMAR = 589847, // 0x00090017
AGC_GETSIGMAR = 589848, // 0x00090018
AGC_SETUSEENTROPY = 589854, // 0x0009001E
AGC_GETUSEENTROPY = 589855, // 0x0009001F
AGC_SETROI = 589856, // 0x00090020
AGC_GETROI = 589857, // 0x00090021
AGC_GETMAXGAINAPPLIED = 589861, // 0x00090025
AGC_GETSIGMARAPPLIED = 589862, // 0x00090026
AGC_SETOUTLIERCUTBALANCE = 589863, // 0x00090027
AGC_GETOUTLIERCUTBALANCE = 589864, // 0x00090028
AGC_GETOUTLIERCUTAPPLIED = 589865, // 0x00090029
AGC_SETDETAILHEADROOMBALANCE = 589866, // 0x0009002A
AGC_GETDETAILHEADROOMBALANCE = 589867, // 0x0009002B
AGC_GETDETAILHEADROOMAPPLIED = 589868, // 0x0009002C
AGC_GETTFTHRESHOLDS = 589872, // 0x00090030
AGC_SETTFTHRESHOLDS = 589873, // 0x00090031
AGC_GETMODE = 589874, // 0x00090032
AGC_SETMODE = 589875, // 0x00090033
AGC_SETHIGHTEMPALARMVALUES = 589876, // 0x00090034
AGC_GETCONTRAST = 589888, // 0x00090040
AGC_SETCONTRAST = 589889, // 0x00090041
AGC_GETBRIGHTNESSBIAS = 589890, // 0x00090042
AGC_SETBRIGHTNESSBIAS = 589891, // 0x00090043
AGC_GETBRIGHTNESS = 589892, // 0x00090044
AGC_SETBRIGHTNESS = 589893, // 0x00090045
AGC_SETMAXGAINFORLOWGAIN = 589894, // 0x00090046
AGC_GETMAXGAINFORLOWGAIN = 589895, // 0x00090047
AGC_SETRADIUS = 589898, // 0x0009004A
AGC_GETRADIUS = 589899, // 0x0009004B
AGC_SETGMAX = 589900, // 0x0009004C
AGC_GETGMAX = 589901, // 0x0009004D
AGC_SETGMIN = 589902, // 0x0009004E
AGC_GETGMIN = 589903, // 0x0009004F
// Module boson
BOSON_GETCAMERASN = 327682, // 0x00050002
BOSON_GETCAMERAPN = 327684, // 0x00050004
BOSON_GETSENSORSN = 327686, // 0x00050006
BOSON_RUNFFC = 327687, // 0x00050007
BOSON_SETFFCTEMPTHRESHOLD = 327688, // 0x00050008
BOSON_GETFFCTEMPTHRESHOLD = 327689, // 0x00050009
BOSON_SETFFCFRAMETHRESHOLD = 327690, // 0x0005000A
BOSON_GETFFCFRAMETHRESHOLD = 327691, // 0x0005000B
BOSON_GETFFCINPROGRESS = 327692, // 0x0005000C
BOSON_REBOOT = 327696, // 0x00050010
BOSON_SETFFCMODE = 327698, // 0x00050012
BOSON_GETFFCMODE = 327699, // 0x00050013
BOSON_SETGAINMODE = 327700, // 0x00050014
BOSON_GETGAINMODE = 327701, // 0x00050015
BOSON_WRITEDYNAMICHEADERTOFLASH = 327704, // 0x00050018
BOSON_READDYNAMICHEADERFROMFLASH = 327705, // 0x00050019
BOSON_RESTOREFACTORYDEFAULTSFROMFLASH = 327707, // 0x0005001B
BOSON_RESTOREFACTORYBADPIXELSFROMFLASH = 327712, // 0x00050020
BOSON_WRITEBADPIXELSTOFLASH = 327713, // 0x00050021
BOSON_GETSOFTWAREREV = 327714, // 0x00050022
BOSON_SETBADPIXELLOCATION = 327725, // 0x0005002D
BOSON_LOOKUPFPATEMPDEGCX10 = 327728, // 0x00050030
BOSON_LOOKUPFPATEMPDEGKX10 = 327729, // 0x00050031
BOSON_WRITELENSNVFFCTOFLASH = 327731, // 0x00050033
BOSON_WRITELENSGAINTOFLASH = 327733, // 0x00050035
BOSON_SETLENSNUMBER = 327736, // 0x00050038
BOSON_GETLENSNUMBER = 327737, // 0x00050039
BOSON_SETTABLENUMBER = 327738, // 0x0005003A
BOSON_GETTABLENUMBER = 327739, // 0x0005003B
BOSON_GETSENSORPN = 327743, // 0x0005003F
BOSON_SETGAINSWITCHPARAMS = 327744, // 0x00050040
BOSON_GETGAINSWITCHPARAMS = 327745, // 0x00050041
BOSON_GETSWITCHTOHIGHGAINFLAG = 327746, // 0x00050042
BOSON_GETSWITCHTOLOWGAINFLAG = 327747, // 0x00050043
BOSON_GETCLOWTOHIGHPERCENT = 327748, // 0x00050044
BOSON_GETMAXNUCTABLES = 327749, // 0x00050045
BOSON_GETMAXLENSTABLES = 327750, // 0x00050046
BOSON_GETFFCWAITCLOSEFRAMES = 327758, // 0x0005004E
BOSON_SETFFCWAITCLOSEFRAMES = 327759, // 0x0005004F
BOSON_CHECKFORTABLESWITCH = 327760, // 0x00050050
BOSON_GETDESIREDTABLENUMBER = 327762, // 0x00050052
BOSON_GETFFCSTATUS = 327764, // 0x00050054
BOSON_GETFFCDESIRED = 327765, // 0x00050055
BOSON_GETSWREVINHEADER = 327766, // 0x00050056
BOSON_GETLASTFFCFRAMECOUNT = 327773, // 0x0005005D
BOSON_GETLASTFFCTEMPDEGKX10 = 327774, // 0x0005005E
BOSON_GETTABLESWITCHDESIRED = 327775, // 0x0005005F
BOSON_GETOVERTEMPTHRESHOLD = 327777, // 0x00050061
BOSON_GETLOWPOWERMODE = 327778, // 0x00050062
BOSON_GETOVERTEMPEVENTOCCURRED = 327779, // 0x00050063
BOSON_SETPERMITTHERMALSHUTDOWNOVERRIDE = 327780, // 0x00050064
BOSON_GETPERMITTHERMALSHUTDOWNOVERRIDE = 327781, // 0x00050065
BOSON_GETMYRIADTEMP = 327784, // 0x00050068
BOSON_GETNVFFCNUCTABLENUMBERLENS0 = 327789, // 0x0005006D
BOSON_GETNVFFCNUCTABLENUMBERLENS1 = 327791, // 0x0005006F
BOSON_GETNVFFCFPATEMPDEGKX10LENS0 = 327793, // 0x00050071
BOSON_GETNVFFCFPATEMPDEGKX10LENS1 = 327795, // 0x00050073
BOSON_SETFFCWARNTIMEINSECX10 = 327796, // 0x00050074
BOSON_GETFFCWARNTIMEINSECX10 = 327797, // 0x00050075
BOSON_GETOVERTEMPEVENTCOUNTER = 327798, // 0x00050076
BOSON_SETOVERTEMPTIMERINSEC = 327799, // 0x00050077
BOSON_GETOVERTEMPTIMERINSEC = 327800, // 0x00050078
BOSON_UNLOADCURRENTLENSCORRECTIONS = 327801, // 0x00050079
BOSON_SETTIMEFORQUICKFFCSINSECS = 327802, // 0x0005007A
BOSON_GETTIMEFORQUICKFFCSINSECS = 327803, // 0x0005007B
BOSON_RELOADCURRENTLENSCORRECTIONS = 327804, // 0x0005007C
BOSON_GETBOOTTIMESTAMPS = 327807, // 0x0005007F
BOSON_SETEXTSYNCMODE = 327832, // 0x00050098
BOSON_GETEXTSYNCMODE = 327833, // 0x00050099
BOSON_GETLASTCOMMAND = 327834, // 0x0005009A
BOSON_GETSENSORHOSTCALVERSION = 327840, // 0x000500A0
BOSON_SETDESIREDSTARTUPTABLENUMBER = 327841, // 0x000500A1
BOSON_GETDESIREDSTARTUPTABLENUMBER = 327842, // 0x000500A2
BOSON_SETNVFFCMEANVALUELENS0 = 327843, // 0x000500A3
BOSON_GETNVFFCMEANVALUELENS0 = 327844, // 0x000500A4
BOSON_SETNVFFCMEANVALUELENS1 = 327845, // 0x000500A5
BOSON_GETNVFFCMEANVALUELENS1 = 327846, // 0x000500A6
BOSON_SETINVERTIMAGE = 327847, // 0x000500A7
BOSON_GETINVERTIMAGE = 327848, // 0x000500A8
BOSON_SETREVERTIMAGE = 327849, // 0x000500A9
BOSON_GETREVERTIMAGE = 327850, // 0x000500AA
BOSON_GETTIMESTAMP = 327851, // 0x000500AB
BOSON_GETISPFRAMECOUNT = 327852, // 0x000500AC
BOSON_WRITEUSERBADPIXELSTOALLTABLES = 327853, // 0x000500AD
BOSON_WRITEFACTORYBADPIXELSTOALLTABLES = 327854, // 0x000500AE
BOSON_GETTEMPDIODESTATUS = 327857, // 0x000500B1
BOSON_CLEARFACTORYBADPIXELSINDDR = 327858, // 0x000500B2
BOSON_GETFFCWAITOPENFRAMES = 327859, // 0x000500B3
BOSON_SETFFCWAITOPENFRAMES = 327860, // 0x000500B4
BOSON_GETFFCWAITOPENFLAGSETTLEFRAMES = 327861, // 0x000500B5
BOSON_SETFFCWAITOPENFLAGSETTLEFRAMES = 327862, // 0x000500B6
BOSON_GETTAUEXTFFCCOMPATIBILITYMODE = 327866, // 0x000500BA
BOSON_SETTAUEXTFFCCOMPATIBILITYMODE = 327867, // 0x000500BB
BOSON_GETINITIALTABLESELECTIONTEMPOFFSET = 327879, // 0x000500C7
BOSON_SETINITIALTABLESELECTIONTEMPOFFSET = 327880, // 0x000500C8
BOSON_GETIMAGEVALID = 327881, // 0x000500C9
BOSON_GETCURRENTTABLETYPE = 327882, // 0x000500CA
BOSON_GETGAINSWITCHFRAMETHRESHOLD = 327883, // 0x000500CB
BOSON_SETGAINSWITCHFRAMETHRESHOLD = 327884, // 0x000500CC
BOSON_GETGAINSWITCHHYSTERESISTIME = 327885, // 0x000500CD
BOSON_SETGAINSWITCHHYSTERESISTIME = 327886, // 0x000500CE
BOSON_GETGAINSWITCHDESIRED = 327887, // 0x000500CF
BOSON_GETGAINSWITCHRADIOMETRICPARAMS = 327890, // 0x000500D2
BOSON_SETGAINSWITCHRADIOMETRICPARAMS = 327891, // 0x000500D3
BOSON_SETSATURATIONOVERRIDEMODE = 327896, // 0x000500D8
BOSON_GETSATURATIONOVERRIDEMODE = 327897, // 0x000500D9
BOSON_SETSATURATIONOVERRIDEVALUE = 327898, // 0x000500DA
BOSON_GETSATURATIONOVERRIDEVALUE = 327899, // 0x000500DB
BOSON_SETFFCHIGHLOWGAINTHRESHOLDMODE = 327900, // 0x000500DC
BOSON_GETFFCHIGHLOWGAINTHRESHOLDMODE = 327901, // 0x000500DD
BOSON_SETFFCTEMPTHRESHOLDLOWGAIN = 327902, // 0x000500DE
BOSON_GETFFCTEMPTHRESHOLDLOWGAIN = 327903, // 0x000500DF
BOSON_SETFFCFRAMETHRESHOLDLOWGAIN = 327904, // 0x000500E0
BOSON_GETFFCFRAMETHRESHOLDLOWGAIN = 327905, // 0x000500E1
BOSON_GETBOARDID = 327906, // 0x000500E2
BOSON_SETAUTOGAINSWITCHCONDITIONS = 327907, // 0x000500E3
BOSON_GETAUTOGAINSWITCHCONDITIONS = 327908, // 0x000500E4
BOSON_SETGAINSWITCHPARAMSCATS = 327909, // 0x000500E5
BOSON_GETGAINSWITCHPARAMSCATS = 327910, // 0x000500E6
BOSON_GETGAINSWITCHRADIOMETRICPARAMSCATS = 327911, // 0x000500E7
BOSON_SETGAINSWITCHRADIOMETRICPARAMSCATS = 327912, // 0x000500E8
BOSON_GETCLOWTOHIGHPERCENTCATS = 327913, // 0x000500E9
// Module bpr
BPR_GETSTATE = 196609, // 0x00030001
BPR_SETSTATE = 196610, // 0x00030002
BPR_GETSTATS = 196611, // 0x00030003
BPR_GETDISPLAYMODE = 196613, // 0x00030005
BPR_SETDISPLAYMODE = 196614, // 0x00030006
BPR_GETDISPLAYMODEMINVALUE = 196615, // 0x00030007
BPR_SETDISPLAYMODEMINVALUE = 196616, // 0x00030008
BPR_GETDISPLAYMODEMAXVALUE = 196617, // 0x00030009
BPR_SETDISPLAYMODEMAXVALUE = 196618, // 0x0003000A
BPR_GETWORKBUFINDEX = 196619, // 0x0003000B
BPR_SETWORKBUFINDEX = 196620, // 0x0003000C
BPR_GETWORKBUFSTATS = 196621, // 0x0003000D
// Module capture
CAPTURE_SINGLEFRAME = 458753, // 0x00070001
CAPTURE_FRAMES = 458754, // 0x00070002
CAPTURE_SINGLEFRAMEWITHSRC = 458755, // 0x00070003
CAPTURE_SINGLEFRAMETOFILE = 458756, // 0x00070004
CAPTURE_GETSTATUS = 458757, // 0x00070005
// Module colorLut
COLORLUT_SETCONTROL = 720897, // 0x000B0001
COLORLUT_GETCONTROL = 720898, // 0x000B0002
COLORLUT_SETID = 720899, // 0x000B0003
COLORLUT_GETID = 720900, // 0x000B0004
COLORLUT_SETOUTLINECOLOR = 720901, // 0x000B0005
COLORLUT_GETOUTLINECOLOR = 720902, // 0x000B0006
// Module dummy
DUMMY_BADCOMMAND = 3735928559, // 0xDEADBEEF
// Module dvo
DVO_SETANALOGVIDEOSTATE = 393220, // 0x00060004
DVO_GETANALOGVIDEOSTATE = 393221, // 0x00060005
DVO_SETOUTPUTFORMAT = 393222, // 0x00060006
DVO_GETOUTPUTFORMAT = 393223, // 0x00060007
DVO_SETOUTPUTYCBCRSETTINGS = 393224, // 0x00060008
DVO_GETOUTPUTYCBCRSETTINGS = 393225, // 0x00060009
DVO_SETOUTPUTRGBSETTINGS = 393226, // 0x0006000A
DVO_GETOUTPUTRGBSETTINGS = 393227, // 0x0006000B
DVO_APPLYCUSTOMSETTINGS = 393228, // 0x0006000C
DVO_SETDISPLAYMODE = 393229, // 0x0006000D
DVO_GETDISPLAYMODE = 393230, // 0x0006000E
DVO_SETTYPE = 393231, // 0x0006000F
DVO_GETTYPE = 393232, // 0x00060010
DVO_SETVIDEOSTANDARD = 393233, // 0x00060011
DVO_GETVIDEOSTANDARD = 393234, // 0x00060012
DVO_SETCHECKVIDEODACPRESENT = 393235, // 0x00060013
DVO_GETCHECKVIDEODACPRESENT = 393236, // 0x00060014
DVO_SETCUSTOMLCDCONFIG = 393237, // 0x00060015
DVO_GETCUSTOMLCDCONFIG = 393238, // 0x00060016
DVO_SETLCDCONFIG = 393239, // 0x00060017
DVO_GETLCDCONFIG = 393240, // 0x00060018
DVO_GETCLOCKINFO = 393241, // 0x00060019
DVO_SETALLCUSTOMLCDCONFIGS = 393242, // 0x0006001A
DVO_GETALLCUSTOMLCDCONFIGS = 393243, // 0x0006001B
DVO_SETOUTPUTIR16FORMAT = 393244, // 0x0006001C
DVO_GETOUTPUTIR16FORMAT = 393245, // 0x0006001D
DVO_SETLCDCLOCKRATE = 393246, // 0x0006001E
DVO_GETLCDCLOCKRATE = 393247, // 0x0006001F
DVO_SETLCDVIDEOFRAMERATE = 393248, // 0x00060020
DVO_GETLCDVIDEOFRAMERATE = 393249, // 0x00060021
DVO_SETMIPISTARTSTATE = 393250, // 0x00060022
DVO_GETMIPISTARTSTATE = 393251, // 0x00060023
DVO_SETMIPISTATE = 393252, // 0x00060024
DVO_GETMIPISTATE = 393253, // 0x00060025
DVO_SETMIPICLOCKLANEMODE = 393254, // 0x00060026
DVO_GETMIPICLOCKLANEMODE = 393255, // 0x00060027
DVO_SETOUTPUTINTERFACE = 393256, // 0x00060028
DVO_GETOUTPUTINTERFACE = 393257, // 0x00060029
DVO_SETOUTPUTFORMATVC1 = 393258, // 0x0006002A
DVO_GETOUTPUTFORMATVC1 = 393259, // 0x0006002B
// Module dvoMux
DVOMUX_SETTYPE = 3342336, // 0x00330000
DVOMUX_GETTYPE = 3342337, // 0x00330001
// Module fileOps
FILEOPS_DIR = 1441792, // 0x00160000
FILEOPS_CD = 1441793, // 0x00160001
FILEOPS_MD = 1441794, // 0x00160002
FILEOPS_FOPEN = 1441795, // 0x00160003
FILEOPS_FCLOSE = 1441796, // 0x00160004
FILEOPS_FREAD = 1441797, // 0x00160005
FILEOPS_FWRITE = 1441798, // 0x00160006
FILEOPS_FTELL = 1441799, // 0x00160007
FILEOPS_FSEEK = 1441800, // 0x00160008
FILEOPS_FTRUNCATE = 1441801, // 0x00160009
FILEOPS_RMDIR = 1441802, // 0x0016000A
FILEOPS_RM = 1441803, // 0x0016000B
FILEOPS_RENAME = 1441804, // 0x0016000C
FILEOPS_GETFILESIZE = 1441805, // 0x0016000D
// Module flashIO
FLASHIO_SETPROTECTIONSTATE = 3145729, // 0x00300001
FLASHIO_GETPROTECTIONSTATE = 3145730, // 0x00300002
// Module flashMapFs
FLASHMAPFS_GETHEADERVERSION = 3407877, // 0x00340005
// Module gao
GAO_SETGAINSTATE = 1, // 0x00000001
GAO_GETGAINSTATE = 2, // 0x00000002
GAO_SETFFCSTATE = 3, // 0x00000003
GAO_GETFFCSTATE = 4, // 0x00000004
GAO_SETTEMPCORRECTIONSTATE = 5, // 0x00000005
GAO_GETTEMPCORRECTIONSTATE = 6, // 0x00000006
GAO_SETICONSTL = 7, // 0x00000007
GAO_GETICONSTL = 8, // 0x00000008
GAO_SETICONSTM = 9, // 0x00000009
GAO_GETICONSTM = 10, // 0x0000000A
GAO_SETAVERAGERSTATE = 11, // 0x0000000B
GAO_GETAVERAGERSTATE = 12, // 0x0000000C
GAO_SETNUMFFCFRAMES = 13, // 0x0000000D
GAO_GETNUMFFCFRAMES = 14, // 0x0000000E
GAO_GETAVERAGERTHRESHOLD = 16, // 0x00000010
GAO_SETTESTRAMPSTATE = 19, // 0x00000013
GAO_GETTESTRAMPSTATE = 20, // 0x00000014
GAO_SETSFFCSTATE = 23, // 0x00000017
GAO_GETSFFCSTATE = 24, // 0x00000018
GAO_SETNUCTYPE = 35, // 0x00000023
GAO_GETNUCTYPE = 36, // 0x00000024
GAO_SETFFCZEROMEANSTATE = 37, // 0x00000025
GAO_GETFFCZEROMEANSTATE = 38, // 0x00000026
GAO_GETAVERAGERDESIREDSTATE = 62, // 0x0000003E
GAO_GETAPPLIEDCLIP = 77, // 0x0000004D
GAO_SETAPPLIEDCLIPENABLE = 79, // 0x0000004F
GAO_GETAPPLIEDCLIPENABLE = 80, // 0x00000050
GAO_SETFFCSHUTTERSIMULATIONSTATE = 90, // 0x0000005A
GAO_GETFFCSHUTTERSIMULATIONSTATE = 91, // 0x0000005B
GAO_SETFFCSHUTTERSIMULATORVALUE = 92, // 0x0000005C
GAO_GETFFCSHUTTERSIMULATORVALUE = 93, // 0x0000005D
GAO_SETBCNRSTATE = 95, // 0x0000005F
GAO_GETBCNRSTATE = 96, // 0x00000060
GAO_GETAPPLIEDSFFCSCALEFACTOR = 97, // 0x00000061
GAO_SETSFFCMODE = 98, // 0x00000062
GAO_GETSFFCMODE = 99, // 0x00000063
// Module imageStats
IMAGESTATS_GETTOTALHISTPIXELSINROI = 1900544, // 0x001D0000
IMAGESTATS_GETPOPBELOWLOWTOHIGHTHRESH = 1900545, // 0x001D0001
IMAGESTATS_GETPOPABOVEHIGHTOLOWTHRESH = 1900546, // 0x001D0002
IMAGESTATS_SETROI = 1900547, // 0x001D0003
IMAGESTATS_GETROI = 1900548, // 0x001D0004
IMAGESTATS_GETFIRSTBIN = 1900549, // 0x001D0005
IMAGESTATS_GETLASTBIN = 1900550, // 0x001D0006
IMAGESTATS_GETMEAN = 1900551, // 0x001D0007
IMAGESTATS_GETFIRSTBININROI = 1900552, // 0x001D0008
IMAGESTATS_GETLASTBININROI = 1900553, // 0x001D0009
IMAGESTATS_GETMEANINROI = 1900554, // 0x001D000A
IMAGESTATS_GETIMAGESTATS = 1900555, // 0x001D000B
IMAGESTATS_GETPOPABOVELOWTOHIGHTHRESHCATS = 1900556, // 0x001D000C
IMAGESTATS_GETPOPBELOWHIGHTOLOWTHRESHCATS = 1900557, // 0x001D000D
IMAGESTATS_GETPOPBETWEENLTHCATSANDLTHSATS = 1900558, // 0x001D000E
// Module isotherm
ISOTHERM_GETENABLE = 4128838, // 0x003F0046
ISOTHERM_SETENABLE = 4128839, // 0x003F0047
ISOTHERM_SETTEMPS = 4128840, // 0x003F0048
ISOTHERM_GETTEMPS = 4128841, // 0x003F0049
ISOTHERM_SETISOCOLORVALUES = 4128842, // 0x003F004A
ISOTHERM_GETISOCOLORVALUES = 4128843, // 0x003F004B
ISOTHERM_SETREGIONMODE = 4128844, // 0x003F004C
ISOTHERM_GETREGIONMODE = 4128845, // 0x003F004D
ISOTHERM_GETUNIT = 4128846, // 0x003F004E
ISOTHERM_SETUNIT = 4128847, // 0x003F004F
ISOTHERM_GETSETTINGSLOWGAIN = 4128848, // 0x003F0050
ISOTHERM_SETSETTINGSLOWGAIN = 4128849, // 0x003F0051
ISOTHERM_GETSETTINGSHIGHGAIN = 4128850, // 0x003F0052
ISOTHERM_SETSETTINGSHIGHGAIN = 4128851, // 0x003F0053
ISOTHERM_SETCOLORLUTID = 4128852, // 0x003F0054
ISOTHERM_GETCOLORLUTID = 4128853, // 0x003F0055
// Module jffs2
JFFS2_MOUNT = 1507329, // 0x00170001
JFFS2_UNMOUNT = 1507330, // 0x00170002
JFFS2_GETSTATE = 1507335, // 0x00170007
// Module lagrange
// Module latencyCtrl
LATENCYCTRL_SETLOWLATENCYSTATE = 3735552, // 0x00390000
LATENCYCTRL_GETLOWLATENCYSTATE = 3735553, // 0x00390001
LATENCYCTRL_SETJITTERREDUCTION = 3735554, // 0x00390002
LATENCYCTRL_GETJITTERREDUCTION = 3735555, // 0x00390003
LATENCYCTRL_LATENCYRESETSTATS = 3735556, // 0x00390004
LATENCYCTRL_GETJITTER = 3735557, // 0x00390005
LATENCYCTRL_GETLATENCY = 3735558, // 0x00390006
LATENCYCTRL_SETUSBVIDEOLATENCYREDUCTION = 3735559, // 0x00390007
LATENCYCTRL_GETUSBVIDEOLATENCYREDUCTION = 3735560, // 0x00390008
// Module lfsr
LFSR_SETAPPLYOFFSETENABLESTATE = 2883585, // 0x002C0001
LFSR_GETAPPLYOFFSETENABLESTATE = 2883586, // 0x002C0002
LFSR_SETMAXITERATIONS = 2883592, // 0x002C0008
LFSR_GETMAXITERATIONS = 2883593, // 0x002C0009
LFSR_SETDF = 2883594, // 0x002C000A
LFSR_GETDF = 2883595, // 0x002C000B
LFSR_SETLAMBDA1 = 2883596, // 0x002C000C
LFSR_GETLAMBDA1 = 2883597, // 0x002C000D
LFSR_SETLAMBDA2 = 2883598, // 0x002C000E
LFSR_GETLAMBDA2 = 2883599, // 0x002C000F
LFSR_SETHALTENABLE = 2883603, // 0x002C0013
LFSR_GETHALTENABLE = 2883604, // 0x002C0014
LFSR_SETRANDOMMETHOD = 2883605, // 0x002C0015
LFSR_GETRANDOMMETHOD = 2883606, // 0x002C0016
LFSR_SETSINGLESTEPENABLE = 2883607, // 0x002C0017
LFSR_GETSINGLESTEPENABLE = 2883608, // 0x002C0018
LFSR_SETR_LOCALBUMP = 2883610, // 0x002C001A
LFSR_GETR_LOCALBUMP = 2883611, // 0x002C001B
LFSR_SETR_CORNERBUMP = 2883612, // 0x002C001C
LFSR_GETR_CORNERBUMP = 2883613, // 0x002C001D
LFSR_SETFFC_RESETENABLE = 2883622, // 0x002C0026
LFSR_GETFFC_RESETENABLE = 2883623, // 0x002C0027
LFSR_SETNORMALIZEATCENTERSPOTSTATE = 2883624, // 0x002C0028
LFSR_GETNORMALIZEATCENTERSPOTSTATE = 2883625, // 0x002C0029
// Module mem
MEM_READCAPTURE = 4294901763, // 0xFFFF0003
MEM_GETCAPTURESIZE = 4294901764, // 0xFFFF0004
MEM_WRITEFLASH = 4294901765, // 0xFFFF0005
MEM_READFLASH = 4294901766, // 0xFFFF0006
MEM_GETFLASHSIZE = 4294901767, // 0xFFFF0007
MEM_ERASEFLASH = 4294901768, // 0xFFFF0008
MEM_ERASEFLASHPARTIAL = 4294901769, // 0xFFFF0009
MEM_READCURRENTGAIN = 4294901770, // 0xFFFF000A
MEM_GETGAINSIZE = 4294901771, // 0xFFFF000B
MEM_GETCAPTURESIZESRC = 4294901772, // 0xFFFF000C
MEM_READCAPTURESRC = 4294901773, // 0xFFFF000D
// Module normalize
// Module radiometry
RADIOMETRY_SETTEMPSTABLEENABLE = 4325376, // 0x00420000
RADIOMETRY_GETTEMPSTABLEENABLE = 4325377, // 0x00420001
RADIOMETRY_SETFNUMBERLENS0 = 4325380, // 0x00420004
RADIOMETRY_GETFNUMBERLENS0 = 4325381, // 0x00420005
RADIOMETRY_SETFNUMBERLENS1 = 4325382, // 0x00420006
RADIOMETRY_GETFNUMBERLENS1 = 4325383, // 0x00420007
RADIOMETRY_SETTAULENS0 = 4325384, // 0x00420008
RADIOMETRY_GETTAULENS0 = 4325385, // 0x00420009
RADIOMETRY_SETTAULENS1 = 4325386, // 0x0042000A
RADIOMETRY_GETTAULENS1 = 4325387, // 0x0042000B
RADIOMETRY_GETGLOBALGAINDESIRED = 4325390, // 0x0042000E
RADIOMETRY_GETGLOBALOFFSETDESIRED = 4325391, // 0x0042000F
RADIOMETRY_GETGLOBALGAINAPPLIED = 4325392, // 0x00420010
RADIOMETRY_GETGLOBALOFFSETAPPLIED = 4325393, // 0x00420011
RADIOMETRY_SETTCOMPONENTOVERRIDEMODE = 4325394, // 0x00420012
RADIOMETRY_GETTCOMPONENTOVERRIDEMODE = 4325395, // 0x00420013
RADIOMETRY_SETGLOBALGAINOVERRIDE = 4325396, // 0x00420014
RADIOMETRY_GETGLOBALGAINOVERRIDE = 4325397, // 0x00420015
RADIOMETRY_SETGLOBALOFFSETOVERRIDE = 4325398, // 0x00420016
RADIOMETRY_GETGLOBALOFFSETOVERRIDE = 4325399, // 0x00420017
RADIOMETRY_SETGLOBALPARAMOVERRIDEMODE = 4325400, // 0x00420018
RADIOMETRY_GETGLOBALPARAMOVERRIDEMODE = 4325401, // 0x00420019
RADIOMETRY_SETRBFOHIGHGAINDEFAULT = 4325402, // 0x0042001A
RADIOMETRY_GETRBFOHIGHGAINDEFAULT = 4325403, // 0x0042001B
RADIOMETRY_SETRBFOLOWGAINDEFAULT = 4325404, // 0x0042001C
RADIOMETRY_GETRBFOLOWGAINDEFAULT = 4325405, // 0x0042001D
RADIOMETRY_SETRBFOHIGHGAINFACTORY = 4325406, // 0x0042001E
RADIOMETRY_GETRBFOHIGHGAINFACTORY = 4325407, // 0x0042001F
RADIOMETRY_SETRBFOLOWGAINFACTORY = 4325408, // 0x00420020
RADIOMETRY_GETRBFOLOWGAINFACTORY = 4325409, // 0x00420021
RADIOMETRY_SETDAMPINGFACTOR = 4325410, // 0x00420022
RADIOMETRY_GETDAMPINGFACTOR = 4325411, // 0x00420023
RADIOMETRY_GETGOMEQ = 4325412, // 0x00420024
RADIOMETRY_GETGOMSHUTTER = 4325413, // 0x00420025
RADIOMETRY_GETGOMLENS = 4325414, // 0x00420026
RADIOMETRY_GETGOMLG = 4325415, // 0x00420027
RADIOMETRY_GETGOMFFC = 4325416, // 0x00420028
RADIOMETRY_GETTEMPLENSHOUSING = 4325417, // 0x00420029
RADIOMETRY_GETTEMPSHUTTERHOUSING = 4325418, // 0x0042002A
RADIOMETRY_GETTEMPSHUTTERPADDLE = 4325419, // 0x0042002B
RADIOMETRY_SETFNUMBERSHUTTERHOUSING = 4325420, // 0x0042002C
RADIOMETRY_GETFNUMBERSHUTTERHOUSING = 4325421, // 0x0042002D
RADIOMETRY_SETEMISSIVITYSHUTTERHOUSING = 4325422, // 0x0042002E
RADIOMETRY_GETEMISSIVITYSHUTTERHOUSING = 4325423, // 0x0042002F
RADIOMETRY_SETM_DTFPA_LENS = 4325424, // 0x00420030
RADIOMETRY_GETM_DTFPA_LENS = 4325425, // 0x00420031
RADIOMETRY_SETOFFSET_LENS = 4325426, // 0x00420032
RADIOMETRY_GETOFFSET_LENS = 4325427, // 0x00420033
RADIOMETRY_SETM_RECURSIVE_LENS = 4325428, // 0x00420034
RADIOMETRY_GETM_RECURSIVE_LENS = 4325429, // 0x00420035
RADIOMETRY_GETGGFFC = 4325430, // 0x00420036
RADIOMETRY_GETCOUNTSFROMTEMP = 4325431, // 0x00420037
RADIOMETRY_GETTEMPFROMCOUNTS = 4325432, // 0x00420038
RADIOMETRY_SETTEMPLENSHOUSINGOVERRIDE = 4325433, // 0x00420039
RADIOMETRY_GETTEMPLENSHOUSINGOVERRIDE = 4325434, // 0x0042003A
RADIOMETRY_SETTEMPSHUTTERHOUSINGOVERRIDE = 4325435, // 0x0042003B
RADIOMETRY_GETTEMPSHUTTERHOUSINGOVERRIDE = 4325436, // 0x0042003C
RADIOMETRY_SETTEMPSHUTTERPADDLEOVERRIDE = 4325437, // 0x0042003D
RADIOMETRY_GETTEMPSHUTTERPADDLEOVERRIDE = 4325438, // 0x0042003E
RADIOMETRY_SETSIGNALFACTORLUT = 4325439, // 0x0042003F
RADIOMETRY_GETSIGNALFACTORLUT = 4325440, // 0x00420040
RADIOMETRY_SETNOISEFACTORLUT = 4325441, // 0x00420041
RADIOMETRY_GETNOISEFACTORLUT = 4325442, // 0x00420042
RADIOMETRY_SETM_TFPAK = 4325447, // 0x00420047
RADIOMETRY_GETM_TFPAK = 4325448, // 0x00420048
RADIOMETRY_SETB_TFPAK = 4325449, // 0x00420049
RADIOMETRY_GETB_TFPAK = 4325450, // 0x0042004A
RADIOMETRY_SETTAUXPARAMS = 4325451, // 0x0042004B
RADIOMETRY_GETTAUXPARAMS = 4325452, // 0x0042004C
RADIOMETRY_SETM_TAUX = 4325453, // 0x0042004D
RADIOMETRY_GETM_TAUX = 4325454, // 0x0042004E
RADIOMETRY_SETB_TAUX = 4325455, // 0x0042004F
RADIOMETRY_GETB_TAUX = 4325456, // 0x00420050
RADIOMETRY_SETTSOURCE_FFC = 4325457, // 0x00420051
RADIOMETRY_GETTSOURCE_FFC = 4325458, // 0x00420052
RADIOMETRY_SETM_DTFPA_SH_H = 4325459, // 0x00420053
RADIOMETRY_GETM_DTFPA_SH_H = 4325460, // 0x00420054
RADIOMETRY_SETOFFSET_SH_H = 4325461, // 0x00420055
RADIOMETRY_GETOFFSET_SH_H = 4325462, // 0x00420056
RADIOMETRY_SETM_RECURSIVE_SH_H = 4325463, // 0x00420057
RADIOMETRY_GETM_RECURSIVE_SH_H = 4325464, // 0x00420058
RADIOMETRY_SETM_DTFPA_SH_P = 4325465, // 0x00420059
RADIOMETRY_GETM_DTFPA_SH_P = 4325466, // 0x0042005A
RADIOMETRY_SETOFFSET_SH_P = 4325467, // 0x0042005B
RADIOMETRY_GETOFFSET_SH_P = 4325468, // 0x0042005C
RADIOMETRY_SETM_RECURSIVE_SH_P = 4325469, // 0x0042005D
RADIOMETRY_GETM_RECURSIVE_SH_P = 4325470, // 0x0042005E
RADIOMETRY_SETM_DELTA_SH_P = 4325471, // 0x0042005F
RADIOMETRY_GETM_DELTA_SH_P = 4325472, // 0x00420060
RADIOMETRY_SETB_DELTA_SH_P = 4325473, // 0x00420061
RADIOMETRY_GETB_DELTA_SH_P = 4325474, // 0x00420062
RADIOMETRY_GETDTTFPAK = 4325476, // 0x00420064
RADIOMETRY_GETDTTFPAK_DAMP = 4325477, // 0x00420065
RADIOMETRY_GETTAUXK = 4325478, // 0x00420066
RADIOMETRY_SETEXTERNALFFCUPDATEMODE = 4325479, // 0x00420067
RADIOMETRY_GETEXTERNALFFCUPDATEMODE = 4325480, // 0x00420068
RADIOMETRY_GETGG_SCALE = 4325482, // 0x0042006A
RADIOMETRY_SETTEMPWINDOW = 4325483, // 0x0042006B
RADIOMETRY_GETTEMPWINDOW = 4325484, // 0x0042006C
RADIOMETRY_SETTRANSMISSIONWINDOW = 4325485, // 0x0042006D
RADIOMETRY_GETTRANSMISSIONWINDOW = 4325486, // 0x0042006E
RADIOMETRY_SETREFLECTIVITYWINDOW = 4325487, // 0x0042006F
RADIOMETRY_GETREFLECTIVITYWINDOW = 4325488, // 0x00420070
RADIOMETRY_SETTEMPWINDOWREFLECTION = 4325489, // 0x00420071
RADIOMETRY_GETTEMPWINDOWREFLECTION = 4325490, // 0x00420072
RADIOMETRY_SETTRANSMISSIONATMOSPHERE = 4325491, // 0x00420073
RADIOMETRY_GETTRANSMISSIONATMOSPHERE = 4325492, // 0x00420074
RADIOMETRY_SETTEMPATMOSPHERE = 4325493, // 0x00420075
RADIOMETRY_GETTEMPATMOSPHERE = 4325494, // 0x00420076
RADIOMETRY_SETEMISSIVITYTARGET = 4325495, // 0x00420077
RADIOMETRY_GETEMISSIVITYTARGET = 4325496, // 0x00420078
RADIOMETRY_SETTEMPBACKGROUND = 4325497, // 0x00420079
RADIOMETRY_GETTEMPBACKGROUND = 4325498, // 0x0042007A
RADIOMETRY_GETRADIOMETRYCAPABLE = 4325501, // 0x0042007D
RADIOMETRY_SETDELTATEMPDAMPINGFACTOR = 4325502, // 0x0042007E
RADIOMETRY_GETDELTATEMPDAMPINGFACTOR = 4325503, // 0x0042007F
RADIOMETRY_SETDELTATEMPINTERVALTIME = 4325504, // 0x00420080
RADIOMETRY_GETDELTATEMPINTERVALTIME = 4325505, // 0x00420081
RADIOMETRY_SETDELTATEMPMAXVALUE = 4325506, // 0x00420082
RADIOMETRY_GETDELTATEMPMAXVALUE = 4325507, // 0x00420083
RADIOMETRY_SETDELTATEMPMAXINCREMENT = 4325508, // 0x00420084
RADIOMETRY_GETDELTATEMPMAXINCREMENT = 4325509, // 0x00420085
RADIOMETRY_SETDELTATEMPDAMPINGTIME = 4325510, // 0x00420086
RADIOMETRY_GETDELTATEMPDAMPINGTIME = 4325511, // 0x00420087
RADIOMETRY_GETRESPONSIVITYFPATEMP = 4325512, // 0x00420088
RADIOMETRY_SETM_DELTA_LENS = 4325513, // 0x00420089
RADIOMETRY_GETM_DELTA_LENS = 4325514, // 0x0042008A
RADIOMETRY_SETB_DELTA_LENS = 4325515, // 0x0042008B
RADIOMETRY_GETB_DELTA_LENS = 4325516, // 0x0042008C
RADIOMETRY_SETM_DELTA_SH_H = 4325517, // 0x0042008D
RADIOMETRY_GETM_DELTA_SH_H = 4325518, // 0x0042008E
RADIOMETRY_SETB_DELTA_SH_H = 4325519, // 0x0042008F
RADIOMETRY_GETB_DELTA_SH_H = 4325520, // 0x00420090
RADIOMETRY_SETGG_SCALE_HG = 4325521, // 0x00420091
RADIOMETRY_GETGG_SCALE_HG = 4325522, // 0x00420092
RADIOMETRY_SETGG_SCALE_LG = 4325523, // 0x00420093
RADIOMETRY_GETGG_SCALE_LG = 4325524, // 0x00420094
RADIOMETRY_SETRBFOSCALEDMODE = 4325525, // 0x00420095
RADIOMETRY_GETRBFOSCALEDMODE = 4325526, // 0x00420096
RADIOMETRY_GETUNCERTAINTYFACTOR = 4325527, // 0x00420097
RADIOMETRY_GETTROOMMINTHRESH = 4325529, // 0x00420099
RADIOMETRY_GETTROOMMAXTHRESH = 4325531, // 0x0042009B
RADIOMETRY_GETTOPERATINGMINTHRESH = 4325533, // 0x0042009D
RADIOMETRY_GETTOPERATINGMAXTHRESH = 4325535, // 0x0042009F
RADIOMETRY_GETSTABLETEMPTHRESH = 4325537, // 0x004200A1
RADIOMETRY_GETSLOWDRIFTTHRESH = 4325539, // 0x004200A3
RADIOMETRY_GETFFCTEMPTHRESH = 4325541, // 0x004200A5
RADIOMETRY_GETTARGETTEMPMINTHRESHLG = 4325543, // 0x004200A7
RADIOMETRY_GETTARGETTEMPMAXTHRESHLG = 4325545, // 0x004200A9
RADIOMETRY_GETMFACTORTHRESH = 4325547, // 0x004200AB
RADIOMETRY_GETTARGETTEMPMINTHRESHHG = 4325549, // 0x004200AD
RADIOMETRY_GETTARGETTEMPMAXTHRESHHG = 4325551, // 0x004200AF
RADIOMETRY_GETUNCERTAINTYSTATUSBITS = 4325552, // 0x004200B0
RADIOMETRY_SETTEMPERATUREOFFSET_HG = 4325553, // 0x004200B1
RADIOMETRY_GETTEMPERATUREOFFSET_HG = 4325554, // 0x004200B2
RADIOMETRY_SETTEMPERATUREOFFSET_LG = 4325555, // 0x004200B3
RADIOMETRY_GETTEMPERATUREOFFSET_LG = 4325556, // 0x004200B4
RADIOMETRY_SETM_DELTA_LENS_HG = 4325557, // 0x004200B5
RADIOMETRY_GETM_DELTA_LENS_HG = 4325558, // 0x004200B6
RADIOMETRY_SETB_DELTA_LENS_HG = 4325559, // 0x004200B7
RADIOMETRY_GETB_DELTA_LENS_HG = 4325560, // 0x004200B8
RADIOMETRY_SETM_DELTA_LENS_LG = 4325561, // 0x004200B9
RADIOMETRY_GETM_DELTA_LENS_LG = 4325562, // 0x004200BA
RADIOMETRY_SETB_DELTA_LENS_LG = 4325563, // 0x004200BB
RADIOMETRY_GETB_DELTA_LENS_LG = 4325564, // 0x004200BC
RADIOMETRY_SETOFFSET_LENS_HG = 4325565, // 0x004200BD
RADIOMETRY_GETOFFSET_LENS_HG = 4325566, // 0x004200BE
RADIOMETRY_SETOFFSET_LENS_LG = 4325567, // 0x004200BF
RADIOMETRY_GETOFFSET_LENS_LG = 4325568, // 0x004200C0
RADIOMETRY_SETM_DELTA_SH_P_HG = 4325569, // 0x004200C1
RADIOMETRY_GETM_DELTA_SH_P_HG = 4325570, // 0x004200C2
RADIOMETRY_SETB_DELTA_SH_P_HG = 4325571, // 0x004200C3
RADIOMETRY_GETB_DELTA_SH_P_HG = 4325572, // 0x004200C4
RADIOMETRY_SETM_DELTA_SH_P_LG = 4325573, // 0x004200C5
RADIOMETRY_GETM_DELTA_SH_P_LG = 4325574, // 0x004200C6
RADIOMETRY_SETB_DELTA_SH_P_LG = 4325575, // 0x004200C7
RADIOMETRY_GETB_DELTA_SH_P_LG = 4325576, // 0x004200C8
RADIOMETRY_SETM_DELTA_SH_H_HG = 4325577, // 0x004200C9
RADIOMETRY_GETM_DELTA_SH_H_HG = 4325578, // 0x004200CA
RADIOMETRY_SETB_DELTA_SH_H_HG = 4325579, // 0x004200CB
RADIOMETRY_GETB_DELTA_SH_H_HG = 4325580, // 0x004200CC
RADIOMETRY_SETM_DELTA_SH_H_LG = 4325581, // 0x004200CD
RADIOMETRY_GETM_DELTA_SH_H_LG = 4325582, // 0x004200CE
RADIOMETRY_SETB_DELTA_SH_H_LG = 4325583, // 0x004200CF
RADIOMETRY_GETB_DELTA_SH_H_LG = 4325584, // 0x004200D0
RADIOMETRY_GETGG_ROOMTEMP = 4325585, // 0x004200D1
// Module roic
ROIC_GETFPATEMP = 131073, // 0x00020001
ROIC_GETFRAMECOUNT = 131074, // 0x00020002
ROIC_GETACTIVENORMALIZATIONTARGET = 131078, // 0x00020006
ROIC_SETFPARAMPSTATE = 131092, // 0x00020014
ROIC_GETFPARAMPSTATE = 131093, // 0x00020015
ROIC_GETSENSORADC1 = 131097, // 0x00020019
ROIC_GETSENSORADC2 = 131098, // 0x0002001A
ROIC_SETFPATEMPOFFSET = 131099, // 0x0002001B
ROIC_GETFPATEMPOFFSET = 131100, // 0x0002001C
ROIC_SETFPATEMPMODE = 131101, // 0x0002001D
ROIC_GETFPATEMPMODE = 131102, // 0x0002001E
ROIC_GETFPATEMPTABLE = 131104, // 0x00020020
ROIC_SETFPATEMPVALUE = 131106, // 0x00020022
ROIC_GETFPATEMPVALUE = 131107, // 0x00020023
ROIC_GETPREAMBLEERROR = 131113, // 0x00020029
ROIC_INDUCEPREAMBLEERROR = 131115, // 0x0002002B
ROIC_GETROICSTARTED = 131116, // 0x0002002C
ROIC_SETFRAMESKIP = 131129, // 0x00020039
ROIC_GETFRAMESKIP = 131130, // 0x0002003A
ROIC_SETFRAMEONESHOT = 131133, // 0x0002003D
// Module scaler
SCALER_GETMAXZOOM = 851969, // 0x000D0001
SCALER_SETZOOM = 851970, // 0x000D0002
SCALER_GETZOOM = 851971, // 0x000D0003
SCALER_SETFRACTIONALZOOM = 851975, // 0x000D0007
SCALER_SETINDEXZOOM = 851976, // 0x000D0008
// Module scnr
SCNR_SETENABLESTATE = 524289, // 0x00080001
SCNR_GETENABLESTATE = 524290, // 0x00080002
SCNR_SETTHCOLSUM = 524291, // 0x00080003
SCNR_GETTHCOLSUM = 524292, // 0x00080004
SCNR_SETTHPIXEL = 524293, // 0x00080005
SCNR_GETTHPIXEL = 524294, // 0x00080006
SCNR_SETMAXCORR = 524295, // 0x00080007
SCNR_GETMAXCORR = 524296, // 0x00080008
SCNR_GETTHPIXELAPPLIED = 524298, // 0x0008000A
SCNR_GETMAXCORRAPPLIED = 524299, // 0x0008000B
SCNR_SETTHCOLSUMSAFE = 524300, // 0x0008000C
SCNR_GETTHCOLSUMSAFE = 524301, // 0x0008000D
SCNR_SETTHPIXELSAFE = 524302, // 0x0008000E
SCNR_GETTHPIXELSAFE = 524303, // 0x0008000F
SCNR_SETMAXCORRSAFE = 524304, // 0x00080010
SCNR_GETMAXCORRSAFE = 524305, // 0x00080011
SCNR_SETCORRECTIONMETHOD = 524306, // 0x00080012
SCNR_GETCORRECTIONMETHOD = 524307, // 0x00080013
SCNR_SETSTDTHRESHOLD = 524308, // 0x00080014
SCNR_GETSTDTHRESHOLD = 524309, // 0x00080015
SCNR_SETNFRAMES = 524310, // 0x00080016
SCNR_GETNFRAMES = 524311, // 0x00080017
SCNR_SETRESETDESIRED = 524312, // 0x00080018
SCNR_GETRESETDESIRED = 524313, // 0x00080019
SCNR_SETM_MODEONLY = 524314, // 0x0008001A
SCNR_GETM_MODEONLY = 524315, // 0x0008001B
SCNR_GETMODE = 524316, // 0x0008001C
SCNR_SETSPECKLESENABLESTATE = 524320, // 0x00080020
SCNR_GETSPECKLESENABLESTATE = 524321, // 0x00080021
SCNR_SETSPECKLESTHRESHOLD = 524322, // 0x00080022
SCNR_GETSPECKLESTHRESHOLD = 524323, // 0x00080023
SCNR_SETSPECKLESRATIO = 524324, // 0x00080024
SCNR_GETSPECKLESRATIO = 524325, // 0x00080025
SCNR_SETSPECKLESDF = 524326, // 0x00080026
SCNR_GETSPECKLESDF = 524327, // 0x00080027
SCNR_GETSPECKLESDIFFSBUFFERADDR = 524328, // 0x00080028
SCNR_GETSPECKLESOFFSBUFFERADDR = 524329, // 0x00080029
SCNR_SETSPECKLESRESETDESIRED = 524330, // 0x0008002A
SCNR_GETSPECKLESRESETDESIRED = 524331, // 0x0008002B
// Module sffc
SFFC_GETSCALEFACTOR = 1835008, // 0x001C0000
SFFC_GETDELTATEMPLINEARCOEFF = 1835009, // 0x001C0001
SFFC_SETDELTATEMPLINEARCOEFF = 1835010, // 0x001C0002
SFFC_GETDELTATEMPOFFSETCOEFF = 1835011, // 0x001C0003
SFFC_SETDELTATEMPOFFSETCOEFF = 1835012, // 0x001C0004
SFFC_GETFPATEMPLINEARCOEFF = 1835013, // 0x001C0005
SFFC_SETFPATEMPLINEARCOEFF = 1835014, // 0x001C0006
SFFC_GETFPATEMPOFFSETCOEFF = 1835015, // 0x001C0007
SFFC_SETFPATEMPOFFSETCOEFF = 1835016, // 0x001C0008
SFFC_GETDELTATEMPTIMELIMITINSECS = 1835017, // 0x001C0009
SFFC_SETDELTATEMPTIMELIMITINSECS = 1835018, // 0x001C000A
// Module spnr
SPNR_SETENABLESTATE = 786433, // 0x000C0001
SPNR_GETENABLESTATE = 786434, // 0x000C0002
SPNR_GETSTATE = 786436, // 0x000C0004
SPNR_SETFRAMEDELAY = 786437, // 0x000C0005
SPNR_GETFRAMEDELAY = 786438, // 0x000C0006
SPNR_SETSF = 786443, // 0x000C000B
SPNR_GETSF = 786444, // 0x000C000C
SPNR_GETSFAPPLIED = 786453, // 0x000C0015
SPNR_SETPSDKERNEL = 786458, // 0x000C001A
SPNR_GETPSDKERNEL = 786459, // 0x000C001B
SPNR_SETSFMIN = 786460, // 0x000C001C
SPNR_GETSFMIN = 786461, // 0x000C001D
SPNR_SETSFMAX = 786462, // 0x000C001E
SPNR_GETSFMAX = 786463, // 0x000C001F
SPNR_SETDFMIN = 786464, // 0x000C0020
SPNR_GETDFMIN = 786465, // 0x000C0021
SPNR_SETDFMAX = 786466, // 0x000C0022
SPNR_GETDFMAX = 786467, // 0x000C0023
SPNR_SETNORMTARGET = 786468, // 0x000C0024
SPNR_GETNORMTARGET = 786469, // 0x000C0025
SPNR_GETNORMTARGETAPPLIED = 786470, // 0x000C0026
SPNR_SETTHPIX = 786471, // 0x000C0027
SPNR_GETTHPIX = 786472, // 0x000C0028
SPNR_SETTHPIXSUM = 786473, // 0x000C0029
SPNR_GETTHPIXSUM = 786474, // 0x000C002A
SPNR_SETMAXCORR = 786475, // 0x000C002B
SPNR_GETMAXCORR = 786476, // 0x000C002C
SPNR_GETALGORITHM = 786483, // 0x000C0033
SPNR_SETALGORITHMDESIRED = 786484, // 0x000C0034
SPNR_GETALGORITHMDESIRED = 786485, // 0x000C0035
SPNR_SETDFFAST = 786487, // 0x000C0037
SPNR_GETDFFAST = 786488, // 0x000C0038
SPNR_SETDFSLOW = 786489, // 0x000C0039
SPNR_GETDFSLOW = 786490, // 0x000C003A
SPNR_SETSENSITIVITYTHRESHOLD = 786491, // 0x000C003B
SPNR_GETSENSITIVITYTHRESHOLD = 786492, // 0x000C003C
SPNR_SETRESET = 786493, // 0x000C003D
// Module spotMeter
SPOTMETER_SETENABLE = 4390912, // 0x00430000
SPOTMETER_GETENABLE = 4390913, // 0x00430001
SPOTMETER_GETROIMAXSIZE = 4390914, // 0x00430002
SPOTMETER_SETROI = 4390915, // 0x00430003
SPOTMETER_GETROI = 4390916, // 0x00430004
SPOTMETER_GETSPOTSTATS = 4390917, // 0x00430005
SPOTMETER_SETSTATSMODE = 4390918, // 0x00430006
SPOTMETER_GETSTATSMODE = 4390919, // 0x00430007
SPOTMETER_GETTEMPSTATS = 4390920, // 0x00430008
// Module srnr
SRNR_SETENABLESTATE = 2621441, // 0x00280001
SRNR_GETENABLESTATE = 2621442, // 0x00280002
SRNR_SETTHROWSUM = 2621443, // 0x00280003
SRNR_GETTHROWSUM = 2621444, // 0x00280004
SRNR_SETTHPIXEL = 2621445, // 0x00280005
SRNR_GETTHPIXEL = 2621446, // 0x00280006
SRNR_SETMAXCORR = 2621447, // 0x00280007
SRNR_GETMAXCORR = 2621448, // 0x00280008
SRNR_GETTHPIXELAPPLIED = 2621450, // 0x0028000A
SRNR_GETMAXCORRAPPLIED = 2621451, // 0x0028000B
// Module symbology
SYMBOLOGY_SETENABLE = 1310720, // 0x00140000
SYMBOLOGY_CREATEBITMAP = 1310721, // 0x00140001
SYMBOLOGY_SENDDATA = 1310723, // 0x00140003
SYMBOLOGY_CREATEARC = 1310724, // 0x00140004
SYMBOLOGY_CREATETEXT = 1310726, // 0x00140006
SYMBOLOGY_MOVESPRITE = 1310727, // 0x00140007
SYMBOLOGY_ADDTOGROUP = 1310728, // 0x00140008
SYMBOLOGY_REMOVEFROMGROUP = 1310729, // 0x00140009
SYMBOLOGY_UPDATEANDSHOW = 1310730, // 0x0014000A
SYMBOLOGY_UPDATEANDSHOWGROUP = 1310731, // 0x0014000B
SYMBOLOGY_DELETE = 1310732, // 0x0014000C
SYMBOLOGY_DELETEGROUP = 1310733, // 0x0014000D
SYMBOLOGY_CREATEFILLEDRECTANGLE = 1310734, // 0x0014000E
SYMBOLOGY_CREATEOUTLINEDRECTANGLE = 1310736, // 0x00140010
SYMBOLOGY_CREATEBITMAPFROMPNG = 1310738, // 0x00140012
SYMBOLOGY_CREATECOMPRESSEDBITMAP = 1310740, // 0x00140014
SYMBOLOGY_CREATEBITMAPFROMPNGFILE = 1310742, // 0x00140016
SYMBOLOGY_CREATEBITMAPFROMFILE = 1310743, // 0x00140017
SYMBOLOGY_RESETWRITEPOSITION = 1310744, // 0x00140018
SYMBOLOGY_MOVEBYOFFSET = 1310745, // 0x00140019
SYMBOLOGY_MOVEGROUPBYOFFSET = 1310746, // 0x0014001A
SYMBOLOGY_CREATEFILLEDELLIPSE = 1310747, // 0x0014001B
SYMBOLOGY_CREATELINE = 1310748, // 0x0014001C
SYMBOLOGY_SETZORDER = 1310749, // 0x0014001D
SYMBOLOGY_SAVECONFIGURATION = 1310750, // 0x0014001E
SYMBOLOGY_RELOADCONFIGURATION = 1310751, // 0x0014001F
SYMBOLOGY_GETENABLE = 1310752, // 0x00140020
SYMBOLOGY_SETCLONESNUMBER = 1310753, // 0x00140021
SYMBOLOGY_MOVECLONEBYOFFSET = 1310754, // 0x00140022
SYMBOLOGY_MOVECLONESPRITE = 1310755, // 0x00140023
SYMBOLOGY_SETTRANSFORMATION = 1310756, // 0x00140024
SYMBOLOGY_UPDATEALLVISIBLE = 1310757, // 0x00140025
SYMBOLOGY_SETSIZEANDSCALINGMODE = 1310758, // 0x00140026
SYMBOLOGY_CREATELINEHVT = 1310759, // 0x00140027
SYMBOLOGY_CREATETEXTHVT = 1310760, // 0x00140028
SYMBOLOGY_CREATETEXTBG = 1310761, // 0x00140029
SYMBOLOGY_CREATESCALEDBITMAPFROMFILE = 1310762, // 0x0014002A
SYMBOLOGY_GETLOCATION = 1310763, // 0x0014002B
SYMBOLOGY_GETSIZE = 1310764, // 0x0014002C
SYMBOLOGY_GETZORDER = 1310765, // 0x0014002D
SYMBOLOGY_GETCOLOR = 1310766, // 0x0014002E
SYMBOLOGY_GETTYPE = 1310767, // 0x0014002F
SYMBOLOGY_COPYSYMBOL = 1310768, // 0x00140030
SYMBOLOGY_GETTEXTFONTSIZE = 1310769, // 0x00140031
// Module sysctrl
SYSCTRL_SETFREEZESTATE = 917505, // 0x000E0001
SYSCTRL_GETFREEZESTATE = 917506, // 0x000E0002
SYSCTRL_GETCAMERAFRAMERATE = 917511, // 0x000E0007
SYSCTRL_GETUPTIMESECS = 917512, // 0x000E0008
SYSCTRL_SETUSBVIDEOIR16MODE = 917517, // 0x000E000D
SYSCTRL_GETUSBVIDEOIR16MODE = 917518, // 0x000E000E
SYSCTRL_SETOPERATINGMODE = 917519, // 0x000E000F
SYSCTRL_GETOPERATINGMODE = 917520, // 0x000E0010
SYSCTRL_GETAVGFPATEMPCOUNTS = 917528, // 0x000E0018
SYSCTRL_SETFPATEMPFRAMES = 917529, // 0x000E0019
SYSCTRL_GETFPATEMPFRAMES = 917536, // 0x000E0020
// Module sysinfo
SYSINFO_GETMONITORSOFTWAREREV = 3080193, // 0x002F0001
SYSINFO_GETMONITORBUILDVARIANT = 3080194, // 0x002F0002
SYSINFO_GETPRODUCTNAME = 3080195, // 0x002F0003
SYSINFO_GETCAMERASN = 3080197, // 0x002F0005
SYSINFO_GETBOOTLOCATION = 3080198, // 0x002F0006
SYSINFO_GETSWCONFIGID = 3080199, // 0x002F0007
SYSINFO_GETSWPERMISSIONS = 3080200, // 0x002F0008
SYSINFO_GETIS9HZBUILD = 3080201, // 0x002F0009
SYSINFO_GETPRODUCTVERSION = 3080202, // 0x002F000A
SYSINFO_GETMONITORPRODUCTREV = 3080207, // 0x002F000F
SYSINFO_GETOPTICALREVISION = 3080209, // 0x002F0011
SYSINFO_GETSENSORREVISION = 3080211, // 0x002F0013
SYSINFO_GETPROBETIPSN = 3080213, // 0x002F0015
SYSINFO_GETMECHANICALREVISION = 3080215, // 0x002F0017
SYSINFO_GETPROBETIPTYPE = 3080216, // 0x002F0018
// Module systemSymbols
SYSTEMSYMBOLS_GETID = 1769474, // 0x001B0002
SYSTEMSYMBOLS_SETID = 1769475, // 0x001B0003
SYSTEMSYMBOLS_GETENABLE = 1769476, // 0x001B0004
SYSTEMSYMBOLS_SETENABLE = 1769477, // 0x001B0005
SYSTEMSYMBOLS_GETSPOTCONFIG = 1769480, // 0x001B0008
SYSTEMSYMBOLS_SETSPOTCONFIG = 1769481, // 0x001B0009
SYSTEMSYMBOLS_GETISOCONFIG = 1769482, // 0x001B000A
SYSTEMSYMBOLS_SETISOCONFIG = 1769483, // 0x001B000B
SYSTEMSYMBOLS_GETBARCONFIG = 1769484, // 0x001B000C
SYSTEMSYMBOLS_SETBARCONFIG = 1769485, // 0x001B000D
SYSTEMSYMBOLS_GETSPOTCONFIGIDS = 1769487, // 0x001B000F
SYSTEMSYMBOLS_SETSPOTCONFIGIDS = 1769488, // 0x001B0010
SYSTEMSYMBOLS_GETISOCONFIGIDS = 1769489, // 0x001B0011
SYSTEMSYMBOLS_SETISOCONFIGIDS = 1769490, // 0x001B0012
// Module telemetry
TELEMETRY_SETSTATE = 262145, // 0x00040001
TELEMETRY_GETSTATE = 262146, // 0x00040002
TELEMETRY_SETLOCATION = 262147, // 0x00040003
TELEMETRY_GETLOCATION = 262148, // 0x00040004
TELEMETRY_SETPACKING = 262149, // 0x00040005
TELEMETRY_GETPACKING = 262150, // 0x00040006
TELEMETRY_SETORDER = 262151, // 0x00040007
TELEMETRY_GETORDER = 262152, // 0x00040008
TELEMETRY_SETPACKINGVC1 = 262153, // 0x00040009
TELEMETRY_GETPACKINGVC1 = 262154, // 0x0004000A
TELEMETRY_SETMIPIEMBEDDEDDATATAG = 262155, // 0x0004000B
TELEMETRY_GETMIPIEMBEDDEDDATATAG = 262156, // 0x0004000C
// Module testRamp
TESTRAMP_SETTYPE = 1048576, // 0x00100000
TESTRAMP_GETTYPE = 1048577, // 0x00100001
TESTRAMP_SETSETTINGS = 1048578, // 0x00100002
TESTRAMP_GETSETTINGS = 1048579, // 0x00100003
TESTRAMP_SETMOTIONSTATE = 1048580, // 0x00100004
TESTRAMP_GETMOTIONSTATE = 1048581, // 0x00100005
TESTRAMP_SETINDEX = 1048582, // 0x00100006
TESTRAMP_GETINDEX = 1048583, // 0x00100007
TESTRAMP_GETMAXINDEX = 1048584, // 0x00100008
TESTRAMP_SETPN9CONTINUOUSMODE = 1048585, // 0x00100009
TESTRAMP_GETPN9CONTINUOUSMODE = 1048586, // 0x0010000A
TESTRAMP_SETANIMATIONSETTINGS = 1048587, // 0x0010000B
TESTRAMP_GETANIMATIONSETTINGS = 1048588, // 0x0010000C
// Module tf
TF_SETENABLESTATE = 655361, // 0x000A0001
TF_GETENABLESTATE = 655362, // 0x000A0002
TF_SETDELTA_NF = 655363, // 0x000A0003
TF_GETDELTA_NF = 655364, // 0x000A0004
TF_SETTHDELTAMOTION = 655365, // 0x000A0005
TF_GETTHDELTAMOTION = 655366, // 0x000A0006
TF_SETWLUT = 655367, // 0x000A0007
TF_GETWLUT = 655368, // 0x000A0008
TF_GETMOTIONCOUNT = 655369, // 0x000A0009
TF_SETMOTIONTHRESHOLD = 655374, // 0x000A000E
TF_GETMOTIONTHRESHOLD = 655375, // 0x000A000F
TF_GETDELTA_NFAPPLIED = 655382, // 0x000A0016
TF_GETTHDELTAMOTIONAPPLIED = 655383, // 0x000A0017
TF_SETTEMPSIGNALCOMPFACTORLUT = 655389, // 0x000A001D
TF_GETTEMPSIGNALCOMPFACTORLUT = 655390, // 0x000A001E
TF_GETRNF = 655391, // 0x000A001F
// Module uart
UART_SETSTARTUPBAUDRATE = 4194304, // 0x00400000
UART_GETSTARTUPBAUDRATE = 4194305, // 0x00400001
};
typedef enum _functionCodes FLR_FUNCTION;
#endif // FUNCTION_CODES_H

View File

@ -0,0 +1,29 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef I2C_CONNECTOR_H
#define I2C_CONNECTOR_H
#include <stdint.h>
#include "ReturnCodes.h"
#include <stdbool.h>
#define I2C_SLAVE_CP_FRAME_HEAD_SIZE 2
#define I2C_SALVE_CP_FRAME_BYTES_NUM_SIZE 2
#define I2C_SLAVE_CP_FRAME_HEADER_SIZE (I2C_SLAVE_CP_FRAME_HEAD_SIZE + I2C_SALVE_CP_FRAME_BYTES_NUM_SIZE)
FLR_RESULT I2C_readFrame(uint8_t* readData, uint32_t* readBytes);
FLR_RESULT I2C_writeFrame(uint8_t* writeData, uint32_t writeBytes);
#endif // I2C_CONNECTOR_H

View File

@ -0,0 +1,35 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef MULTI_SERVICE_SUPPORT_H
#define MULTI_SERVICE_SUPPORT_H
#include <stdio.h>
#include <stdint.h>
#include "ReturnCodes.h"
typedef int32_t svcDataReadyCallback_t(uint32_t receiveBytes, const uint8_t* receiveData);
#define MAX_SERVICES (10)
FLR_RESULT RegisterServiceDataCallback(uint8_t svc, svcDataReadyCallback_t *callback);
/*
* This should be called as ofter as possible, but by one thread only.
* It should also be the only place where the port is ever read.
*/
FLR_RESULT CheckServiceDataReady(void);
#endif // MULTI_SERVICE_SUPPORT_H

View File

@ -0,0 +1,122 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef FLR_RESULT_CODES_H
#define FLR_RESULT_CODES_H
enum _returnCodes {
MAX_ERR_CODE = 0xFFFFFFFF, // 65535
R_SUCCESS = 0U, // 0x00000000
R_UART_UNSPECIFIED_FAILURE = 1U, // 0x00000001
R_UART_PORT_FAILURE = 2U, // 0x00000002
R_UART_RECEIVE_TIMEOUT = 3U, // 0x00000003
R_UART_PORT_ALREADY_OPEN = 4U, // 0x00000004
R_SDK_API_UNSPECIFIED_FAILURE = 272U, // 0x00000110
R_SDK_API_NOT_DEFINED = 273U, // 0x00000111
R_SDK_PKG_UNSPECIFIED_FAILURE = 288U, // 0x00000120
R_SDK_PKG_BUFFER_OVERFLOW = 303U, // 0x0000012F
R_SDK_DSPCH_UNSPECIFIED_FAILURE = 304U, // 0x00000130
R_SDK_DSPCH_SEQUENCE_MISMATCH = 305U, // 0x00000131
R_SDK_DSPCH_ID_MISMATCH = 306U, // 0x00000132
R_SDK_DSPCH_MALFORMED_STATUS = 307U, // 0x00000133
R_SDK_TX_UNSPECIFIED_FAILURE = 320U, // 0x00000140
R_CAM_RX_UNSPECIFIED_FAILURE = 336U, // 0x00000150
R_CAM_DSPCH_UNSPECIFIED_FAILURE = 352U, // 0x00000160
R_CAM_DSPCH_BAD_CMD_ID = 353U, // 0x00000161
R_CAM_DSPCH_BAD_PAYLOAD_STATUS = 354U, // 0x00000162
R_CAM_PKG_UNSPECIFIED_FAILURE = 368U, // 0x00000170
R_CAM_PKG_INSUFFICIENT_BYTES = 381U, // 0x0000017D
R_CAM_PKG_EXCESS_BYTES = 382U, // 0x0000017E
R_CAM_PKG_BUFFER_OVERFLOW = 383U, // 0x0000017F
R_CAM_API_UNSPECIFIED_FAILURE = 384U, // 0x00000180
R_CAM_API_INVALID_INPUT = 385U, // 0x00000181
R_CAM_TX_UNSPECIFIED_FAILURE = 400U, // 0x00000190
R_API_RX_UNSPECIFIED_FAILURE = 416U, // 0x000001A0
R_CAM_FEATURE_NOT_ENABLED = 432U, // 0x000001B0
FLR_OK = 0U, // 0x00000000
FLR_COMM_OK = 0U, // 0x00000000
FLR_ERROR = 513U, // 0x00000201
FLR_NOT_READY = 514U, // 0x00000202
FLR_RANGE_ERROR = 515U, // 0x00000203
FLR_CHECKSUM_ERROR = 516U, // 0x00000204
FLR_BAD_ARG_POINTER_ERROR = 517U, // 0x00000205
FLR_DATA_SIZE_ERROR = 518U, // 0x00000206
FLR_UNDEFINED_FUNCTION_ERROR = 519U, // 0x00000207
FLR_ILLEGAL_ADDRESS_ERROR = 520U, // 0x00000208
FLR_BAD_OUT_TYPE = 521U, // 0x00000209
FLR_BAD_OUT_INTERFACE = 522U, // 0x0000020A
FLR_DEPRECATED_FUNCTION_ERROR = 523U, // 0x0000020B
FLR_COMM_PORT_NOT_OPEN = 613U, // 0x00000265
FLR_COMM_INVALID_PORT_ERROR = 614U, // 0x00000266
FLR_COMM_RANGE_ERROR = 615U, // 0x00000267
FLR_ERROR_CREATING_COMM = 616U, // 0x00000268
FLR_ERROR_STARTING_COMM = 617U, // 0x00000269
FLR_ERROR_CLOSING_COMM = 618U, // 0x0000026A
FLR_COMM_CHECKSUM_ERROR = 619U, // 0x0000026B
FLR_COMM_NO_DEV = 620U, // 0x0000026C
FLR_COMM_TIMEOUT_ERROR = 621U, // 0x0000026D
FLR_COMM_ERROR_WRITING_COMM = 621U, // 0x0000026D
FLR_COMM_ERROR_READING_COMM = 622U, // 0x0000026E
FLR_COMM_COUNT_ERROR = 623U, // 0x0000026F
FLR_OPERATION_CANCELED = 638U, // 0x0000027E
FLR_UNDEFINED_ERROR_CODE = 639U, // 0x0000027F
FLR_LEN_NOT_SUBBLOCK_BOUNDARY = 640U, // 0x00000280
FLR_CONFIG_ERROR = 641U, // 0x00000281
FLR_I2C_ERROR = 642U, // 0x00000282
FLR_CAM_BUSY = 643U, // 0x00000283
FLR_HEATER_ERROR = 644U, // 0x00000284
FLR_WINDOW_ERROR = 645U, // 0x00000285
FLR_VBATT_ERROR = 646U, // 0x00000286
R_SYM_UNSPECIFIED_FAILURE = 768U, // 0x00000300
R_SYM_INVALID_POSITION_ERROR = 769U, // 0x00000301
FLR_RES_NOT_AVAILABLE = 800U, // 0x00000320
FLR_RES_NOT_IMPLEMENTED = 801U, // 0x00000321
FLR_RES_RANGE_ERROR = 802U, // 0x00000322
FLR_SYSTEMINIT_XX_ERROR = 900U, // 0x00000384
FLR_SDIO_XX_ERROR = 1000U, // 0x000003E8
FLR_STOR_SD_XX_ERROR = 1100U, // 0x0000044C
FLR_USB_VIDEO_XX_ERROR = 1200U, // 0x000004B0
FLR_USB_CDC_XX_ERROR = 1300U, // 0x00000514
FLR_USB_MSD_XX_ERROR = 1400U, // 0x00000578
FLR_NET_XX_ERROR = 1500U, // 0x000005DC
FLR_BT_XX_ERROR = 1600U, // 0x00000640
FLR_FLASH_XX_ERROR = 1700U, // 0x000006A4
FLR_FLASH_ERASE_ERROR = 1701U, // 0x000006A5
FLR_FLASH_WRITE_ERROR = 1702U, // 0x000006A6
FLR_FLASH_READ_ERROR = 1703U, // 0x000006A7
FLR_FLASH_BUSY_ERROR = 1704U, // 0x000006A8
FLR_FLASH_ADDRESS_ERROR = 1705U, // 0x000006A9
FLR_FLASH_RANGE_ERROR = 1706U, // 0x000006AA
FLR_FLASH_ACCESS_ERROR = 1707U, // 0x000006AB
FLR_FLASH_OPERATION_RETRY_ERROR = 1708U, // 0x000006AC
FLR_FLASH_UNKNOWN_ERROR = 1709U, // 0x000006AD
FLR_FLASHHDR_ERASED = 1800U, // 0x00000708
FLR_FLASHHDR_PARTIAL_WRITE = 1801U, // 0x00000709
FLR_FLASHHDR_WRONG_FOOTER_ID = 1802U, // 0x0000070A
FLR_FLASHHDR_WRONG_FOOTER_METADATA = 1803U, // 0x0000070B
FLR_FLASHHDR_WRONG_FOOTER_TYPE = 1804U, // 0x0000070C
FLR_FLASHHDR_WRONG_HEADER_SIZE = 1805U, // 0x0000070D
FLR_FLASHHDR_FOOTER_CRC_ERROR = 1806U, // 0x0000070E
FLR_UNKNOWN_PROBE_MODEL = 1900U, // 0x0000076C
};
typedef enum _returnCodes FLR_RESULT;
#endif

View File

@ -0,0 +1,61 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef BOSON_BUILTIN_HANDLERS_H
#define BOSON_BUILTIN_HANDLERS_H
#include <stdint.h>
extern void byteToBOOL(const uint8_t*inBuff, _Bool *outVal);
extern void byteToCHAR(const uint8_t*inBuff, int8_t *outVal);
extern void byteToUCHAR(const uint8_t*inBuff, uint8_t *outVal);
extern void byteToINT_16(const uint8_t*inBuff, int16_t *outVal);
extern void byteToUINT_16(const uint8_t*inBuff, uint16_t *outVal);
extern void byteToINT_32(const uint8_t*inBuff, int32_t *outVal);
extern void byteToUINT_32(const uint8_t*inBuff, uint32_t *outVal);
extern void byteToFLOAT(const uint8_t*inBuff, float *outVal);
extern void byteToDOUBLE(const uint8_t*inBuff, double *outVal);
extern void byteToBOOLArray(const uint8_t*inBuff, _Bool *outVal,uint16_t length);
extern void byteToCHARArray(const uint8_t*inBuff, int8_t *outVal,uint16_t length);
extern void byteToUCHARArray(const uint8_t*inBuff, uint8_t *outVal,uint16_t length);
extern void byteToINT_16Array(const uint8_t*inBuff, int16_t *outVal,uint16_t length);
extern void byteToUINT_16Array(const uint8_t*inBuff, uint16_t *outVal,uint16_t length);
extern void byteToINT_32Array(const uint8_t*inBuff, int32_t *outVal,uint16_t length);
extern void byteToUINT_32Array(const uint8_t*inBuff, uint32_t *outVal,uint16_t length);
extern void byteToFLOATArray(const uint8_t*inBuff, float *outVal,uint16_t length);
extern void byteToDOUBLEArray(const uint8_t*inBuff, double *outVal,uint16_t length);
extern void BOOLToByte(const _Bool inVal, const uint8_t *outBuff);
extern void CHARToByte(const int8_t inVal, const uint8_t *outBuff );
extern void UCHARToByte(const uint8_t inVal, const uint8_t *outBuff);
extern void INT_16ToByte(const int16_t inVal, const uint8_t *outBuff);
extern void UINT_16ToByte(const uint16_t inVal, const uint8_t *outBuff);
extern void INT_32ToByte(const int32_t inVal, const uint8_t *outBuff);
extern void UINT_32ToByte(const uint32_t inVal, const uint8_t *outBuff);
extern void FLOATToByte(const float inVal, const uint8_t *outBuff);
extern void DOUBLEToByte(const double inVal, const uint8_t *outBuff);
extern void BOOLArrayToByte(const _Bool *inVal, uint16_t length, const uint8_t *outBuff);
extern void CHARArrayToByte(const int8_t *inVal, uint16_t length, const uint8_t *outBuff );
extern void UCHARArrayToByte(const uint8_t *inVal, uint16_t length, const uint8_t *outBuff);
extern void INT_16ArrayToByte(const int16_t *inVal, uint16_t length, const uint8_t *outBuff);
extern void UINT_16ArrayToByte(const uint16_t *inVal, uint16_t length, const uint8_t *outBuff);
extern void INT_32ArrayToByte(const int32_t *inVal, uint16_t length, const uint8_t *outBuff);
extern void UINT_32ArrayToByte(const uint32_t *inVal, uint16_t length, const uint8_t *outBuff);
extern void FLOATArrayToByte(const float *inVal, uint16_t length, const uint8_t *outBuff);
extern void DOUBLEArrayToByte(const double *inVal, uint16_t length, const uint8_t *outBuff);
#endif //BOSON_BUILTIN_HANDLERS_H

View File

@ -0,0 +1,462 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef SERIALIZER_STRUCT_H
#define SERIALIZER_STRUCT_H
#include <stdint.h>
#include "EnumTypes.h"
#include "Serializer_BuiltIn.h"
struct t_FLR_ROI_T {
uint16_t rowStart;
uint16_t rowStop;
uint16_t colStart;
uint16_t colStop;
};
typedef struct t_FLR_ROI_T FLR_ROI_T;
void byteToFLR_ROI_T(const uint8_t *inBuff, FLR_ROI_T *outVal);
void FLR_ROI_TToByte(const FLR_ROI_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_PARTNUMBER_T {
uint8_t value[20];
};
typedef struct t_FLR_BOSON_PARTNUMBER_T FLR_BOSON_PARTNUMBER_T;
void byteToFLR_BOSON_PARTNUMBER_T(const uint8_t *inBuff, FLR_BOSON_PARTNUMBER_T *outVal);
void FLR_BOSON_PARTNUMBER_TToByte(const FLR_BOSON_PARTNUMBER_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_SENSOR_PARTNUMBER_T {
uint8_t value[32];
};
typedef struct t_FLR_BOSON_SENSOR_PARTNUMBER_T FLR_BOSON_SENSOR_PARTNUMBER_T;
void byteToFLR_BOSON_SENSOR_PARTNUMBER_T(const uint8_t *inBuff, FLR_BOSON_SENSOR_PARTNUMBER_T *outVal);
void FLR_BOSON_SENSOR_PARTNUMBER_TToByte(const FLR_BOSON_SENSOR_PARTNUMBER_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_GAIN_SWITCH_PARAMS_T {
uint32_t pHighToLowPercent;
uint32_t cHighToLowPercent;
uint32_t pLowToHighPercent;
uint32_t hysteresisPercent;
};
typedef struct t_FLR_BOSON_GAIN_SWITCH_PARAMS_T FLR_BOSON_GAIN_SWITCH_PARAMS_T;
void byteToFLR_BOSON_GAIN_SWITCH_PARAMS_T(const uint8_t *inBuff, FLR_BOSON_GAIN_SWITCH_PARAMS_T *outVal);
void FLR_BOSON_GAIN_SWITCH_PARAMS_TToByte(const FLR_BOSON_GAIN_SWITCH_PARAMS_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T {
uint32_t pHighToLowPercent;
float TempHighToLowDegK;
uint32_t pLowToHighPercent;
float TempLowToHighDegK;
};
typedef struct t_FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T;
void byteToFLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T(const uint8_t *inBuff, FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *outVal);
void FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_TToByte(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_SATURATION_LUT_T {
uint16_t value[17];
};
typedef struct t_FLR_BOSON_SATURATION_LUT_T FLR_BOSON_SATURATION_LUT_T;
void byteToFLR_BOSON_SATURATION_LUT_T(const uint8_t *inBuff, FLR_BOSON_SATURATION_LUT_T *outVal);
void FLR_BOSON_SATURATION_LUT_TToByte(const FLR_BOSON_SATURATION_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_BOSON_SATURATION_HEADER_LUT_T {
FLR_BOSON_SATURATION_LUT_T lut;
uint16_t tableIndex;
};
typedef struct t_FLR_BOSON_SATURATION_HEADER_LUT_T FLR_BOSON_SATURATION_HEADER_LUT_T;
void byteToFLR_BOSON_SATURATION_HEADER_LUT_T(const uint8_t *inBuff, FLR_BOSON_SATURATION_HEADER_LUT_T *outVal);
void FLR_BOSON_SATURATION_HEADER_LUT_TToByte(const FLR_BOSON_SATURATION_HEADER_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_CAPTURE_SETTINGS_T {
FLR_CAPTURE_SRC_E dataSrc;
uint32_t numFrames;
uint16_t bufferIndex;
};
typedef struct t_FLR_CAPTURE_SETTINGS_T FLR_CAPTURE_SETTINGS_T;
void byteToFLR_CAPTURE_SETTINGS_T(const uint8_t *inBuff, FLR_CAPTURE_SETTINGS_T *outVal);
void FLR_CAPTURE_SETTINGS_TToByte(const FLR_CAPTURE_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_CAPTURE_FILE_SETTINGS_T {
FLR_CAPTURE_FILE_TYPE_E captureFileType;
uint8_t filePath[128];
};
typedef struct t_FLR_CAPTURE_FILE_SETTINGS_T FLR_CAPTURE_FILE_SETTINGS_T;
void byteToFLR_CAPTURE_FILE_SETTINGS_T(const uint8_t *inBuff, FLR_CAPTURE_FILE_SETTINGS_T *outVal);
void FLR_CAPTURE_FILE_SETTINGS_TToByte(const FLR_CAPTURE_FILE_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_CAPTURE_STATUS_T {
FLR_CAPTURE_STATE_E state;
uint32_t result;
uint32_t capturedFrames;
uint32_t missedFrames;
uint32_t savedFrames;
uint32_t unsyncFrames;
};
typedef struct t_FLR_CAPTURE_STATUS_T FLR_CAPTURE_STATUS_T;
void byteToFLR_CAPTURE_STATUS_T(const uint8_t *inBuff, FLR_CAPTURE_STATUS_T *outVal);
void FLR_CAPTURE_STATUS_TToByte(const FLR_CAPTURE_STATUS_T *inVal, const uint8_t *outBuff);
struct t_FLR_DVO_YCBCR_SETTINGS_T {
FLR_DVO_OUTPUT_YCBCR_FORMAT_E ycbcrFormat;
FLR_DVO_OUTPUT_CBCR_ORDER_E cbcrOrder;
FLR_DVO_OUTPUT_Y_ORDER_E yOrder;
};
typedef struct t_FLR_DVO_YCBCR_SETTINGS_T FLR_DVO_YCBCR_SETTINGS_T;
void byteToFLR_DVO_YCBCR_SETTINGS_T(const uint8_t *inBuff, FLR_DVO_YCBCR_SETTINGS_T *outVal);
void FLR_DVO_YCBCR_SETTINGS_TToByte(const FLR_DVO_YCBCR_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_DVO_RGB_SETTINGS_T {
FLR_DVO_OUTPUT_RGB_FORMAT_E rgbFormat;
FLR_DVO_OUTPUT_RGB_ORDER_E rgbOrder;
};
typedef struct t_FLR_DVO_RGB_SETTINGS_T FLR_DVO_RGB_SETTINGS_T;
void byteToFLR_DVO_RGB_SETTINGS_T(const uint8_t *inBuff, FLR_DVO_RGB_SETTINGS_T *outVal);
void FLR_DVO_RGB_SETTINGS_TToByte(const FLR_DVO_RGB_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_DVO_LCD_CONFIG_T {
uint32_t width;
uint32_t hPulseWidth;
uint32_t hBackP;
uint32_t hFrontP;
uint32_t height;
uint32_t vPulseWidth;
uint32_t vBackP;
uint32_t vFrontP;
uint32_t outputFormat;
uint32_t control;
uint32_t rotation;
uint32_t pixelClockkHz;
};
typedef struct t_FLR_DVO_LCD_CONFIG_T FLR_DVO_LCD_CONFIG_T;
void byteToFLR_DVO_LCD_CONFIG_T(const uint8_t *inBuff, FLR_DVO_LCD_CONFIG_T *outVal);
void FLR_DVO_LCD_CONFIG_TToByte(const FLR_DVO_LCD_CONFIG_T *inVal, const uint8_t *outBuff);
struct t_FLR_GAO_RNS_COL_CORRECT_T {
int16_t value[20];
};
typedef struct t_FLR_GAO_RNS_COL_CORRECT_T FLR_GAO_RNS_COL_CORRECT_T;
void byteToFLR_GAO_RNS_COL_CORRECT_T(const uint8_t *inBuff, FLR_GAO_RNS_COL_CORRECT_T *outVal);
void FLR_GAO_RNS_COL_CORRECT_TToByte(const FLR_GAO_RNS_COL_CORRECT_T *inVal, const uint8_t *outBuff);
struct t_FLR_ISOTHERM_COLOR_T {
uint16_t r;
uint16_t g;
uint16_t b;
};
typedef struct t_FLR_ISOTHERM_COLOR_T FLR_ISOTHERM_COLOR_T;
void byteToFLR_ISOTHERM_COLOR_T(const uint8_t *inBuff, FLR_ISOTHERM_COLOR_T *outVal);
void FLR_ISOTHERM_COLOR_TToByte(const FLR_ISOTHERM_COLOR_T *inVal, const uint8_t *outBuff);
struct t_FLR_ISOTHERM_COLORS_T {
FLR_ISOTHERM_COLOR_T range1;
FLR_ISOTHERM_COLOR_T range2;
FLR_ISOTHERM_COLOR_T range3;
uint16_t num;
};
typedef struct t_FLR_ISOTHERM_COLORS_T FLR_ISOTHERM_COLORS_T;
void byteToFLR_ISOTHERM_COLORS_T(const uint8_t *inBuff, FLR_ISOTHERM_COLORS_T *outVal);
void FLR_ISOTHERM_COLORS_TToByte(const FLR_ISOTHERM_COLORS_T *inVal, const uint8_t *outBuff);
struct t_FLR_ISOTHERM_SETTINGS_T {
int32_t thIsoT1;
int32_t thIsoT2;
int32_t thIsoT3;
int32_t thIsoT4;
int32_t thIsoT5;
FLR_ISOTHERM_COLORS_T color0;
FLR_ISOTHERM_COLORS_T color1;
FLR_ISOTHERM_COLORS_T color2;
FLR_ISOTHERM_COLORS_T color3;
FLR_ISOTHERM_COLORS_T color4;
FLR_ISOTHERM_COLORS_T color5;
FLR_ISOTHERM_REGION_E region0;
FLR_ISOTHERM_REGION_E region1;
FLR_ISOTHERM_REGION_E region2;
FLR_ISOTHERM_REGION_E region3;
FLR_ISOTHERM_REGION_E region4;
FLR_ISOTHERM_REGION_E region5;
};
typedef struct t_FLR_ISOTHERM_SETTINGS_T FLR_ISOTHERM_SETTINGS_T;
void byteToFLR_ISOTHERM_SETTINGS_T(const uint8_t *inBuff, FLR_ISOTHERM_SETTINGS_T *outVal);
void FLR_ISOTHERM_SETTINGS_TToByte(const FLR_ISOTHERM_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T {
uint16_t value[17];
};
typedef struct t_FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T;
void byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *outVal);
void FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T {
uint16_t value[17];
};
typedef struct t_FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T;
void byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *outVal);
void FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T {
FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T lut;
uint16_t tableIndex;
};
typedef struct t_FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T;
void byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T *outVal);
void FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_TToByte(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T {
FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T lut;
uint16_t tableIndex;
};
typedef struct t_FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T;
void byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T *outVal);
void FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_TToByte(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_RBFO_PARAMS_T {
float RBFO_R;
float RBFO_B;
float RBFO_F;
float RBFO_O;
};
typedef struct t_FLR_RADIOMETRY_RBFO_PARAMS_T FLR_RADIOMETRY_RBFO_PARAMS_T;
void byteToFLR_RADIOMETRY_RBFO_PARAMS_T(const uint8_t *inBuff, FLR_RADIOMETRY_RBFO_PARAMS_T *outVal);
void FLR_RADIOMETRY_RBFO_PARAMS_TToByte(const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal, const uint8_t *outBuff);
struct t_FLR_RADIOMETRY_TAUX_PARAMS_T {
float A3;
float A2;
float A1;
float A0;
};
typedef struct t_FLR_RADIOMETRY_TAUX_PARAMS_T FLR_RADIOMETRY_TAUX_PARAMS_T;
void byteToFLR_RADIOMETRY_TAUX_PARAMS_T(const uint8_t *inBuff, FLR_RADIOMETRY_TAUX_PARAMS_T *outVal);
void FLR_RADIOMETRY_TAUX_PARAMS_TToByte(const FLR_RADIOMETRY_TAUX_PARAMS_T *inVal, const uint8_t *outBuff);
struct t_FLR_ROIC_FPATEMP_TABLE_T {
int16_t value[32];
};
typedef struct t_FLR_ROIC_FPATEMP_TABLE_T FLR_ROIC_FPATEMP_TABLE_T;
void byteToFLR_ROIC_FPATEMP_TABLE_T(const uint8_t *inBuff, FLR_ROIC_FPATEMP_TABLE_T *outVal);
void FLR_ROIC_FPATEMP_TABLE_TToByte(const FLR_ROIC_FPATEMP_TABLE_T *inVal, const uint8_t *outBuff);
struct t_FLR_SCALER_ZOOM_PARAMS_T {
uint32_t zoom;
uint32_t xCenter;
uint32_t yCenter;
};
typedef struct t_FLR_SCALER_ZOOM_PARAMS_T FLR_SCALER_ZOOM_PARAMS_T;
void byteToFLR_SCALER_ZOOM_PARAMS_T(const uint8_t *inBuff, FLR_SCALER_ZOOM_PARAMS_T *outVal);
void FLR_SCALER_ZOOM_PARAMS_TToByte(const FLR_SCALER_ZOOM_PARAMS_T *inVal, const uint8_t *outBuff);
struct t_FLR_SPNR_PSD_KERNEL_T {
float fvalue[64];
};
typedef struct t_FLR_SPNR_PSD_KERNEL_T FLR_SPNR_PSD_KERNEL_T;
void byteToFLR_SPNR_PSD_KERNEL_T(const uint8_t *inBuff, FLR_SPNR_PSD_KERNEL_T *outVal);
void FLR_SPNR_PSD_KERNEL_TToByte(const FLR_SPNR_PSD_KERNEL_T *inVal, const uint8_t *outBuff);
struct t_FLR_SPOTMETER_SPOT_PARAM_T {
uint16_t row;
uint16_t column;
uint16_t value;
};
typedef struct t_FLR_SPOTMETER_SPOT_PARAM_T FLR_SPOTMETER_SPOT_PARAM_T;
void byteToFLR_SPOTMETER_SPOT_PARAM_T(const uint8_t *inBuff, FLR_SPOTMETER_SPOT_PARAM_T *outVal);
void FLR_SPOTMETER_SPOT_PARAM_TToByte(const FLR_SPOTMETER_SPOT_PARAM_T *inVal, const uint8_t *outBuff);
struct t_FLR_SPOTMETER_STAT_PARAM_TEMP_T {
uint16_t row;
uint16_t column;
float value;
};
typedef struct t_FLR_SPOTMETER_STAT_PARAM_TEMP_T FLR_SPOTMETER_STAT_PARAM_TEMP_T;
void byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T(const uint8_t *inBuff, FLR_SPOTMETER_STAT_PARAM_TEMP_T *outVal);
void FLR_SPOTMETER_STAT_PARAM_TEMP_TToByte(const FLR_SPOTMETER_STAT_PARAM_TEMP_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSINFO_MONITOR_BUILD_VARIANT_T {
uint8_t value[50];
};
typedef struct t_FLR_SYSINFO_MONITOR_BUILD_VARIANT_T FLR_SYSINFO_MONITOR_BUILD_VARIANT_T;
void byteToFLR_SYSINFO_MONITOR_BUILD_VARIANT_T(const uint8_t *inBuff, FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *outVal);
void FLR_SYSINFO_MONITOR_BUILD_VARIANT_TToByte(const FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSINFO_PROBE_TIP_TYPE {
FLR_SYSINFO_PROBE_TIP_MODEL_E model;
uint8_t hwRevision;
};
typedef struct t_FLR_SYSINFO_PROBE_TIP_TYPE FLR_SYSINFO_PROBE_TIP_TYPE;
void byteToFLR_SYSINFO_PROBE_TIP_TYPE(const uint8_t *inBuff, FLR_SYSINFO_PROBE_TIP_TYPE *outVal);
void FLR_SYSINFO_PROBE_TIP_TYPEToByte(const FLR_SYSINFO_PROBE_TIP_TYPE *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T {
uint8_t id;
int16_t x;
int16_t y;
int16_t width;
int16_t height;
uint32_t color;
int16_t size;
};
typedef struct t_FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T;
void byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T *outVal);
void FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(const FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_SPOTCONFIG_T {
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T symbol;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T area;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T min;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T max;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T mean;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T meanBar;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarOutline;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBar;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarText1;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarText2;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarText3;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarText4;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T greenBarText5;
};
typedef struct t_FLR_SYSTEMSYMBOLS_SPOTCONFIG_T FLR_SYSTEMSYMBOLS_SPOTCONFIG_T;
void byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *outVal);
void FLR_SYSTEMSYMBOLS_SPOTCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T {
uint8_t symbol;
uint8_t area;
uint8_t min;
uint8_t max;
uint8_t mean;
uint8_t meanBar;
uint8_t greenBarOutline;
uint8_t greenBar;
uint8_t greenBarText1;
uint8_t greenBarText2;
uint8_t greenBarText3;
uint8_t greenBarText4;
uint8_t greenBarText5;
};
typedef struct t_FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T;
void byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *outVal);
void FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_TToByte(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_ISOCONFIG_T {
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T colorBar;
FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T colorBarOutline;
};
typedef struct t_FLR_SYSTEMSYMBOLS_ISOCONFIG_T FLR_SYSTEMSYMBOLS_ISOCONFIG_T;
void byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_ISOCONFIG_T *outVal);
void FLR_SYSTEMSYMBOLS_ISOCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T {
uint8_t colorBar;
uint8_t colorBarOutline;
};
typedef struct t_FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T;
void byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *outVal);
void FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_TToByte(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *inVal, const uint8_t *outBuff);
struct t_FLR_SYSTEMSYMBOLS_BARCONFIG_T {
int16_t val0;
int16_t val1;
int16_t val2;
int16_t val3;
int16_t val4;
};
typedef struct t_FLR_SYSTEMSYMBOLS_BARCONFIG_T FLR_SYSTEMSYMBOLS_BARCONFIG_T;
void byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_BARCONFIG_T *outVal);
void FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal, const uint8_t *outBuff);
struct t_FLR_TESTRAMP_SETTINGS_T {
uint16_t start;
uint16_t end;
uint16_t increment;
};
typedef struct t_FLR_TESTRAMP_SETTINGS_T FLR_TESTRAMP_SETTINGS_T;
void byteToFLR_TESTRAMP_SETTINGS_T(const uint8_t *inBuff, FLR_TESTRAMP_SETTINGS_T *outVal);
void FLR_TESTRAMP_SETTINGS_TToByte(const FLR_TESTRAMP_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_TESTRAMP_ANIMATION_SETTINGS_T {
int16_t moveLines;
uint16_t moveFrames;
};
typedef struct t_FLR_TESTRAMP_ANIMATION_SETTINGS_T FLR_TESTRAMP_ANIMATION_SETTINGS_T;
void byteToFLR_TESTRAMP_ANIMATION_SETTINGS_T(const uint8_t *inBuff, FLR_TESTRAMP_ANIMATION_SETTINGS_T *outVal);
void FLR_TESTRAMP_ANIMATION_SETTINGS_TToByte(const FLR_TESTRAMP_ANIMATION_SETTINGS_T *inVal, const uint8_t *outBuff);
struct t_FLR_TF_WLUT_T {
uint8_t value[32];
};
typedef struct t_FLR_TF_WLUT_T FLR_TF_WLUT_T;
void byteToFLR_TF_WLUT_T(const uint8_t *inBuff, FLR_TF_WLUT_T *outVal);
void FLR_TF_WLUT_TToByte(const FLR_TF_WLUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_TF_NF_LUT_T {
uint16_t value[17];
};
typedef struct t_FLR_TF_NF_LUT_T FLR_TF_NF_LUT_T;
void byteToFLR_TF_NF_LUT_T(const uint8_t *inBuff, FLR_TF_NF_LUT_T *outVal);
void FLR_TF_NF_LUT_TToByte(const FLR_TF_NF_LUT_T *inVal, const uint8_t *outBuff);
struct t_FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T {
uint16_t value[17];
};
typedef struct t_FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T;
void byteToFLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *outVal);
void FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_TToByte(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff);
#endif //SERIALIZER_STRUCT_H

View File

@ -0,0 +1,29 @@
/******************************************************************************/
/* */
/* Copyright (C) 2015, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef UART_CONNECTOR_H
#define UART_CONNECTOR_H
#include <stdint.h>
#include "ReturnCodes.h"
void ReadTimeoutSet(unsigned int timeout);
void SendToCamera( uint8_t channelID, uint32_t sendBytes, uint8_t *sendData);
void ReadFrame( uint8_t channelID, uint32_t *receiveBytes, uint8_t *receiveData);
void ReadUnframed(uint32_t *receiveBytes, uint8_t *receiveData);
FLR_RESULT Initialize();
void Close();
int32_t CheckDataReady(uint8_t *channel_ID, uint32_t *receiveBytes, const uint8_t **receiveData);
#endif //UART_CONNECTOR_H

View File

@ -0,0 +1,39 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef UPT_CLIENT_H
#define UPT_CLIENT_H
#include <stdio.h>
#include <stdint.h>
#include "ReturnCodes.h"
enum _uptRecipient {
UPT_USB_HOST = (int32_t) 0,
UPT_UART_HOST = (int32_t) 1,
UPT_HOST_COUNT,
};
typedef enum _uptRecipient UPT_RECIPIENT;
#define MAX_PAYLOAD_BYTES (768 - 1)
FLR_RESULT passToRecipient(UPT_RECIPIENT recipient, const uint8_t *data, uint32_t length);
FLR_RESULT getMyData(uint8_t *data, uint32_t *length);
#endif // UPT_CLIENT_H

View File

@ -0,0 +1,164 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
/**
* @file dataServiceClient.h
* @author Artur Tynecki
* @date April, 2017
* @brief Data Service Client header file
*
* Includes function used to send with confirmation data packets.
* Communcation base on HostBinaryProtocol module. Confirmation base on send ACK
* and control packet counter.
* Implementation:
* 1. call dataServiceClientInit() function during system initialization
* 2. register receive data callback by dataServiceClientRegisterCallback() function
* 3. register receive HostBinaryProtcol callback by set dataServiceClientReceive()
* function as an argument in RegisterServiceDataCallback() call
* 3. send your data by dataServiceClientSend() function
* 4. on data receive: callback function with number of receive bytes
* will be called. Read receive data buffer by dataServiceClientRead() function
* 5. reset communication by call dataServiceClientReset()
*/
#ifndef _DATA_SERVICE_H
#define _DATA_SERVICE_H
/******************************************************************************/
/** INCLUDE FILES **/
/******************************************************************************/
#include <stdint.h>
#include "ReturnCodes.h"
/******************************************************************************/
/** EXPORTED DEFINES **/
/******************************************************************************/
#define DATA_SERVICE_NUMBER 1
#define MAX_PAYLOAD_BYTES 768
#define CMD_MASK 0xC0
#define COUNTER_MASK 0x3F
#define MAX_COUNTER_VALUE 0x3FFF
#define DATA_SEND_TIMEOUT_MS 3000
#define DATA_BUFFER_SIZE UINT16_MAX
/******************************************************************************/
/** EXPORTED TYPE DEFINITIONS **/
/******************************************************************************/
/**
* @brief definition of callback function type
* @param [in] number of received bytes
*/
typedef void (*receive_callback) (uint32_t);
/**
* @brief Frame command definition
*/
typedef enum {
DATA_SEND = (uint8_t) 0, ///< send data
DATA_ACK = (uint8_t) 1, ///< send ACK response
COMMUNICATION_RESET = (uint8_t) 2, ///< reset communication
COMMUNICATION_RESET_ACK = (uint8_t) 3
}dataServiceFrameCommand_t;
/**
* @brief Controller state definition
*/
typedef enum {
CONTROLLER_READY = (uint8_t) 0, ///< controller is ready for action
CONTROLLER_ACK_WAIT = (uint8_t) 1 ///< controller is busy
}dataServiceControllerState_t;
/**
* @brief Data Service Client controller structure
*/
typedef struct {
uint16_t send_counter; ///< Send data counter
uint16_t receive_counter; ///< Received data counter
dataServiceControllerState_t state; /**< Controller state */
receive_callback callback; /**< Received data callback */
} dataServiceController_t, *dataServiceController_p;
/**
* @brief Data Service Client frame structure
*/
typedef struct {
dataServiceFrameCommand_t cmd; /**< Command code */
uint16_t counter; /**< Frame counter */
uint8_t buffer[MAX_PAYLOAD_BYTES]; /**< Frame buffer */
uint32_t size; /**< Frame buffer size */
} dataServiceFrame_t, *dataServiceFrame_p;
/******************************************************************************/
/** EXPORTED PUBLIC FUNCTIONS **/
/******************************************************************************/
/**
* @brief Initialization Data Service Client
* Initalization service controller and receive data buffer
* @return FLR_OK if successful else return error
*/
FLR_RESULT dataServiceClientInit(void);
/**
* @brief Register receive data callback
* Add callback that is called when new data receive on Data Service
* @param [in] callback - callback function definition
* @return FLR_OK if successful else return error
*/
FLR_RESULT dataServiceClientRegisterCallback(receive_callback callback);
/**
* @brief Data send
* @param [in] data - send data buffer
* @param [in] data_len - send data size in bytes
* @param [out] data_len_out - pointer to number of bytes which are properly sent
* @return FLR_OK if successful else return error
*/
FLR_RESULT dataServiceClientSend(uint8_t* data, uint32_t data_len, uint32_t* data_len_out);
/**
* @brief Data read
* @param [out] data - read data buffer
* @param [in] data_len - number of bytes to read
* @param [out] data_len_out - pointer to number of bytes which are properly read
* @return FLR_OK if successful else return error
*/
FLR_RESULT dataServiceClientRead(uint8_t* data, uint32_t data_len, uint32_t* data_len_out);
/**
* @brief Reset Data Service communication
* Send reset command and reset controller parameters after ACK received
* @return FLR_OK if successful else return error
*/
FLR_RESULT dataServiceClientReset(void);
/**
* @brief Receive data HostBinaryProtocol callback
* Callback that is called from BinaryProtcol module
* when new data receive on Data Service Client
* Add by set as an argument in RegisterServiceDataCallback() call
* @param [in] receiveBytes - number of receive bytes
* @param [in] receiveData - pointer to data buffer
* @return 0 if successful else return -1
*/
int32_t dataServiceClientReceive(uint32_t receiveBytes, const uint8_t* receiveData);
#endif // _DATA_SERVICE_H

View File

@ -0,0 +1,95 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
/**
* @file fifo.h
* @author Artur Tynecki
* @date May, 2017
* @brief FIFO implementation header file
*
* Simple FIFO implementation with the ability to create a buffer of any size
* and thread safe operation on it.
*/
#ifndef _FIFO_H_
#define _FIFO_H_
/******************************************************************************/
/** INCLUDE FILES **/
/******************************************************************************/
#include <stdint.h>
#include "ReturnCodes.h"
/******************************************************************************/
/** EXPORTED TYPE DEFINITIONS **/
/******************************************************************************/
/**
* @brief FIFO data structure
*/
typedef struct {
uint32_t head; /**< Buffer head index */
uint32_t tail; /**< Buffer tail index */
uint32_t size; /**< Buffer size */
uint32_t length; /**< Buffer data length */
uint8_t *buffer; /**< Data buffer */
} fifo_t, *fifo_p;
/******************************************************************************/
/** EXPORTED PUBLIC FUNCTIONS **/
/******************************************************************************/
/**
* @brief FIFO Create
* Initialization FIFO structure, allocate memeory, set default parameters value
* @param [in] size - FIFO buffer size
* @return pointer to initialized fifo structure
*/
fifo_p fifoCreate(uint32_t size);
/**
* @brief FIFO Destroy
* Deinitialization FIFO structure, free memeory
* @param [in] fifo - pointer to fifo structure
* @return none
*/
void fifoDestroy(fifo_p fifo);
/**
* @brief Write data to FIFO
* Write data to FIFO buffer, thread safe
* @param [out] fifo - pointer to fifo structure
* @param [in] data - write data pointer
* @param [in] data_len - write data size in bytes
* @param [out] data_len_out - pointer to number of bytes which are properly write
* @return FLR_OK if successful else return error
*/
FLR_RESULT fifoWrite(fifo_p fifo, uint8_t* data, uint32_t data_len, uint32_t* data_len_out);
/**
* @brief Read data from fifo
* Read data from FIFO buffer, thread safe
* @param [out] fifo - pointer to fifo structure
* @param [in] data - read data pointer
* @param [in] data_len - read data size in bytes
* @param [out] data_len_out - pointer to number of bytes which are properly read
* @return FLR_OK if successful else return error
*/
FLR_RESULT fifoRead(fifo_p fifo, uint8_t* data, uint32_t data_len, uint32_t* data_len_out);
#endif // _FIFO_H_

View File

@ -0,0 +1,25 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef _FLIR_CRC_H_
#define _FLIR_CRC_H_
#include <stdint.h>
#define FLIR_CRC_INITIAL_VALUE (0x1D0F)
uint16_t calcFlirCRC16Words(unsigned int count, short *buffer);
uint16_t calcFlirCRC16Bytes(unsigned int count, uint8_t *buffer);
int calcFlirByteCRC16(int value, int crcin);
#endif // _FLIR_CRC_H_

View File

@ -0,0 +1,84 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef FLIR_CHANNELS_H
#define FLIR_CHANNELS_H
#include <stdint.h>
#define CHANNEL_BUF_SIZ 1
#define SERVICE_UNRELATED_CHANNEL_ID (0xff)
struct t_CHANNEL_T {
uint8_t channel;
uint16_t start;
uint16_t len;
uint8_t buff[CHANNEL_BUF_SIZ];
};
typedef struct t_CHANNEL_T CHANNEL_T;
#define CHANNEL_INIT(_channel_list_index, _channel_id) \
do { \
chan_ptr = &(channel_list[_channel_list_index]); \
chan_ptr->channel = (_channel_id); \
chan_ptr->len = 0; \
chan_ptr->start = 0; \
} while (0)
#define NUM_CHANNELS 7
static CHANNEL_T *chan_ptr;
static CHANNEL_T *unframed_ptr;
static CHANNEL_T channel_list[NUM_CHANNELS];
extern void initialize_channels();
extern int32_t get_channel(uint8_t channel_ID, CHANNEL_T **return_channel);
extern void get_unframed(CHANNEL_T **return_channel);
extern void add_byte(uint8_t inbyte,CHANNEL_T *channel_ptr);
extern int32_t get_byte(uint8_t *outbyte,CHANNEL_T *channel_ptr);
/* Maybe later if number of channels becomes large.
int16_t channel_nums[256] = {
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x00->0x09
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x0A->0x13
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x14->0x1D
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x1E->0x27
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x28->0x31
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x32->0x3B
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x3C->0x45
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x46->0x4F
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x50->0x59
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x5A->0x63
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x64->0x6D
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x6E->0x77
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x78->0x81
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x82->0x8B
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x8C->0x95
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0x96->0x9F
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xA0->0xA9
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xAA->0xB3
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xB4->0xBD
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xBE->0xC7
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xC8->0xD1
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xD2->0xDB
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xDC->0xE5
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xE6->0xEF
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, //0xF0->0xF9
-1,-1,-1,-1,-1,-1, //0xFA->0xFF
}
*/
#endif //FLIR_CHANNELS_H

View File

@ -0,0 +1,78 @@
/*
* Copyright (C) 2023-2024 OpenMV, LLC.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Any redistribution, use, or modification in source or binary form
* is done solely for personal benefit and not for any commercial
* purpose or for monetary gain. For commercial licensing options,
* please contact openmv@openmv.io
*
* THIS SOFTWARE IS PROVIDED BY THE LICENSOR AND COPYRIGHT OWNER "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR OR COPYRIGHT
* OWNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* I2C to UART bridge register definitions.
*/
#define SC16IS741A_SUB_ADDR(reg, channel) (((reg) << 3) | ((channel) << 1))
#define SC16IS741A_REG_RHR 0x00
#define SC16IS741A_REG_THR 0x00
#define SC16IS741A_REG_IER 0x01
#define SC16IS741A_REG_FCR 0x02
#define SC16IS741A_REG_IIR 0x02
#define SC16IS741A_REG_LCR 0x03
#define SC16IS741A_REG_MCR 0x04
#define SC16IS741A_REG_LSR 0x05
#define SC16IS741A_REG_MSR 0x06
#define SC16IS741A_REG_SPR 0x07
#define SC16IS741A_REG_TCR 0x06
#define SC16IS741A_REG_TLR 0x07
#define SC16IS741A_REG_TXLVL 0x08
#define SC16IS741A_REG_RXLVL 0x09
#define SC16IS741A_REG_UARTRST 0x0e
#define SC16IS741A_REG_EFCR 0x0f
#define SC16IS741A_REG_DLL 0x00
#define SC16IS741A_REG_DLH 0x01
#define SC16IS741A_REG_EFR 0x02
#define SC16IS741A_REG_XON1 0x04
#define SC16IS741A_REG_XON2 0x05
#define SC16IS741A_REG_XOFF1 0x06
#define SC16IS741A_REG_XOFF2 0x07
#define SC16IS741A_FCR_ENABLE_FIFO 0x01
#define SC16IS741A_FCR_RX_FIFO_RESET 0x02
#define SC16IS741A_FCR_TX_FIFO_RESET 0x04
#define SC16IS741A_LCR_WORD_SZ_5 0x00
#define SC16IS741A_LCR_WORD_SZ_6 0x01
#define SC16IS741A_LCR_WORD_SZ_7 0x02
#define SC16IS741A_LCR_WORD_SZ_8 0x03
#define SC16IS741A_LCR_STOP_BIT 0x04
#define SC16IS741A_LCR_PARITY_EN 0x08
#define SC16IS741A_LCR_PARITY_EVEN 0x10
#define SC16IS741A_LCR_PARITY_ODD 0x00
#define SC16IS741A_LCR_PARITY_FORCE 0x20
#define SC16IS741A_LCR_PARTIY_FORCE_1 0x00
#define SC16IS741A_LCR_PARTIY_FORCE_0 0x10
#define SC16IS741A_LCR_BREAK_EN 0x40
#define SC16IS741A_LCR_ENABLE_LATCH 0x80
#define SC16IS741A_UARTRST 0x08

View File

@ -0,0 +1,39 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef _SERIALPORT_ADAPTER_H
#define _SERIALPORT_ADAPTER_H
#include <stdlib.h>
#include <stdint.h>
// open port by id, using specified baud_rate.
// passes library errors up, 0 on success.
uint8_t FSLP_open_port();
// close port via id
void FSLP_close_port();
// read single byte with timeout.
// -1 on timeout, 0-255 for valid byte value
int16_t FSLP_read_byte_with_timeout(double timeout);
// flush tx buffer
void FSLP_flush_write_queue();
// write buffer of bytes
// return number of bytes written
int32_t FSLP_write_buffer(uint8_t *frame_buf, int32_t len);
#endif //_SERIALPORT_ADAPTER_H

View File

@ -0,0 +1,25 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#ifndef _TIMEOUT_LOGIC_H
#define _TIMEOUT_LOGIC_H
#define CLOCK_MONOTONIC 0
struct timespec { long tv_sec; long tv_nsec; };
int clock_gettime(int _ignore, struct timespec *spec);
double difftime(long current, long reference);
double diff_timespec(struct timespec *current, struct timespec *reference);
#endif //_TIMEOUT_LOGIC_H

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,160 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "Client_Dispatcher.h"
// Asynchronous (MultiService compatible) transmit part
FLR_RESULT CLIENT_dispatcher_Tx(uint32_t seqNum, FLR_FUNCTION fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes) {
uint32_t i;
// Allocated buffer with extra space for payload header
uint8_t sendPayload[530];
uint8_t *pyldPtr = (uint8_t *)sendPayload;
// Write sequence number to first 4 bytes
UINT_32ToByte(seqNum, (const uint8_t *)pyldPtr);
pyldPtr += 4;
// Write function ID to second 4 bytes
UINT_32ToByte((const uint32_t) fnID, (const uint8_t *)pyldPtr);
pyldPtr += 4;
// Write 0xFFFFFFFF to third 4 bytes
UINT_32ToByte(0xFFFFFFFF, (const uint8_t *)pyldPtr);
pyldPtr += 4;
// Copy sendData to payload buffer
uint8_t *dataPtr = (uint8_t *)sendData;
for(i = 0;i<sendBytes;i++) {
*pyldPtr++ = *dataPtr++;
}
if(CLIENT_interface_writeFrame(sendPayload, sendBytes + 12) != FLR_OK)
return FLR_COMM_ERROR_WRITING_COMM;
return R_SUCCESS;
}
// Asynchronous (MultiService compatible) receive part
FLR_RESULT CLIENT_dispatcher_Rx(uint32_t *seqNum, uint32_t *fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes) {
uint32_t i;
// Allocated buffer with extra space for return data
uint8_t receivePayload[530];
uint8_t *inPtr = (uint8_t *)receivePayload;
*receiveBytes+=12;
if(CLIENT_interface_readFrame(receivePayload, receiveBytes) != FLR_OK)
return FLR_COMM_ERROR_READING_COMM;
if (*receiveBytes < 12) {
if(CLIENT_interface_readFrame(receivePayload, receiveBytes) != FLR_OK)
return FLR_COMM_ERROR_READING_COMM;
}
if (*receiveBytes < 12)
return FLR_COMM_ERROR_READING_COMM;
// Evaluate sequence bytes as UINT_32
uint32_t returnSequence;
byteToUINT_32( (const uint8_t *) inPtr, &returnSequence);
inPtr += 4;
// Ensure that received sequence matches sent sequence
if(seqNum){
*seqNum = returnSequence;
}
// Evaluate CMD ID bytes as UINT_32
uint32_t cmdID;
byteToUINT_32( (const uint8_t *) inPtr, &cmdID);
inPtr += 4;
// Ensure that received CMD ID matches sent CMD ID
if(fnID){
*fnID = cmdID;
}
// Evaluate Payload Status bytes as UINT_32
uint32_t pyldStatus;
byteToUINT_32( (const uint8_t *) inPtr, &pyldStatus);
inPtr += 4;
const FLR_RESULT returncode = (FLR_RESULT) pyldStatus;
// Check for any errorcode
if(returncode != R_SUCCESS){
return returncode;
}
// Now have Good Tx, Good Sequence, Good CMD ID, and Good Status.
// inPtr at Data block, fill receiveData buffer with outPtr
uint8_t *outPtr = (uint8_t *)receiveData;
// decrement receiveBytes by 12 (len of header bytes)
*receiveBytes-=12;
uint32_t localvar = *receiveBytes; //shouldn't have to do this, but it works.
for(i=0;i<localvar;i++) {
*outPtr++ = *inPtr++;
}
return R_SUCCESS;
} // End CLIENT_dispatcher()
// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT CLIENT_dispatcher(uint32_t seqNum, FLR_FUNCTION fnID, const uint8_t *sendData, const uint32_t sendBytes, const uint8_t *receiveData, uint32_t *receiveBytes)
{ uint32_t returnSequence;
uint32_t cmdID;
FLR_RESULT res = CLIENT_dispatcher_Tx(seqNum, fnID, sendData, sendBytes, receiveData, receiveBytes);
if (res)
return res;
res = CLIENT_dispatcher_Rx(&returnSequence, &cmdID, sendData, sendBytes, receiveData, receiveBytes);
if (res)
return res;
if (returnSequence ^ seqNum)
return R_SDK_DSPCH_SEQUENCE_MISMATCH;
if (cmdID ^ (uint32_t) fnID)
return R_SDK_DSPCH_ID_MISMATCH;
return R_SUCCESS;
}
FLR_RESULT CheckReadyDataCommandId(uint32_t receiveBytes, const uint8_t *receiveData, uint32_t *commandId)
{
if (!receiveData || !commandId)
return FLR_ERROR;
if (receiveBytes < 8)
return FLR_RANGE_ERROR;
uint8_t *inPtr = (uint8_t *)receiveData;
// Evaluate sequence bytes as UINT_32
uint32_t returnSequence;
byteToUINT_32( (const uint8_t *) inPtr, &returnSequence);
inPtr += 4;
// Evaluate CMD ID bytes as UINT_32
uint32_t cmdID;
byteToUINT_32( (const uint8_t *) inPtr, &cmdID);
*commandId = cmdID;
return R_SUCCESS;
}

View File

@ -0,0 +1,53 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "Client_Interface.h"
#ifdef USE_I2C_SLAVE_CP
#include "I2C_Connector.h"
#else
#include "UART_Connector.h"
static uint8_t CommandChannel = 0x00;
#endif
FLR_RESULT CLIENT_interface_readFrame(uint8_t *readData, uint32_t *readBytes)
{
if(readData == NULL || readBytes == NULL)
return FLR_BAD_ARG_POINTER_ERROR;
#ifdef USE_I2C_SLAVE_CP
if(I2C_readFrame(readData, readBytes) != FLR_OK)
return FLR_COMM_ERROR_READING_COMM;
#else
ReadFrame(CommandChannel, readBytes, readData);
#endif
return FLR_OK;
}
FLR_RESULT CLIENT_interface_writeFrame(uint8_t *writeData, uint32_t writeBytes)
{
if(writeData == NULL)
return FLR_BAD_ARG_POINTER_ERROR;
#ifdef USE_I2C_SLAVE_CP
if(I2C_writeFrame(writeData, writeBytes) != FLR_OK)
return FLR_COMM_ERROR_WRITING_COMM;
#else
SendToCamera(CommandChannel, writeBytes, writeData);
#endif
return FLR_OK;
}

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,742 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include <stdio.h>
#include "FSLP.h"
#include "flirCRC.h"
#include "flirChannels.h"
#include "timeoutLogic.h"
//MODIFY or replace this serial port library as necessary
#include "serialPortAdapter.h"
#define DO_ERROR_TRACE(...) //printf(__VA_ARGS__)
#define DO_DEBUG_TRACE(...) //printf(__VA_ARGS__)
#define DO_VERBOSE_TRACE(...) //printf(__VA_ARGS__)
#define ESCAPE_BYTE 0x9E
#define START_FRAME_BYTE 0x8E
#define END_FRAME_BYTE 0xAE
#define ESCAPED_ESCAPE_BYTE 0x91
#define ESCAPED_START_FRAME_BYTE 0x81
#define ESCAPED_END_FRAME_BYTE 0xA1
#define NUM_FRAMING_BYTES 3
#define FRAME_START_IDX 1
#define CRC_START_IDX 0
#define FRAME_BUF_SIZ 2048
#define FRAME_TIMEOUT_SEC 2.000
#define POLL_TIMEOUT_SEC 0.025
#define BYTE_TIMEOUT_SEC 0.005
enum frame_state_e {
UNFRAMED = 0,
CORRECT_FRAME = 1,
OTHER_FRAME = 2,
};
typedef enum frame_state_e frame_state;
static uint8_t other_frame_ID;
static int16_t read_single_byte()
{
return FSLP_read_byte_with_timeout(BYTE_TIMEOUT_SEC);
}
// defined by serialPortAdapter
// static inline int write_byte(int outc)
static void extract_payload(uint8_t* raw_payload_buf, uint32_t raw_payload_len, uint8_t* payload_buf, uint32_t* payload_len)
{
uint32_t i;
for(*payload_len=0, i=0; i < raw_payload_len; i++)
{
// if (raw_payload_buf[i] == ESCAPE_BYTE) i++;
payload_buf[(*payload_len)++] = raw_payload_buf[i];
}
}
int32_t FSLP_read_frame(uint8_t channel_ID, uint16_t start_byte_ms,uint32_t *receiveBytes, uint8_t *receiveBuffer)
{
int32_t byte_idx = 0;
int32_t tempval = 0;
frame_state am_in_frame = UNFRAMED;
uint8_t found_complete_frame=0, in_escape=0;
uint8_t c;
// uint8_t failedcrc = 0;
uint16_t calc_crc;
uint8_t in_frame_buf[FRAME_BUF_SIZ];
if (get_channel(channel_ID, &chan_ptr))
DO_ERROR_TRACE("Channel not found for channel_ID [0x%02x]\n", channel_ID);
get_unframed(&unframed_ptr);
struct timespec start_t,current_t;
double elapsed_sec;
clock_gettime(CLOCK_MONOTONIC, &start_t);
double timeout = (double)start_byte_ms/1000;
*receiveBytes = 0;
if (chan_ptr && (chan_ptr->len > 0)) {
int i,j;
DO_DEBUG_TRACE("POLL buffer start = %d, len = %d \n", chan_ptr->start, chan_ptr->len);
DO_DEBUG_TRACE("current buffer[20] : ");
for (j = 0; j < 20; j++){
i = ( (chan_ptr->start + j ) % CHANNEL_BUF_SIZ);
DO_DEBUG_TRACE(" %02X", chan_ptr->buff[i]);
}
DO_DEBUG_TRACE("\n");
while (chan_ptr->len > 0) {
// if (i==poll_idx_lo) DO_DEBUG_TRACE("Entered PROCESS_BUFF_%02d\n",chan_ptr->channel);
int32_t ret = get_byte(&c, chan_ptr);
if (ret < 0){
DO_ERROR_TRACE("Failed to get_byte\n");
DO_VERBOSE_TRACE("Breaking the pre-received path\n");
break;
} else {
DO_VERBOSE_TRACE("Next byte: [0x%02x]\n", c);
}
if (c == START_FRAME_BYTE)
{
DO_DEBUG_TRACE(" POLL_RX_BUF StartByte \n ");
timeout = FRAME_TIMEOUT_SEC;
DO_VERBOSE_TRACE("Setting timeout to FRAME_TIMEOUT_SEC\n");
byte_idx = 0;
am_in_frame = CORRECT_FRAME;
DO_VERBOSE_TRACE("Am in CORRECT_FRAME\n");
DO_VERBOSE_TRACE("Continuing (to get_byte stage)\n");
continue;
}
if (am_in_frame) {
if (c == ESCAPE_BYTE)
{
in_escape = 1;
int32_t ret = get_byte(&c,chan_ptr);
if (ret < 0){
DO_ERROR_TRACE("Failed to get_byte\n");
DO_VERBOSE_TRACE("Breaking the pre-received path\n");
break;
}
switch (c){
case ESCAPED_END_FRAME_BYTE:
c = END_FRAME_BYTE;
break;
case ESCAPED_START_FRAME_BYTE:
c = START_FRAME_BYTE;
break;
case ESCAPED_ESCAPE_BYTE:
c = ESCAPE_BYTE;
break;
default:
break;
}
in_frame_buf[byte_idx++] = c;
DO_DEBUG_TRACE(" %02X",c);
DO_VERBOSE_TRACE("in_frame_buf[%d] [%02X]",(byte_idx - 1), c);
DO_VERBOSE_TRACE("Continuing (to get_byte stage)\n");
continue;
}
if (c == END_FRAME_BYTE)
{
DO_VERBOSE_TRACE("Am in UNFRAMED\n");
am_in_frame = UNFRAMED;
/*
* Check CRC: if good end loop. If bad, start looking for start byte.
* Check Frame Status: If zero, end loop. If non-zero, start looking for start byte.
*/
/*
* byte_idx - 3 = total frame length - channel_ID byte - crc_bytes[2]
* &(frame_buf[1]) is first byte after channel_ID byte
*/
calc_crc = calcFlirCRC16Bytes((byte_idx - 2), &(in_frame_buf[CRC_START_IDX]));
if ( (((calc_crc >> 8) &0xFF) != in_frame_buf[byte_idx - 2]) || ((calc_crc &0xFF) != in_frame_buf[byte_idx - 1]) )
{
DO_ERROR_TRACE("\nFailed packet integrity check (calc) %02X%02X != (recd) %02X%02X\n",((calc_crc >> 8) &0xFF),(calc_crc&0xFF),in_frame_buf[byte_idx - 2],in_frame_buf[byte_idx - 1]);
DO_ERROR_TRACE("RAW Receive Packet: ");
for (i = 0; i < byte_idx; i++){
DO_ERROR_TRACE(" %02X",in_frame_buf[i]);
}
DO_ERROR_TRACE("\n");
// DO_ERROR_TRACE(" Failed time %f:\n",elapsed_sec);
// failedcrc = 1;
byte_idx = 0;
timeout = POLL_TIMEOUT_SEC;
DO_VERBOSE_TRACE("Setting timeout to POLL_TIMEOUT_SEC\n");
DO_VERBOSE_TRACE("Continuing (to get_byte stage)\n");
continue;
} else {
DO_DEBUG_TRACE("\n");
}
found_complete_frame = 1;
DO_VERBOSE_TRACE("Found a complete frame - breaking the pre-received path\n");
break;
}
in_frame_buf[byte_idx++] = c;
DO_VERBOSE_TRACE("in_frame_buf[%d] [0x%02x]\n", (byte_idx - 1), c);
DO_DEBUG_TRACE(" %02X",c);
DO_VERBOSE_TRACE("Continuing (to get_byte stage)\n");
continue;
}
}
}
if (found_complete_frame) {
DO_DEBUG_TRACE("Found Complete Frame in channel_buf_%02d\n",chan_ptr->channel);
DO_DEBUG_TRACE("current buffer start = %d, len = %d \n",chan_ptr->start,chan_ptr->len);
extract_payload(&(in_frame_buf[FRAME_START_IDX]), (byte_idx - NUM_FRAMING_BYTES), receiveBuffer, receiveBytes);
return 0;
}
DO_DEBUG_TRACE("Entering serial loop...\n");
clock_gettime(CLOCK_MONOTONIC, &start_t);
while(1)
{
// if (failedcrc){
// DO_ERROR_TRACE("AFTER FAIL: %f\n",elapsed_sec);
// }
if (byte_idx == FRAME_BUF_SIZ)
{
// Buffer overrun
DO_ERROR_TRACE("Buffer overrun - exitting\n");
return -1;
}
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
// The whole thing has been taking too long
if (elapsed_sec >= timeout){
DO_DEBUG_TRACE("Frame reading has been taking too long [%f]\n", elapsed_sec);
DO_ERROR_TRACE("Timeout: %f s\n", elapsed_sec);
if (am_in_frame == CORRECT_FRAME) {
int i;
DO_VERBOSE_TRACE("Timeout while in CORRECT_FRAME: %f s\n", elapsed_sec);
DO_ERROR_TRACE("Received frame fragment - len:[%ld] : ", byte_idx);
for (i = 0; i < byte_idx; i++){
DO_ERROR_TRACE(" %02X", in_frame_buf[i]);
}
DO_ERROR_TRACE("\n");
} else {
DO_VERBOSE_TRACE("Timeout while in %s: %f s\n", (am_in_frame) ? "OTHER_FRAME" : "UNFRAMED", elapsed_sec);
}
*receiveBytes = 0;
am_in_frame = UNFRAMED;
return -1;
}
if (in_escape && (am_in_frame == CORRECT_FRAME)) {
//carryover escape character from buffer
tempval = ESCAPE_BYTE;
} else {
//normal operations
tempval = read_single_byte();
}
if (tempval<0) {
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
DO_VERBOSE_TRACE("Timeout in read_byte; current frame read time %f\n", elapsed_sec);
DO_VERBOSE_TRACE("Continuing...\n");
continue; //byte read timeout.
} else {
c = (uint8_t) tempval;
DO_VERBOSE_TRACE("Next byte: [0x%02x]\n", c);
}
if ((c & 0xFF) == (START_FRAME_BYTE & 0xFF))
{
DO_DEBUG_TRACE(" StartByte time %f:\n ",elapsed_sec);
DO_VERBOSE_TRACE("Setting timeout to FRAME_TIMEOUT_SEC=%f\n",FRAME_TIMEOUT_SEC);
timeout = FRAME_TIMEOUT_SEC;
DO_VERBOSE_TRACE("Resetting start time from %f to %f\n",start_t,current_t);
start_t = current_t;
byte_idx = 0;
do {
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
if (elapsed_sec > timeout) {
DO_DEBUG_TRACE("Abort waiting for channel ID at %f of %f seconds\n",elapsed_sec,timeout);
break;
}
tempval = read_single_byte();
if ( (tempval & 0xFF) == (START_FRAME_BYTE & 0xFF) )
{
DO_DEBUG_TRACE("Weird Byte 0x%X\n",tempval);
tempval = -1;
}
} while (tempval < 0);
if (tempval < 0) {
DO_VERBOSE_TRACE("Timeout in read_byte\n");
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
c = (uint8_t) tempval & 0xFF;
uint8_t needs_escape = 0;
if (c == ESCAPE_BYTE){
DO_DEBUG_TRACE("ESCAPE char before channel byte\n");
needs_escape = 1;
do {
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
if (elapsed_sec > timeout) {
DO_DEBUG_TRACE("Abort waiting for escaped channel ID at %f of %f seconds\n",elapsed_sec,timeout);
break;
}
tempval = read_single_byte();
if ( (tempval & 0xFF) == (START_FRAME_BYTE & 0xFF) )
{
DO_DEBUG_TRACE("Escaped channel Byte 0x%X\n",tempval);
tempval = -1;
}
} while (tempval < 0);
if (tempval < 0) {
DO_VERBOSE_TRACE("Timeout in read_byte\n");
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
c = (uint8_t) tempval & 0xFF;
}
if (c == channel_ID) {
//found correct frame
DO_VERBOSE_TRACE("Am in CORRECT_FRAME\n");
am_in_frame = CORRECT_FRAME;
in_frame_buf[byte_idx++] = c;
DO_VERBOSE_TRACE("in_frame_buf[%d] [0x%02x]\n", (byte_idx - 1), c);
} else {
DO_VERBOSE_TRACE("Am in OTHER_FRAME (0x%02x)\n", c);
am_in_frame = OTHER_FRAME;
other_frame_ID = c;
get_channel(other_frame_ID, &chan_ptr);
if (!chan_ptr){
DO_ERROR_TRACE("Incoming frame's channel (0x%02x) not found\n", other_frame_ID);
chan_ptr = unframed_ptr;
am_in_frame = UNFRAMED;
DO_VERBOSE_TRACE("Am in UNFRAMED\n");
continue;
}
add_byte(START_FRAME_BYTE,chan_ptr);
if(needs_escape)
add_byte(ESCAPE_BYTE,chan_ptr);
add_byte(c,chan_ptr);
DO_VERBOSE_TRACE("Add START + (ESCAPE) + [0x%02x]\n", c);
}
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
if (am_in_frame == CORRECT_FRAME) {
if ((c & 0xFF) == (ESCAPE_BYTE & 0xFF))
{
in_escape = 1;
do {
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
if (elapsed_sec>timeout) {
DO_DEBUG_TRACE("Abort waiting for escaped normal byte at %f of %f seconds\n",elapsed_sec,timeout);
break;
}
tempval = read_single_byte();
} while (tempval < 0);
if (tempval < 0) {
DO_VERBOSE_TRACE("Timeout in read_byte\n");
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
c = (uint8_t) tempval;
switch (c){
case ESCAPED_END_FRAME_BYTE:
c = END_FRAME_BYTE;
break;
case ESCAPED_START_FRAME_BYTE:
c = START_FRAME_BYTE;
break;
case ESCAPED_ESCAPE_BYTE:
c = ESCAPE_BYTE;
break;
default:
break;
}
in_frame_buf[byte_idx++] = c;
in_escape = 0;
DO_VERBOSE_TRACE("in_frame_buf[%d] [0x%02x]\n", (byte_idx - 1), c);
DO_DEBUG_TRACE(" %02X",c);
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
if ((c & 0xFF) == (END_FRAME_BYTE & 0xFF))
{
// DO_ERROR_TRACE("\n EndByte time %f:\n",elapsed_sec);
// frame_buf[byte_idx++] = c;
/*
* Check CRC: if good end loop. If bad, start looking for start byte.
* Check Frame Status: If zero, end loop. If non-zero, start looking for start byte.
*/
/*
* byte_idx - 3 = total frame length - channel_ID byte - crc_bytes[2]
* &(frame_buf[1]) is first byte after channel_ID byte
*/
DO_VERBOSE_TRACE("End frame byte\n");
am_in_frame = UNFRAMED;
DO_VERBOSE_TRACE("Am in UNFRAMED\n");
calc_crc = calcFlirCRC16Bytes((byte_idx - 2), &(in_frame_buf[CRC_START_IDX]));
if ( (((calc_crc >> 8) &0xFF) != in_frame_buf[byte_idx - 2]) || ((calc_crc &0xFF) != in_frame_buf[byte_idx - 1]) )
{
int i;
DO_ERROR_TRACE("Failed POLL packet integrity check (calc) %02X%02X != (recd) %02X%02X\n",((calc_crc >> 8) &0xFF),(calc_crc&0xFF),in_frame_buf[byte_idx - 2],in_frame_buf[byte_idx - 1]);
DO_ERROR_TRACE("RAW Receive Packet: ");
for (i = 0; i < byte_idx; i++){
DO_ERROR_TRACE(" %02X", in_frame_buf[i]);
}
DO_ERROR_TRACE("\n");
// DO_ERROR_TRACE(" Failed time %f:\n",elapsed_sec);
// failedcrc = 1;
byte_idx = 0;
clock_gettime(CLOCK_MONOTONIC, &start_t);
timeout= (double)start_byte_ms/1000;
DO_VERBOSE_TRACE("Setting timeout to [%f]\n", timeout);
DO_VERBOSE_TRACE("Continuing...\n");
continue;
} else {
DO_DEBUG_TRACE("\n");
}
DO_VERBOSE_TRACE("Found complete frame\n");
found_complete_frame = 1;
DO_VERBOSE_TRACE("Breaking the serial loop path\n");
break;
}
in_frame_buf[byte_idx++] = c;
DO_VERBOSE_TRACE("in_frame_buf[%d] [0x%02x]\n", (byte_idx - 1), c);
DO_DEBUG_TRACE(" %02X",c);
} else if (am_in_frame == OTHER_FRAME) {
if ((c & 0xFF) == (ESCAPE_BYTE & 0xFF)) {
in_escape = 1;
add_byte(c,chan_ptr);
DO_VERBOSE_TRACE("Add [0x%02x]\n", c);
do {
clock_gettime(CLOCK_MONOTONIC, &current_t);
elapsed_sec = diff_timespec(&current_t, &start_t);
if (elapsed_sec>timeout) {
break;
}
tempval = read_single_byte();
} while (tempval < 0);
if (tempval < 0) {
DO_VERBOSE_TRACE("Timeout in read_byte\n");
DO_VERBOSE_TRACE("Continuing...\n");
continue;
}
c = (uint8_t) tempval;
add_byte(c,chan_ptr);
DO_VERBOSE_TRACE("Add [0x%02x]\n", c);
in_escape = 0;
} else if ((c & 0xFF) == (END_FRAME_BYTE & 0xFF)) {
add_byte(c,chan_ptr);
DO_VERBOSE_TRACE("Add [0x%02x]\n", c);
am_in_frame = UNFRAMED;
DO_VERBOSE_TRACE("End frame byte\n");
DO_VERBOSE_TRACE("Am in UNFRAMED\n");
found_complete_frame = 1;
break;
} else {
add_byte(c,chan_ptr);
DO_VERBOSE_TRACE("Add [0x%02x]\n", c);
}
DO_DEBUG_TRACE("(%02d:%02X)",chan_ptr->channel,c);
DO_VERBOSE_TRACE("Continuing...\n");
continue;
} else { //Unframed data
DO_DEBUG_TRACE("(U:%02X)",c);
add_byte(c,unframed_ptr);
DO_VERBOSE_TRACE("Add [0x%02x] to unframed\n", c);
}
}
if (found_complete_frame) {
if (channel_ID == 0xff) {
*receiveBuffer = other_frame_ID;
*receiveBytes = chan_ptr->len;
DO_VERBOSE_TRACE("Frame completed in 0xff mode\n");
} else {
extract_payload(&(in_frame_buf[FRAME_START_IDX]), (byte_idx - NUM_FRAMING_BYTES), receiveBuffer, receiveBytes);
}
return 0;
} else {
*receiveBytes = 0;
return 0;
}
}
void FSLP_read_unframed(uint16_t start_byte_ms, uint32_t *receiveBytes, uint8_t *receiveBuffer){
int tempval = 0;
// frame_state am_in_frame = UNFRAMED;
uint8_t c;
// uint8_t failedcrc = 0;
get_unframed(&unframed_ptr);
// clock_t start_t,elapsed_t;
// float elapsed_sec;
// float timeout = (float)start_byte_ms/1000.0;
*receiveBytes = 0;
while(unframed_ptr->len > 0){
if (*receiveBytes == FRAME_BUF_SIZ) return;
tempval = get_byte(&c,unframed_ptr);
if (tempval < 0){
break;
}
receiveBuffer[(*receiveBytes)++] = c;
DO_DEBUG_TRACE(" %02X",c);
}
}
static int32_t create_frame(uint8_t *frame_buf, uint8_t channel_ID, uint8_t *payload, uint32_t payload_len)
{
uint32_t i;
int32_t out_len = 0;
uint16_t crc_out = FLIR_CRC_INITIAL_VALUE;
frame_buf[out_len++] = (uint8_t) START_FRAME_BYTE;
frame_buf[out_len++] = (uint8_t) channel_ID;
crc_out = calcFlirByteCRC16(channel_ID, (int) crc_out);
// frame_buf[out_len++] = (uint8_t) 0x00; // Removed Frame status byte[0]
// crc_out = calcFlirByteCRC16(0x00, (int) crc_out);
// frame_buf[out_len++] = (uint8_t) 0x00; // Removed Frame status byte[1]
// crc_out = calcFlirByteCRC16(0x00, (int) crc_out);
if ((payload_len + 5) > FRAME_BUF_SIZ) // start + channel_ID + payload + crc_bytes[2] + end
return (-1);
for(i=0; i < payload_len; i++)
{
if ((payload[i] == START_FRAME_BYTE) || (payload[i] == END_FRAME_BYTE) || (payload[i] == ESCAPE_BYTE)){
frame_buf[out_len++] = ESCAPE_BYTE;
uint8_t c = payload[i];
crc_out = calcFlirByteCRC16((int) c, (int) crc_out);
switch (c)
{
case END_FRAME_BYTE:
c = ESCAPED_END_FRAME_BYTE;
break;
case START_FRAME_BYTE:
c = ESCAPED_START_FRAME_BYTE;
break;
case ESCAPE_BYTE:
c = ESCAPED_ESCAPE_BYTE;
break;
default:
break;
}
frame_buf[out_len++] = c;
}
else
{
frame_buf[out_len++] = payload[i];
crc_out = calcFlirByteCRC16((int) payload[i], (int) crc_out);
}
if ((out_len + 3) > FRAME_BUF_SIZ)
return (-2);
}
// crc_out = calcFlirCRC16Bytes(out_len, frame_buf);
uint8_t crcbyte = ((crc_out >> 8) & 0xFF);
if ((crcbyte == START_FRAME_BYTE) || (crcbyte == END_FRAME_BYTE) || (crcbyte == ESCAPE_BYTE)) {
frame_buf[out_len++] = ESCAPE_BYTE;
uint8_t c = crcbyte;
switch (c)
{
case END_FRAME_BYTE:
c = ESCAPED_END_FRAME_BYTE;
break;
case START_FRAME_BYTE:
c = ESCAPED_START_FRAME_BYTE;
break;
case ESCAPE_BYTE:
c = ESCAPED_ESCAPE_BYTE;
break;
default:
break;
}
frame_buf[out_len++] = c;
}
else
{
frame_buf[out_len++] = crcbyte;
}
crcbyte = (crc_out & 0xFF);
if ((crcbyte == START_FRAME_BYTE) || (crcbyte == END_FRAME_BYTE) || (crcbyte == ESCAPE_BYTE)) {
frame_buf[out_len++] = ESCAPE_BYTE;
uint8_t c = crcbyte;
switch (c)
{
case END_FRAME_BYTE:
c = ESCAPED_END_FRAME_BYTE;
break;
case START_FRAME_BYTE:
c = ESCAPED_START_FRAME_BYTE;
break;
case ESCAPE_BYTE:
c = ESCAPED_ESCAPE_BYTE;
break;
default:
break;
}
frame_buf[out_len++] = c;
}
else
{
frame_buf[out_len++] = crcbyte;
}
frame_buf[out_len++] = END_FRAME_BYTE;
return(out_len);
}
static int write_frame(uint8_t *frame_buf, uint32_t len)
{
int i;
DO_DEBUG_TRACE("Writing Frame: ");
for(i=0; i<len; i++){
DO_DEBUG_TRACE(" %02X",frame_buf[i]);
}
DO_DEBUG_TRACE("...\n");
if (FSLP_write_buffer(frame_buf, len) == len){
DO_DEBUG_TRACE("Success.");
return 0;
} else {
DO_DEBUG_TRACE("Failed.");
return -1;
}
}
//, uint32_t *receiveBytes, uint8_t *receivePayload)
void FSLP_send_to_camera(uint8_t channel_ID, uint32_t sendBytes, uint8_t *sendPayload)
{
int success=0;//, i=0;
uint8_t out_frame_buf[FRAME_BUF_SIZ];
int32_t out_len;//, in_payload_len, out_payload_len;
out_len = create_frame(out_frame_buf,channel_ID, sendPayload, sendBytes);
DO_DEBUG_TRACE("sendBytes = %u, out_len = %d\n",sendBytes, out_len);
success = write_frame(out_frame_buf, out_len);
DO_DEBUG_TRACE("frame send status %d.\n",success);
(void) success;
}
int32_t FSLP_check_data_ready(uint8_t *channel_ID, uint16_t start_byte_ms, uint32_t *receiveBytes, const uint8_t **receiveBuffer)
{
uint32_t length;
/*
* A call to read_frame with SERVICE_UNRELATED_CHANNEL_ID will cause it to receive whatever is available
* in OTHER_FRAME mode - there is no service matching the channel_ID we pass.
* As a result data will remain in the channel's buffer, and only its length and its channel_ID will be
* returned;
*/
int32_t ret = FSLP_read_frame(SERVICE_UNRELATED_CHANNEL_ID, start_byte_ms, &length, channel_ID);
if (ret < 0) {
DO_ERROR_TRACE("Error in reading frame\n");
return -1;
}
if (length) {
CHANNEL_T *chan_ptr = 0;
if (get_channel(*channel_ID, &chan_ptr) || !chan_ptr) {
DO_ERROR_TRACE("Failed to find channel for data ready for service [0x%02x]\n", *channel_ID);
return -1;
}
/*
* Lenght will include also the Binary Protocol framing bytes
* We return address of the channel's buffer, excluding the START_FRAME byte (which wouldn't
* get copied to the output buffer) and offset by the FRAME_START_IDX
*/
*receiveBytes = length;
*receiveBuffer = &chan_ptr->buff[chan_ptr->start + 1/* START_FRAME_BYTE */ + FRAME_START_IDX];
}
return 0;
}

View File

@ -0,0 +1,107 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "I2C_Connector.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
extern FLR_RESULT I2C_read(uint8_t* readData, uint32_t readBytes);
extern FLR_RESULT I2C_write(uint8_t* writeData, uint32_t writeBytes);
static uint8_t frameHead[I2C_SLAVE_CP_FRAME_HEAD_SIZE] = {0x8E, 0xA1};
static void addToShiftBuffer(uint8_t* buffer, uint32_t bufferSize, uint8_t value)
{
for(uint32_t index = 0; index < (bufferSize - 1); ++index)
{
buffer[index] = buffer[index + 1];
}
buffer[bufferSize - 1] = value;
}
FLR_RESULT I2C_readFrame(uint8_t* readData, uint32_t* readBytes)
{
bool frameNotReady = true, headerFound = false;
uint8_t retByte;
uint8_t* readBuffer;
uint32_t bytesNumber, readSize;
uint8_t headerBuffer[I2C_SLAVE_CP_FRAME_HEADER_SIZE];
if(readData == NULL || readBytes == NULL)
{
return FLR_BAD_ARG_POINTER_ERROR;
}
readBuffer = &retByte;
readSize = 1;
do
{
if(I2C_read(readBuffer, readSize) != FLR_OK)
{
return FLR_COMM_ERROR_READING_COMM;
}
if(headerFound)
{
*readBytes = readSize;
frameNotReady = false;
}
else
{
addToShiftBuffer(headerBuffer, I2C_SLAVE_CP_FRAME_HEADER_SIZE, retByte);
if(memcmp(headerBuffer, frameHead, I2C_SLAVE_CP_FRAME_HEAD_SIZE) == 0)
{
bytesNumber = ((uint32_t)headerBuffer[I2C_SLAVE_CP_FRAME_HEAD_SIZE]) << 8 | (uint32_t)headerBuffer[I2C_SLAVE_CP_FRAME_HEAD_SIZE + 1];
readSize = bytesNumber;
readBuffer = readData;
headerFound = true;
}
}
} while(frameNotReady);
return FLR_OK;
}
FLR_RESULT I2C_writeFrame(uint8_t* writeData, uint32_t writeBytes)
{
if(writeData == NULL)
{
return FLR_BAD_ARG_POINTER_ERROR;
}
if(writeBytes < 1)
{
return FLR_ERROR;
}
uint8_t sendFrame[writeBytes + I2C_SLAVE_CP_FRAME_HEADER_SIZE];
uint8_t* ptr = sendFrame;
memcpy(ptr, frameHead, I2C_SLAVE_CP_FRAME_HEAD_SIZE);
ptr += I2C_SLAVE_CP_FRAME_HEAD_SIZE;
*ptr = (uint8_t)((writeBytes >> 8) & 0xFF);
ptr++;
*ptr = (uint8_t)(writeBytes & 0xFF);
ptr++;
memcpy(ptr, writeData, writeBytes);
ptr = sendFrame;
if(I2C_write(ptr, sizeof(sendFrame)) != FLR_OK)
{
return FLR_COMM_ERROR_WRITING_COMM;
}
return FLR_OK;
}

View File

@ -0,0 +1,68 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "MultiServiceSupport.h"
#include "UART_Connector.h"
typedef struct {
uint8_t svc;
svcDataReadyCallback_t *callback;
} CALLBACK_CONFIG;
#define SERVICE_UNRELATED_SVC_ID (0xff)
static CALLBACK_CONFIG callbacks[MAX_SERVICES];
FLR_RESULT RegisterServiceDataCallback(uint8_t svc, svcDataReadyCallback_t *callback)
{
int i;
if (!callback)
return FLR_ERROR;
for (i = 0; i < MAX_SERVICES; i++) {
if (callbacks[i].callback == 0) {
callbacks[i].callback = callback;
callbacks[i].svc = svc;
break;
}
}
if (i == MAX_SERVICES)
return FLR_RANGE_ERROR;
return R_SUCCESS;
}
FLR_RESULT CheckServiceDataReady(void)
{
const uint8_t *rawData = 0;
uint32_t length = 0;
uint8_t svc = 0;
int32_t ret = CheckDataReady(&svc, &length, &rawData);
if (ret < 0)
return FLR_ERROR;
if (length) {
int i;
for (i = 0; i < MAX_SERVICES; i++) {
if ((callbacks[i].svc == svc) && (callbacks[i].callback)) {
ret = callbacks[i].callback(length, rawData);
if (ret) printf("Error in callback for svc [0x%02x] : [%ld]\n", callbacks[i].svc, ret);
}
}
}
return R_SUCCESS;
}

View File

@ -0,0 +1,257 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "Serializer_BuiltIn.h"
//#include <stdio.h>
void byteToBOOL(const uint8_t *inBuff, _Bool *outVal){
*outVal = (_Bool) *inBuff;
}
void byteToBOOLArray(const uint8_t *inBuff, _Bool *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToBOOL(inBuff+i,&(outVal[i]));
}
}
void byteToCHAR(const uint8_t *inBuff, int8_t *outVal){
*outVal = (int8_t) *inBuff;
}
void byteToCHARArray(const uint8_t *inBuff, int8_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToCHAR(inBuff+i,&(outVal[i]));
}
}
void byteToUCHAR(const uint8_t *inBuff, uint8_t *outVal){
*outVal = (uint8_t) *inBuff;
}
void byteToUCHARArray(const uint8_t *inBuff, uint8_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToUCHAR(inBuff+i,&(outVal[i]));
}
}
void byteToINT_16(const uint8_t *inBuff, int16_t *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
*outVal = (int16_t) *ptr++ << 8;
*outVal = *outVal | *ptr;
}
void byteToINT_16Array(const uint8_t *inBuff, int16_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToINT_16(inBuff+(i*2),&(outVal[i]));
}
}
void byteToUINT_16(const uint8_t *inBuff, uint16_t *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
*outVal = (uint16_t) *ptr++ << 8;
*outVal = *outVal | *ptr;
}
void byteToUINT_16Array(const uint8_t *inBuff, uint16_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToUINT_16(inBuff+(i*2),&(outVal[i]));
}
}
void byteToINT_32(const uint8_t *inBuff, int32_t *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
*outVal = (int32_t) (*ptr++)<<24;
*outVal |= ((int32_t) (*ptr++)<<16);
*outVal |= ((int32_t) (*ptr++)<<8);
*outVal |=*ptr;
}
void byteToINT_32Array(const uint8_t *inBuff, int32_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToINT_32(inBuff+(i*4),&(outVal[i]));
}
}
void byteToUINT_32(const uint8_t *inBuff, uint32_t *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
*outVal = (uint32_t) (*ptr++)<<24;
*outVal |= ((uint32_t) (*ptr++)<<16);
*outVal |= ((uint32_t) (*ptr++)<<8);
*outVal |= *ptr;
}
void byteToUINT_32Array(const uint8_t *inBuff, uint32_t *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToUINT_32(inBuff+(i*4),&(outVal[i]));
}
}
void byteToFLOAT(const uint8_t *inBuff, float *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
uint32_t tempVal = 0;
tempVal = (uint32_t) (*ptr++)<<24;
tempVal |= ((uint32_t) (*ptr++)<<16);
tempVal |= ((uint32_t) (*ptr++)<<8);
tempVal |= *ptr;
*outVal = *((float *) (&tempVal));
}
void byteToFLOATArray(const uint8_t *inBuff, float *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToFLOAT(inBuff+(i*4),&(outVal[i]));
}
}
void byteToDOUBLE(const uint8_t *inBuff, double *outVal){
uint8_t *ptr = (uint8_t *)inBuff;
uint64_t tempVal = 0;
tempVal = (uint64_t) (*ptr++)<<56;
tempVal |= ((uint64_t) (*ptr++)<<48);
tempVal |= ((uint64_t) (*ptr++)<<40);
tempVal |= ((uint64_t) (*ptr++)<<32);
tempVal |= ((uint64_t) (*ptr++)<<24);
tempVal |= ((uint64_t) (*ptr++)<<16);
tempVal |= ((uint64_t) (*ptr++)<<8);
tempVal |= *ptr;
*outVal = *((double *) (&tempVal));
}
void byteToDOUBLEArray(const uint8_t *inBuff, double *outVal,uint16_t length){
uint16_t i;
for (i=0;i<length;i++) {
byteToDOUBLE(inBuff+(i*8),&(outVal[i]));
}
}
void BOOLToByte(const _Bool inVal, const uint8_t *outBuff){
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr = *((uint8_t *) (&inVal));
}
void BOOLArrayToByte(const _Bool *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
BOOLToByte(inVal[i],outBuff+i);
}
}
void CHARToByte(const int8_t inVal, const uint8_t *outBuff ){
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr = *((uint8_t *) (&inVal));
}
void CHARArrayToByte(const int8_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
CHARToByte(inVal[i],outBuff+i);
}
}
void UCHARToByte(const uint8_t inVal, const uint8_t *outBuff){
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr = inVal;
}
void UCHARArrayToByte(const uint8_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
UCHARToByte(inVal[i],outBuff+i);
}
}
void INT_16ToByte(const int16_t inVal, const uint8_t *outBuff){
uint16_t tempBytes = *((uint16_t *) (&inVal));
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (tempBytes>>8 & 0xff);
*outPtr = (uint8_t) (tempBytes & 0xff);
}
void INT_16ArrayToByte(const int16_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
INT_16ToByte(inVal[i],outBuff+(i*2));
}
}
void UINT_16ToByte(const uint16_t inVal, const uint8_t *outBuff){
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (uint8_t) (inVal>>8 & 0xff);
*outPtr = (uint8_t) (inVal & 0xff);
}
void UINT_16ArrayToByte(const uint16_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
UINT_16ToByte(inVal[i],outBuff+(i*2));
}
}
void INT_32ToByte(const int32_t inVal, const uint8_t *outBuff){
uint32_t tempBytes = *((uint32_t *) (&inVal));
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (uint8_t) (tempBytes>>24 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>16 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>8 & 0xff);
*outPtr = (uint8_t) (tempBytes & 0xff);
}
void INT_32ArrayToByte(const int32_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
INT_32ToByte(inVal[i],outBuff+(i*4));
}
}
void UINT_32ToByte(const uint32_t inVal, const uint8_t *outBuff){
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (uint8_t) (inVal>>24 & 0xff);
*outPtr++ = (uint8_t) (inVal>>16 & 0xff);
*outPtr++ = (uint8_t) (inVal>>8 & 0xff);
*outPtr = (uint8_t) (inVal & 0xff);
}
void UINT_32ArrayToByte(const uint32_t *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
UINT_32ToByte(inVal[i],outBuff+(i*4));
}
}
void FLOATToByte(const float inVal, const uint8_t *outBuff){
uint32_t tempBytes = *((uint32_t *) (&inVal));
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (uint8_t) (tempBytes>>24 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>16 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>8 & 0xff);
*outPtr = (uint8_t) (tempBytes & 0xff);
}
void FLOATArrayToByte(const float *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
FLOATToByte(inVal[i],outBuff+(i*4));
}
}
void DOUBLEToByte(const double inVal, const uint8_t *outBuff){
uint64_t tempBytes = *((uint64_t *) (&inVal));
uint8_t *outPtr = (uint8_t *)outBuff;
*outPtr++ = (uint8_t) (tempBytes>>56 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>48 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>40 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>32 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>24 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>16 & 0xff);
*outPtr++ = (uint8_t) (tempBytes>>8 & 0xff);
*outPtr = (uint8_t) (tempBytes & 0xff);
}
void DOUBLEArrayToByte(const double *inVal,uint16_t length, const uint8_t *outBuff){
uint16_t i;
for (i=0;i<length;i++){
DOUBLEToByte(inVal[i],outBuff+(i*8));
}
}

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,59 @@
/******************************************************************************/
/* */
/* Copyright (C) 2015, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "UART_Connector.h"
#include "serialPortAdapter.h"
#include "FSLP.h"
/* Defaults to 1000ms, can be increased by the user for any commands that take
longer to respond... */
static int readTimeout = 1000;
FLR_RESULT Initialize()
{
if (FSLP_open_port()) return R_UART_PORT_FAILURE;
return FLR_COMM_OK; // 0 == success.
}
void Close()
{
FSLP_close_port();
}
void SendToCamera( uint8_t channelID, uint32_t sendBytes, uint8_t *sendData)
{
FSLP_send_to_camera(channelID, sendBytes, sendData);
}
void ReadFrame(uint8_t channelID, uint32_t *receiveBytes, uint8_t *receiveData)
{
FSLP_read_frame(channelID, readTimeout, receiveBytes, receiveData);
}
void ReadUnframed(uint32_t *receiveBytes, uint8_t *receiveData)
{
// hardcoded 25ms polling delay for now
FSLP_read_unframed(25, receiveBytes,receiveData);
}
void ReadTimeoutSet(unsigned int timeout)
{
readTimeout = timeout;
}
int32_t CheckDataReady(uint8_t *channel_ID, uint32_t *receiveBytes, const uint8_t **receiveData)
{
return FSLP_check_data_ready(channel_ID, readTimeout, receiveBytes, receiveData);
}

View File

@ -0,0 +1,50 @@
// /////////////////////////////////////////////////////
// // DO NOT EDIT. This is a machine generated file. //
// /////////////////////////////////////////////////////
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include <string.h>
#include "UART_Connector.h"
#include "UPTClient.h"
uint8_t sendPayload[1 + MAX_PAYLOAD_BYTES];
FLR_RESULT passToRecipient(UPT_RECIPIENT recipient, const uint8_t *data, uint32_t length)
{
if (!data)
return FLR_ERROR;
if (length > MAX_PAYLOAD_BYTES)
return FLR_DATA_SIZE_ERROR;
sendPayload[0] = (uint8_t)recipient;
memcpy(&sendPayload[1], data, length);
SendToCamera(0xaa, (length + 1), sendPayload);
return R_SUCCESS;
}
FLR_RESULT getMyData(uint8_t *data, uint32_t *length)
{
if (!data || !length)
return FLR_ERROR;
ReadFrame(0xaa, length, data);
return R_SUCCESS;
}

View File

@ -0,0 +1,428 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
/**
* @file dataServiceClient.c
* @author Artur Tynecki
* @date April, 2017
* @brief Data Service Client source file
*
*/
/******************************************************************************/
/** INCLUDE FILES **/
/******************************************************************************/
#include <string.h>
#include <stdio.h>
#include "UART_Connector.h"
#include "dataServiceClient.h"
#include "fifo.h"
#include "py/mphal.h"
/******************************************************************************/
/** EXPORTED DEFINES **/
/******************************************************************************/
#define DO_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DO_INIT_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DO_DATA_SERVICE_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DEBUG_ERR(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DEBUG_WARN(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
/******************************************************************************/
/** LOCAL DATA **/
/******************************************************************************/
static dataServiceController_t controller;
static dataServiceFrame_t sendFrame;
static dataServiceFrame_t receiveFrame;
static fifo_p receiveBuffer;
/******************************************************************************/
/** LOCAL FUNCTIONS DECLARATIONS **/
/******************************************************************************/
static FLR_RESULT parseData(uint8_t *data, uint32_t data_len);
/******************************************************************************/
/** FSLP SERVICE FUNCTIONS **/
/******************************************************************************/
/**
* @brief Send data by HostBinaryProtocol
* @param [in] data - send data pointer
* @param [in] data_len - send data size in bytes
* @return FLR_OK if successful else return error
*/
static FLR_RESULT sendData(uint8_t* data, uint32_t data_len)
{
if(!data || !data_len)
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
SendToCamera(DATA_SERVICE_NUMBER, data_len, data);
DO_TRACE("Send data %d bytes: [0x%02x | 0x%02x ...]\n",
data_len, data[0], data[1]);
return FLR_OK;
}
/******************************************************************************/
/** DATA SERVICE CLIENT FUNCTIONS **/
/******************************************************************************/
/**
* @brief Reset Data Service Client controller
* Set default value in controller structure
* @return none
*/
static void resetController(void)
{
controller.send_counter = 0;
controller.receive_counter = 0;
controller.state = CONTROLLER_READY;
}
/**
* @brief Initialization Data Service Client controller
* Reset controller and callback function
* @return none
*/
static void initController(void)
{
resetController();
controller.callback = NULL;
}
/**
* @brief Prepare Data Service Client frame
* Prepare frame by set command, counter and data
* @param [in] cmd - command code
* @param [in] counter - frame counter
* @param [in] data - data buffer
* @param [in] data_len - data size in bytes
* @return none
*/
static void prepareFrame(dataServiceFrameCommand_t cmd, uint16_t counter, uint8_t* data, uint32_t data_len)
{
uint8_t counter_lsb, counter_msb;
counter_msb = (uint8_t)(counter >> 8);
counter_lsb = (uint8_t)(counter);
sendFrame.buffer[0] = (cmd << 6) | (counter_msb & COUNTER_MASK);
sendFrame.buffer[1] = counter_lsb;
if(data_len > 0 && data != NULL)
{
memcpy(&sendFrame.buffer[2], data, data_len);
}
sendFrame.size = data_len + 2;
}
/**
* @brief Send ACK
* Prepare and send ACK frame
* @param [in] counter - number of receive frame
* @return FLR_OK if successful else return error
*/
static FLR_RESULT sendAck(uint16_t counter)
{
prepareFrame(DATA_ACK, counter, NULL, 0);
return sendData(sendFrame.buffer, sendFrame.size);
}
/**
* @brief Calculate counter distance
* @param [in] sender - counter value from sender
* @param [in] sender - counter value from recipient
* @return distance value
*/
static int calculateDistance(uint16_t sender, uint16_t recipient)
{
sender-= (sender>(MAX_COUNTER_VALUE/2) ? (MAX_COUNTER_VALUE/2) : 0); \
recipient-= (recipient>(MAX_COUNTER_VALUE/2) ? (MAX_COUNTER_VALUE/2) : 0); \
return (int)sender-(int)recipient;
}
/**
* @brief Parse received data
* Parse received data: check command code, control received counter number,
* call right function
* @param [in] data - data buffer
* @param [in] data_len - data size in bytes
* @return FLR_OK if successful else return error
*/
static FLR_RESULT parseData(uint8_t *data, uint32_t data_len)
{
uint32_t data_len_out;
int counter_distance;
if(!data || (data_len < 2))
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
/** parse received data */
receiveFrame.cmd = (data[0] & CMD_MASK)>>6;
receiveFrame.counter = ((uint16_t)(data[0] & COUNTER_MASK)) << 8 | (uint16_t) (data[1]);
if(data_len > 2)
{
receiveFrame.size = data_len - 2;
}
switch(receiveFrame.cmd)
{
case DATA_SEND:
/** calculate counter distance */
counter_distance = calculateDistance(receiveFrame.counter, controller.receive_counter);
/** received previous frame - ACK resend */
if(counter_distance < 0)
{
if(sendAck(receiveFrame.counter) != FLR_OK)
{
DEBUG_ERR("Send ACK error occurred\n");
return FLR_ERROR;
}
return FLR_OK;
}
/** received next frame: save data in buffer, send ACK, increment counter, run callback */
else if(counter_distance == 0)
{
if(fifoWrite(receiveBuffer, &data[2], receiveFrame.size, &data_len_out) != FLR_OK)
{
DEBUG_ERR("Write to receive buffer error occurred\n");
return FLR_ERROR;
}
if(sendAck(receiveFrame.counter) != FLR_OK)
{
DEBUG_ERR("Send ACK error occurred\n");
return FLR_ERROR;
}
controller.receive_counter = (controller.receive_counter+1)%MAX_COUNTER_VALUE;
if(controller.callback != NULL)
{
controller.callback(data_len_out);
}
return FLR_OK;
}
/* synchronization error */
else
{
DEBUG_ERR("Synchronization error - incorrect counter distance [%d]\n", counter_distance);
return FLR_ERROR;
}
case DATA_ACK:
/** compare received counter with send counter if the same increment send counter */
if(receiveFrame.counter == controller.send_counter)
{
controller.send_counter = (controller.send_counter+1)%MAX_COUNTER_VALUE;
controller.state = CONTROLLER_READY;
return FLR_OK;
}
/* synchronization error */
else
{
DEBUG_ERR("Synchronization error\n");
return FLR_ERROR;
}
case COMMUNICATION_RESET_ACK:
controller.state = CONTROLLER_READY;
return FLR_OK;
default:
DEBUG_ERR("Unknown frame status\n");
return FLR_ERROR;
}
}
/******************************************************************************/
/** EXPORTED PUBLIC FUNCTIONS **/
/******************************************************************************/
/******************************************************************************/
FLR_RESULT dataServiceClientInit(void)
{
initController();
receiveBuffer = fifoCreate(DATA_BUFFER_SIZE);
if(receiveBuffer == NULL)
{
DEBUG_ERR("Initialization receive buffer error occurred\n");
return FLR_ERROR;
}
DO_INIT_TRACE("Initialization success\n");
return FLR_OK;
}
/******************************************************************************/
FLR_RESULT dataServiceClientRegisterCallback(receive_callback callback)
{
if(!callback)
{
DEBUG_ERR("Incorrect arguments - null pointer to callback\n");
return FLR_ERROR;
}
controller.callback = callback;
return FLR_OK;
}
/******************************************************************************/
FLR_RESULT dataServiceClientSend(uint8_t* data, uint32_t data_len, uint32_t* data_len_out)
{
uint32_t timeout = 0;
if(!data || !data_len || !data_len_out)
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
*data_len_out = 0;
if(data_len > MAX_PAYLOAD_BYTES - 3)
{
data_len = MAX_PAYLOAD_BYTES - 3;
}
prepareFrame(DATA_SEND, controller.send_counter, data, data_len);
if(sendData(sendFrame.buffer, sendFrame.size) != FLR_OK)
{
DEBUG_ERR("Send data error occurred\n");
return FLR_ERROR;
}
controller.state = CONTROLLER_ACK_WAIT;
/** wait for ACK */
while ((controller.state == CONTROLLER_ACK_WAIT) && (timeout < DATA_SEND_TIMEOUT_MS))
{
timeout++;
mp_hal_delay_ms(1);
}
/** ACK received */
if(controller.state == CONTROLLER_READY)
{
*data_len_out = data_len;
}
/** timeout */
else
{
controller.state = CONTROLLER_READY;
DO_TRACE("Send data timeout\n");
return FLR_COMM_TIMEOUT_ERROR;
}
return FLR_OK;
}
/******************************************************************************/
FLR_RESULT dataServiceClientRead(uint8_t* data, uint32_t data_len, uint32_t* data_len_out)
{
if(!data || !data_len || !data_len_out)
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
if(fifoRead(receiveBuffer, data, data_len, data_len_out) != FLR_OK)
{
DEBUG_ERR("Read from receive buffer error occurred\n");
return FLR_ERROR;
}
return FLR_OK;
}
/******************************************************************************/
FLR_RESULT dataServiceClientReset(void)
{
uint32_t timeout = 0;
prepareFrame(COMMUNICATION_RESET, 0, NULL, 0);
if(sendData(sendFrame.buffer, sendFrame.size) != FLR_OK)
{
DEBUG_ERR("Send data error occurred\n");
return FLR_ERROR;
}
controller.state = CONTROLLER_ACK_WAIT;
while ((controller.state == CONTROLLER_ACK_WAIT) && (timeout < DATA_SEND_TIMEOUT_MS))
{
timeout++;
mp_hal_delay_ms(1);
}
if(controller.state == CONTROLLER_READY)
{
resetController();
}
else
{
controller.state = CONTROLLER_READY;
DO_TRACE("Send data timeout\n");
return FLR_COMM_TIMEOUT_ERROR;
}
return FLR_OK;
}
/******************************************************************************/
int32_t dataServiceClientReceive(uint32_t receiveBytes, const uint8_t* receiveData)
{
uint8_t fslpData[MAX_PAYLOAD_BYTES];
uint32_t fslpDataSize = 0;
if (!receiveData || (receiveBytes < 2))
{
DEBUG_ERR("Incorrect arguments\n");
return -1;
}
ReadFrame(DATA_SERVICE_NUMBER, &fslpDataSize, fslpData);
DO_TRACE("Received data %d bytes: [0x%02x | 0x%02x ...]\n",
fslpDataSize, fslpData[0], fslpData[1]);
if(parseData(fslpData, fslpDataSize) != FLR_OK)
{
DEBUG_ERR("Parse data error occurred\n");
return -1;
}
return 0;
}

View File

@ -0,0 +1,179 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
/**
* @file fifo.c
* @author Artur Tynecki
* @date May, 2017
* @brief FIFO implementation source file
*
*/
/******************************************************************************/
/** INCLUDE FILES **/
/******************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "fifo.h"
/******************************************************************************/
/** EXPORTED DEFINES **/
/******************************************************************************/
#define DO_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DO_INIT_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DO_DATA_SERVICE_TRACE(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DEBUG_ERR(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define DEBUG_WARN(s, ...) //printf("%s: " s, __FUNCTION__, __VA_ARGS__)
#define MIN(a,b) ((a) < (b) ? (a) : (b))
/******************************************************************************/
/** EXPORTED PUBLIC FUNCTIONS **/
/******************************************************************************/
/******************************************************************************/
fifo_p fifoCreate(uint32_t size)
{
fifo_p fifo;
if(size < 1)
{
DEBUG_ERR("Incorrect argument - buffer size smaller than 1\n");
return NULL;
}
fifo = malloc(sizeof(fifo_t));
if(!fifo)
{
DEBUG_ERR("Fifo structure memory allocation error occurred\n");
return NULL;
}
fifo->head = fifo->tail = fifo->length = 0;
fifo->buffer = malloc(size * sizeof(uint8_t));
if(!fifo->buffer)
{
free(fifo);
DEBUG_ERR("Fifo buffer memory allocation error occurred\n");
return NULL;
}
fifo->size = size;
memset(fifo->buffer, 0, size);
return fifo;
}
/******************************************************************************/
void fifoDestroy(fifo_p fifo)
{
if(!fifo)
{
free(fifo->buffer);
free(fifo);
}
}
/******************************************************************************/
FLR_RESULT fifoWrite(fifo_p fifo, uint8_t* data, uint32_t data_len, uint32_t* data_len_out)
{
uint32_t part;
int ret = 0;
if(!fifo || !data || !data_len || !data_len_out)
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
/** check buffer is full */
if(fifo->length == fifo->size)
{
*data_len_out = 0;
return FLR_OK;
}
/* set possible data length to write */
data_len = MIN(data_len, (fifo->size - fifo->length));
*data_len_out = data_len;
/* set data from head to buffer end or tail */
part = MIN(data_len, fifo->size - fifo->head);
memcpy(&fifo->buffer[fifo->head], data, part);
fifo->head += part;
/* set data from buffer beginning if it is necessary */
if(part < data_len)
{
memcpy(fifo->buffer, data + part, data_len - part);
fifo->head = data_len - part;
}
if(fifo->head == fifo->size)
{
fifo->head = 0;
}
/* update buffer length */
fifo->length+=data_len;
return FLR_OK;
}
/******************************************************************************/
FLR_RESULT fifoRead(fifo_p fifo, uint8_t* data, uint32_t data_len, uint32_t* data_len_out)
{
uint32_t part;
int ret = 0;
if(!fifo || !data || !data_len || !data_len_out)
{
DEBUG_ERR("Incorrect arguments\n");
return FLR_ERROR;
}
/** check buffer is empty */
if(fifo->length == 0)
{
*data_len_out = 0;
return FLR_OK;
}
/* set possible data length to read */
data_len = MIN(data_len, fifo->length);
*data_len_out = data_len;
/* get data from tail to buffer end or head */
part = MIN(data_len, fifo->size - fifo->tail);
memcpy(data, &fifo->buffer[fifo->tail], part);
fifo->tail += part;
/* get data from buffer beginning if it is necessary */
if(part < data_len)
{
memcpy(&data[part], fifo->buffer, data_len - part);
fifo->tail = data_len - part;
}
if(fifo->tail == fifo->size)
{
fifo->tail = 0;
}
/* update buffer length */
fifo->length-=data_len;
return FLR_OK;
}

View File

@ -0,0 +1,139 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "flirCRC.h"
static const uint16_t ccitt_16Table[] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};
#define _FAST
#ifdef _FAST
//
// ===== calcFlirByteCRC16 ===== FAST
// Calculate (update) the CRC16 for a single 8-bit byte
//
int calcFlirByteCRC16(int value, int crcin)
{
return (unsigned short)((crcin << 8) ^ ccitt_16Table[((crcin >> 8) ^ (value)) & 255]);
}
#else
//
// ===== calcFlirByteCRC16 ===== SLOW
// Calculate (update) the CRC16 for a single 8-bit byte
//
int calcFlirByteCRC16(int value, int crcin)
{
int k = (((crcin >> 8) ^ value) & 255) << 8;
int crc = 0;
int bits = 8;
do
{
if ( ( crc ^ k ) & 0x8000 )
crc = (crc << 1) ^ 0x1021;
else
crc <<= 1;
k <<= 1;
}
while ( --bits );
return ((crcin << 8) ^ crc);
}
#endif
#define _LITTLE_ENDIAN 0
#define _BIG_ENDIAN 1
//
// ===== CalcCRC16Words =====
// Calculate the CRC for a buffer of 16-bit words. Supports both
// Little and Big Endian formats using conditional compilation.
// Note: minimum count is 1 (0 case not handled)
//
uint16_t calcFlirCRC16Words(unsigned int count, short *buffer)
{
int crc = FLIR_CRC_INITIAL_VALUE;
int endian = _LITTLE_ENDIAN;
do
{
int value = *buffer++;
if ( endian == _BIG_ENDIAN )
{
crc = calcFlirByteCRC16(value >> 8, crc);
crc = calcFlirByteCRC16(value, crc);
}
else
{
crc = calcFlirByteCRC16(value, crc);
crc = calcFlirByteCRC16(value >> 8, crc);
}
}
while ( --count );
return (uint16_t) crc;
}
//
// ===== CalcCRC16Bytes =====
// Calculate the CRC for a buffer of 8-bit words.
// Note: minimum count is 1 (0 case not handled)
//
uint16_t calcFlirCRC16Bytes(unsigned int count, uint8_t *buffer)
{
int crc = FLIR_CRC_INITIAL_VALUE;
do
{
int value = *buffer++;
crc = calcFlirByteCRC16(value, crc);
}
while ( --count );
return (uint16_t) crc;
}

View File

@ -0,0 +1,75 @@
/******************************************************************************/
/* */
/* Copyright (C) 2018, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "flirChannels.h"
static uint8_t is_initialized = 0;
int32_t get_channel(uint8_t channel_ID, CHANNEL_T **return_channel){
int i;
for (i = 1; i < NUM_CHANNELS; i++){
if (channel_ID == channel_list[i].channel) {
*return_channel = &(channel_list[i]);
return 0;
}
}
*return_channel = 0;
return -1;
}
void get_unframed(CHANNEL_T **return_channel){
*return_channel = &(channel_list[0]);
return;
}
void add_byte(uint8_t inbyte,CHANNEL_T *channel_ptr){
uint32_t index;
uint16_t start = (channel_ptr->start);
if (channel_ptr->len != CHANNEL_BUF_SIZ){
index = start + (channel_ptr->len);
(channel_ptr->buff)[index] = inbyte;
(channel_ptr->len)++;
} else {
(channel_ptr->buff)[start] = inbyte;
(channel_ptr->start) = (start + 1)%CHANNEL_BUF_SIZ;
}
}
int32_t get_byte(uint8_t *outbyte,CHANNEL_T *channel_ptr){
//return remaining length if success, -1 if channel already empty
if (channel_ptr->len == 0) {
return -1;
} else {
*outbyte = (channel_ptr->buff)[(channel_ptr->start)];
(channel_ptr->start)++;
return --(channel_ptr->len);
}
}
void initialize_channels(){
if (is_initialized==0) {
CHANNEL_INIT(0, 0x00); // unframed "channel" always slot 0
CHANNEL_INIT(1, 0x00); // command channel
CHANNEL_INIT(2, 0x99); // "0x99" debug channel
CHANNEL_INIT(3, 0x63); // "99" alt debug channel
CHANNEL_INIT(4, 0xaa); // "0xaa" Uart Pass Through channel
CHANNEL_INIT(5, 0x01); // "1" Data channel
CHANNEL_INIT(6, SERVICE_UNRELATED_CHANNEL_ID); /*
* all-in - allows for framed reads of whatever has
* collected in the port (unrelated to any service)
*/
is_initialized = 1;
}
}

View File

@ -0,0 +1,110 @@
/*
* Copyright (C) 2023-2024 OpenMV, LLC.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Any redistribution, use, or modification in source or binary form
* is done solely for personal benefit and not for any commercial
* purpose or for monetary gain. For commercial licensing options,
* please contact openmv@openmv.io
*
* THIS SOFTWARE IS PROVIDED BY THE LICENSOR AND COPYRIGHT OWNER "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR OR COPYRIGHT
* OWNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* I2C to UART bridge register definitions.
*/
#include "serialPortAdapter.h"
#include "py/mphal.h"
#include "omv_csi.h"
#include "sc16is741a.h"
static uint8_t read_reg(uint8_t addr){
uint8_t buf;
omv_i2c_write_bytes(&csi.i2c_bus, csi.slv_addr, &addr, 1, OMV_I2C_XFER_NO_STOP);
omv_i2c_read_bytes(&csi.i2c_bus, csi.slv_addr, &buf, 1, OMV_I2C_XFER_NO_FLAGS);
return buf;
}
static void write_reg(uint8_t addr, uint8_t data) {
uint8_t buf[] = {addr, data};
omv_i2c_write_bytes(&csi.i2c_bus, csi.slv_addr, buf, 2, OMV_I2C_XFER_NO_FLAGS);
}
uint8_t FSLP_open_port() {
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_UARTRST, 0), SC16IS741A_UARTRST);
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_FCR, 0), SC16IS741A_FCR_ENABLE_FIFO);
// Set a baud rate of 921600 (14,745,600 / 16 / 1)
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_LCR, 0), SC16IS741A_LCR_ENABLE_LATCH);
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_DLH, 0), 0x00);
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_DLL, 0), 0x01);
// Set 8, N, 1.
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_LCR, 0), SC16IS741A_LCR_WORD_SZ_8);
return 0;
}
void FSLP_close_port() {
}
// Return type is int16_t, so that the full uint8_t value can be represented
// without overlapping with negative error codes.
int16_t FSLP_read_byte_with_timeout(double timeout)
{
int32_t timeout_ms = (int32_t) (timeout*1000);
uint32_t start_ms = mp_hal_ticks_ms();
while (!read_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_RXLVL, 0))) {
if ((mp_hal_ticks_ms() - start_ms) > timeout_ms) {
return -1;
}
}
return read_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_RHR, 0));
}
void FSLP_flush_write_buffer() {
}
int32_t FSLP_write_buffer(uint8_t *frame_buf, int32_t len) {
uint32_t start_ms = mp_hal_ticks_ms();
for (int32_t i = 0; i < len; ) {
if ((mp_hal_ticks_ms() - start_ms) > 1000) {
return i;
}
int32_t bytes_left = len - i;
int32_t space_avail = read_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_TXLVL, 0));
int32_t byte_to_write = (bytes_left < space_avail) ? bytes_left : space_avail;
for (int32_t j = 0; j < byte_to_write; j++) {
write_reg(SC16IS741A_SUB_ADDR(SC16IS741A_REG_THR, 0), frame_buf[i+j]);
}
i += byte_to_write;
}
return len;
}

View File

@ -0,0 +1,37 @@
/******************************************************************************/
/* */
/* Copyright (C) 2017, FLIR Systems */
/* All rights reserved. */
/* */
/* This document is controlled to FLIR Technology Level 2. The information */
/* contained in this document pertains to a dual use product controlled for */
/* export by the Export Administration Regulations (EAR). Diversion contrary */
/* to US law is prohibited. US Department of Commerce authorization is not */
/* required prior to export or transfer to foreign persons or parties unless */
/* otherwise prohibited. */
/* */
/******************************************************************************/
#include "timeoutLogic.h"
#include "py/mphal.h"
int clock_gettime(int _ignore, struct timespec *spec)
{
uint32_t time_ms = mp_hal_ticks_ms();
spec->tv_sec = time_ms / 1000L;
spec->tv_nsec = time_ms % 1000L * 1000000;
return 0;
}
double difftime(long current, long reference)
{
return ((double)current - (double)reference);
}
double diff_timespec(struct timespec *current, struct timespec *reference)
{
double elapsed_sec = difftime(current->tv_sec, reference->tv_sec);
elapsed_sec += (((double)current->tv_nsec) - ((double)reference->tv_nsec))/1000000000;
return elapsed_sec;
}