mirror of
https://github.com/openmv/openmv.git
synced 2025-11-04 14:49:50 +08:00
drivers/boson: Add FLIR Boson IDD 4 Driver.
This commit is contained in:
parent
19ec8b127a
commit
58e362f2f2
BIN
src/drivers/boson/LICENSE.pdf
Normal file
BIN
src/drivers/boson/LICENSE.pdf
Normal file
Binary file not shown.
48
src/drivers/boson/Makefile
Normal file
48
src/drivers/boson/Makefile
Normal 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)
|
||||
3
src/drivers/boson/VERSION
Normal file
3
src/drivers/boson/VERSION
Normal file
@ -0,0 +1,3 @@
|
||||
patch_version = 27648
|
||||
code_branch = ^/Components//tags/BOSON_R4.1_RC01_1
|
||||
project_name = Boson
|
||||
850
src/drivers/boson/include/Client_API.h
Normal file
850
src/drivers/boson/include/Client_API.h
Normal 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
|
||||
33
src/drivers/boson/include/Client_Dispatcher.h
Normal file
33
src/drivers/boson/include/Client_Dispatcher.h
Normal 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
|
||||
28
src/drivers/boson/include/Client_Interface.h
Normal file
28
src/drivers/boson/include/Client_Interface.h
Normal 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
|
||||
959
src/drivers/boson/include/Client_Packager.h
Normal file
959
src/drivers/boson/include/Client_Packager.h
Normal 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
|
||||
|
||||
720
src/drivers/boson/include/EnumTypes.h
Normal file
720
src/drivers/boson/include/EnumTypes.h
Normal 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
|
||||
28
src/drivers/boson/include/FSLP.h
Normal file
28
src/drivers/boson/include/FSLP.h
Normal 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
|
||||
882
src/drivers/boson/include/FunctionCodes.h
Normal file
882
src/drivers/boson/include/FunctionCodes.h
Normal 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
|
||||
29
src/drivers/boson/include/I2C_Connector.h
Normal file
29
src/drivers/boson/include/I2C_Connector.h
Normal 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
|
||||
35
src/drivers/boson/include/MultiServiceSupport.h
Normal file
35
src/drivers/boson/include/MultiServiceSupport.h
Normal 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
|
||||
122
src/drivers/boson/include/ReturnCodes.h
Normal file
122
src/drivers/boson/include/ReturnCodes.h
Normal 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
|
||||
61
src/drivers/boson/include/Serializer_BuiltIn.h
Normal file
61
src/drivers/boson/include/Serializer_BuiltIn.h
Normal 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
|
||||
462
src/drivers/boson/include/Serializer_Struct.h
Normal file
462
src/drivers/boson/include/Serializer_Struct.h
Normal 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
|
||||
29
src/drivers/boson/include/UART_Connector.h
Normal file
29
src/drivers/boson/include/UART_Connector.h
Normal 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
|
||||
39
src/drivers/boson/include/UPTClient.h
Normal file
39
src/drivers/boson/include/UPTClient.h
Normal 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
|
||||
164
src/drivers/boson/include/dataServiceClient.h
Normal file
164
src/drivers/boson/include/dataServiceClient.h
Normal 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
|
||||
95
src/drivers/boson/include/fifo.h
Normal file
95
src/drivers/boson/include/fifo.h
Normal 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_
|
||||
25
src/drivers/boson/include/flirCRC.h
Normal file
25
src/drivers/boson/include/flirCRC.h
Normal 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_
|
||||
84
src/drivers/boson/include/flirChannels.h
Normal file
84
src/drivers/boson/include/flirChannels.h
Normal 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
|
||||
78
src/drivers/boson/include/sc16is741a.h
Normal file
78
src/drivers/boson/include/sc16is741a.h
Normal 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
|
||||
39
src/drivers/boson/include/serialPortAdapter.h
Normal file
39
src/drivers/boson/include/serialPortAdapter.h
Normal 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
|
||||
25
src/drivers/boson/include/timeoutLogic.h
Normal file
25
src/drivers/boson/include/timeoutLogic.h
Normal 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
|
||||
7413
src/drivers/boson/src/Client_API.c
Normal file
7413
src/drivers/boson/src/Client_API.c
Normal file
File diff suppressed because it is too large
Load Diff
160
src/drivers/boson/src/Client_Dispatcher.c
Normal file
160
src/drivers/boson/src/Client_Dispatcher.c
Normal 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;
|
||||
}
|
||||
53
src/drivers/boson/src/Client_Interface.c
Normal file
53
src/drivers/boson/src/Client_Interface.c
Normal 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;
|
||||
}
|
||||
30495
src/drivers/boson/src/Client_Packager.c
Normal file
30495
src/drivers/boson/src/Client_Packager.c
Normal file
File diff suppressed because it is too large
Load Diff
742
src/drivers/boson/src/FSLP.c
Normal file
742
src/drivers/boson/src/FSLP.c
Normal 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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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, ¤t_t);
|
||||
elapsed_sec = diff_timespec(¤t_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;
|
||||
}
|
||||
107
src/drivers/boson/src/I2C_Connector.c
Normal file
107
src/drivers/boson/src/I2C_Connector.c
Normal 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;
|
||||
}
|
||||
68
src/drivers/boson/src/MultiServiceSupport.c
Normal file
68
src/drivers/boson/src/MultiServiceSupport.c
Normal 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;
|
||||
}
|
||||
257
src/drivers/boson/src/Serializer_BuiltIn.c
Normal file
257
src/drivers/boson/src/Serializer_BuiltIn.c
Normal 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));
|
||||
}
|
||||
}
|
||||
2126
src/drivers/boson/src/Serializer_Struct.c
Normal file
2126
src/drivers/boson/src/Serializer_Struct.c
Normal file
File diff suppressed because it is too large
Load Diff
59
src/drivers/boson/src/UART_Connector.c
Normal file
59
src/drivers/boson/src/UART_Connector.c
Normal 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);
|
||||
}
|
||||
50
src/drivers/boson/src/UPTClient.c
Normal file
50
src/drivers/boson/src/UPTClient.c
Normal 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;
|
||||
}
|
||||
428
src/drivers/boson/src/dataServiceClient.c
Normal file
428
src/drivers/boson/src/dataServiceClient.c
Normal 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;
|
||||
}
|
||||
179
src/drivers/boson/src/fifo.c
Normal file
179
src/drivers/boson/src/fifo.c
Normal 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;
|
||||
}
|
||||
139
src/drivers/boson/src/flirCRC.c
Normal file
139
src/drivers/boson/src/flirCRC.c
Normal 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;
|
||||
}
|
||||
75
src/drivers/boson/src/flirChannels.c
Normal file
75
src/drivers/boson/src/flirChannels.c
Normal 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;
|
||||
}
|
||||
}
|
||||
110
src/drivers/boson/src/serialPortAdapter.c
Normal file
110
src/drivers/boson/src/serialPortAdapter.c
Normal 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;
|
||||
}
|
||||
37
src/drivers/boson/src/timeoutLogic.c
Normal file
37
src/drivers/boson/src/timeoutLogic.c
Normal 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;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user