diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_high_temp.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_high_temp.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_high_temp.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_high_temp.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_color.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_color.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_color.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_color.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_color_lcd.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_color_lcd.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_color_lcd.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_color_lcd.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_lcd.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_lcd.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_get_object_temp_lcd.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_get_object_temp_lcd.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking_lcd.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking_lcd.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking_lcd.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_grayscale_color_tracking_lcd.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking_lcd.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking_lcd.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking_lcd.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_hotspot_rgb565_color_tracking_lcd.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_target_temp_hotspot_grayscale_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_target_temp_hotspot_grayscale_color_tracking.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_target_temp_hotspot_grayscale_color_tracking.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_target_temp_hotspot_grayscale_color_tracking.py diff --git a/scripts/examples/01-Camera/05-FLIR-Lepton/lepton_target_temp_hotspot_rgb565_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_target_temp_hotspot_rgb565_color_tracking.py similarity index 100% rename from scripts/examples/01-Camera/05-FLIR-Lepton/lepton_target_temp_hotspot_rgb565_color_tracking.py rename to scripts/examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton/lepton_target_temp_hotspot_rgb565_color_tracking.py diff --git a/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_color_tracking.py new file mode 100644 index 000000000..049b1b2f9 --- /dev/null +++ b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_color_tracking.py @@ -0,0 +1,33 @@ +# This work is licensed under the MIT license. +# Copyright (c) 2013-2024 OpenMV LLC. All rights reserved. +# https://github.com/openmv/openmv/blob/master/LICENSE +# +# Single Color Grayscale Blob Tracking Example +# +# This example shows off single color grayscale tracking using the OpenMV Cam using the FLIR Boson. + +import sensor +import time + +# Color Tracking Thresholds (Grayscale Min, Grayscale Max) +threshold_list = [(220, 255)] + +sensor.reset() +sensor.set_pixformat(sensor.GRAYSCALE) +sensor.set_framesize(sensor.VGA) +sensor.skip_frames(time=5000) +clock = time.clock() + +# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are +# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the +# camera resolution. "merge=True" merges all overlapping blobs in the image. + +while True: + clock.tick() + img = sensor.snapshot() + for blob in img.find_blobs( + threshold_list, pixels_threshold=200, area_threshold=200, merge=True + ): + img.draw_rectangle(blob.rect(), color=127) + img.draw_cross(blob.cx(), blob.cy(), color=127) + print(clock.fps()) diff --git a/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_streaming.py b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_streaming.py new file mode 100644 index 000000000..ea3617f13 --- /dev/null +++ b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/grayscale_streaming.py @@ -0,0 +1,21 @@ +# This work is licensed under the MIT license. +# Copyright (c) 2013-2024 OpenMV LLC. All rights reserved. +# https://github.com/openmv/openmv/blob/master/LICENSE +# +# This example shows off streaming the default grayscale 8-bit AGC image from the FLIR Boson. + +import sensor +import time + +sensor.reset() +sensor.set_pixformat(sensor.GRAYSCALE) # Must always be grayscale. +sensor.set_framesize(sensor.VGA) # Must always be VGA or QVGA. + +clock = time.clock() + +while True: + clock.tick() + + img = sensor.snapshot() + + print(clock.fps()) diff --git a/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_color_tracking.py b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_color_tracking.py new file mode 100644 index 000000000..0a90bb73b --- /dev/null +++ b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_color_tracking.py @@ -0,0 +1,35 @@ +# This work is licensed under the MIT license. +# Copyright (c) 2013-2024 OpenMV LLC. All rights reserved. +# https://github.com/openmv/openmv/blob/master/LICENSE +# +# Single Color RGB565 Blob Tracking Example +# +# This example shows off single color RGB565 tracking using the OpenMV Cam using the FLIR BOSON. + +import sensor +import time +import image + +# Color Tracking Thresholds (L Min, L Max, A Min, A Max, B Min, B Max) +threshold_list = [(70, 100, -30, 40, 20, 100)] + +sensor.reset() +sensor.set_pixformat(sensor.GRAYSCALE) +sensor.set_framesize(sensor.VGA) +sensor.set_color_palette(image.PALETTE_IRONBOW) +sensor.skip_frames(time=5000) +clock = time.clock() + +# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are +# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the +# camera resolution. "merge=True" merges all overlapping blobs in the image. + +while True: + clock.tick() + img = sensor.snapshot() + for blob in img.find_blobs( + threshold_list, pixels_threshold=200, area_threshold=200, merge=True + ): + img.draw_rectangle(blob.rect()) + img.draw_cross(blob.cx(), blob.cy()) + print(clock.fps()) diff --git a/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_streaming.py b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_streaming.py new file mode 100644 index 000000000..2db230d15 --- /dev/null +++ b/scripts/examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson/ironbow_streaming.py @@ -0,0 +1,23 @@ +# This work is licensed under the MIT license. +# Copyright (c) 2013-2024 OpenMV LLC. All rights reserved. +# https://github.com/openmv/openmv/blob/master/LICENSE +# +# This example shows off streaming an ironbow image from the FLIR Boson. + +import sensor +import time +import image + +sensor.reset() +sensor.set_pixformat(sensor.GRAYSCALE) # Must always be grayscale. +sensor.set_framesize(sensor.VGA) # Must always be VGA or QVGA. +sensor.set_color_palette(image.PALETTE_IRONBOW) + +clock = time.clock() + +while True: + clock.tick() + + img = sensor.snapshot() + + print(clock.fps()) diff --git a/scripts/examples/index.csv b/scripts/examples/index.csv index 501b2e517..a51557150 100644 --- a/scripts/examples/index.csv +++ b/scripts/examples/index.csv @@ -7,7 +7,8 @@ "examples/01-Camera/03-Event-Cameras/01-Frogeye2020", ".+", "(FROGEYE2020)", "" "examples/01-Camera/03-Event-Cameras/02-Genx320", ".+", "(GENX320)", "" "examples/01-Camera/04-Global-Shutter", ".+", "(MT9V0X2|MT9V0X2-C|MT9V0X4|MT9V0X4-C)", "" -"examples/01-Camera/05-FLIR-Lepton", ".+", "(LEPTON|LEPTON-1.5|LEPTON-1.6|LEPTON-2.0|LEPTON-2.5|LEPTON-3.0|LEPTON-3.5)", "" +"examples/01-Camera/05-Thermal-Cameras/01-FLIR-Lepton", ".+", "(LEPTON|LEPTON-1.5|LEPTON-1.6|LEPTON-2.0|LEPTON-2.5|LEPTON-3.0|LEPTON-3.5)", "" +"examples/01-Camera/05-Thermal-Cameras/02-FLIR-Boson", ".+", "(BOSON|BOSON-320|BOSON-640)", "" "examples/01-Camera/06-Time-of-Flight", ".+", "^(?!None).*$", "" "examples/01-Camera/07-Sensor-Control", ".+", "^(?!None).*$", "" "examples/01-Camera/08-Readout-Control", ".+", "^(?!None).*$", "" diff --git a/src/Makefile b/src/Makefile index a616b68af..d5eb90e3c 100755 --- a/src/Makefile +++ b/src/Makefile @@ -56,6 +56,7 @@ CUBEAI_DIR=stm32cubeai CMSIS_DIR=hal/cmsis MICROPY_DIR=micropython GENX320_DIR=drivers/genx320 +BOSON_DIR=drivers/boson LEPTON_DIR=drivers/lepton LSM6DS3_DIR=drivers/lsm6ds3 LSM6DSM_DIR=drivers/lsm6dsm diff --git a/src/drivers/boson/LICENSE.pdf b/src/drivers/boson/LICENSE.pdf new file mode 100644 index 000000000..c609ae00a Binary files /dev/null and b/src/drivers/boson/LICENSE.pdf differ diff --git a/src/drivers/boson/Makefile b/src/drivers/boson/Makefile new file mode 100644 index 000000000..c4d93701a --- /dev/null +++ b/src/drivers/boson/Makefile @@ -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) diff --git a/src/drivers/boson/VERSION b/src/drivers/boson/VERSION new file mode 100644 index 000000000..a08d3b2fe --- /dev/null +++ b/src/drivers/boson/VERSION @@ -0,0 +1,3 @@ +patch_version = 27648 +code_branch = ^/Components//tags/BOSON_R4.1_RC01_1 +project_name = Boson diff --git a/src/drivers/boson/include/Client_API.h b/src/drivers/boson/include/Client_API.h new file mode 100644 index 000000000..eb9ab4b3e --- /dev/null +++ b/src/drivers/boson/include/Client_API.h @@ -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 +#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 diff --git a/src/drivers/boson/include/Client_Dispatcher.h b/src/drivers/boson/include/Client_Dispatcher.h new file mode 100644 index 000000000..abd384856 --- /dev/null +++ b/src/drivers/boson/include/Client_Dispatcher.h @@ -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 +#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 diff --git a/src/drivers/boson/include/Client_Interface.h b/src/drivers/boson/include/Client_Interface.h new file mode 100644 index 000000000..c897ebc67 --- /dev/null +++ b/src/drivers/boson/include/Client_Interface.h @@ -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 +#include +#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 diff --git a/src/drivers/boson/include/Client_Packager.h b/src/drivers/boson/include/Client_Packager.h new file mode 100644 index 000000000..42f4b419b --- /dev/null +++ b/src/drivers/boson/include/Client_Packager.h @@ -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 +#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 + diff --git a/src/drivers/boson/include/EnumTypes.h b/src/drivers/boson/include/EnumTypes.h new file mode 100644 index 000000000..2df5fe6c1 --- /dev/null +++ b/src/drivers/boson/include/EnumTypes.h @@ -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 + + +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 diff --git a/src/drivers/boson/include/FSLP.h b/src/drivers/boson/include/FSLP.h new file mode 100644 index 000000000..48f8c8fb2 --- /dev/null +++ b/src/drivers/boson/include/FSLP.h @@ -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 + +#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 diff --git a/src/drivers/boson/include/FunctionCodes.h b/src/drivers/boson/include/FunctionCodes.h new file mode 100644 index 000000000..8cfa61d5b --- /dev/null +++ b/src/drivers/boson/include/FunctionCodes.h @@ -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 diff --git a/src/drivers/boson/include/I2C_Connector.h b/src/drivers/boson/include/I2C_Connector.h new file mode 100644 index 000000000..55cd0e488 --- /dev/null +++ b/src/drivers/boson/include/I2C_Connector.h @@ -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 +#include "ReturnCodes.h" +#include + +#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 diff --git a/src/drivers/boson/include/MultiServiceSupport.h b/src/drivers/boson/include/MultiServiceSupport.h new file mode 100644 index 000000000..289a5df47 --- /dev/null +++ b/src/drivers/boson/include/MultiServiceSupport.h @@ -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 +#include +#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 diff --git a/src/drivers/boson/include/ReturnCodes.h b/src/drivers/boson/include/ReturnCodes.h new file mode 100644 index 000000000..0ae6bb5ca --- /dev/null +++ b/src/drivers/boson/include/ReturnCodes.h @@ -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 diff --git a/src/drivers/boson/include/Serializer_BuiltIn.h b/src/drivers/boson/include/Serializer_BuiltIn.h new file mode 100644 index 000000000..4cee9999c --- /dev/null +++ b/src/drivers/boson/include/Serializer_BuiltIn.h @@ -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 + +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 \ No newline at end of file diff --git a/src/drivers/boson/include/Serializer_Struct.h b/src/drivers/boson/include/Serializer_Struct.h new file mode 100644 index 000000000..195d197b7 --- /dev/null +++ b/src/drivers/boson/include/Serializer_Struct.h @@ -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 +#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 diff --git a/src/drivers/boson/include/UART_Connector.h b/src/drivers/boson/include/UART_Connector.h new file mode 100644 index 000000000..2c982a2b3 --- /dev/null +++ b/src/drivers/boson/include/UART_Connector.h @@ -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 +#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 diff --git a/src/drivers/boson/include/UPTClient.h b/src/drivers/boson/include/UPTClient.h new file mode 100644 index 000000000..f5ae5ec91 --- /dev/null +++ b/src/drivers/boson/include/UPTClient.h @@ -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 +#include +#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 diff --git a/src/drivers/boson/include/dataServiceClient.h b/src/drivers/boson/include/dataServiceClient.h new file mode 100644 index 000000000..80bc50145 --- /dev/null +++ b/src/drivers/boson/include/dataServiceClient.h @@ -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 +#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 diff --git a/src/drivers/boson/include/fifo.h b/src/drivers/boson/include/fifo.h new file mode 100644 index 000000000..6cfb9d56f --- /dev/null +++ b/src/drivers/boson/include/fifo.h @@ -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 +#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_ diff --git a/src/drivers/boson/include/flirCRC.h b/src/drivers/boson/include/flirCRC.h new file mode 100644 index 000000000..1d75b2710 --- /dev/null +++ b/src/drivers/boson/include/flirCRC.h @@ -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 + +#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_ diff --git a/src/drivers/boson/include/flirChannels.h b/src/drivers/boson/include/flirChannels.h new file mode 100644 index 000000000..3b4f1f836 --- /dev/null +++ b/src/drivers/boson/include/flirChannels.h @@ -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 +#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 diff --git a/src/drivers/boson/include/sc16is741a.h b/src/drivers/boson/include/sc16is741a.h new file mode 100644 index 000000000..3333373b7 --- /dev/null +++ b/src/drivers/boson/include/sc16is741a.h @@ -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 diff --git a/src/drivers/boson/include/serialPortAdapter.h b/src/drivers/boson/include/serialPortAdapter.h new file mode 100644 index 000000000..af439873e --- /dev/null +++ b/src/drivers/boson/include/serialPortAdapter.h @@ -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 +#include + +// 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 diff --git a/src/drivers/boson/include/timeoutLogic.h b/src/drivers/boson/include/timeoutLogic.h new file mode 100644 index 000000000..b10ef66a1 --- /dev/null +++ b/src/drivers/boson/include/timeoutLogic.h @@ -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 diff --git a/src/drivers/boson/src/Client_API.c b/src/drivers/boson/src/Client_API.c new file mode 100644 index 000000000..af8437ab0 --- /dev/null +++ b/src/drivers/boson/src/Client_API.c @@ -0,0 +1,7413 @@ +// ///////////////////////////////////////////////////// +// // 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_API.h" + +static const uint16_t MaxMemoryChunk = 256; + +FLR_RESULT TLinearSetControl(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTlinearSetControl(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetControl() + +FLR_RESULT TLinearGetControl(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTlinearGetControl(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetControl() + +FLR_RESULT TLinearGetLUT(const FLR_BOSON_TABLETYPE_E mode, const uint16_t offset, float a[], float b[]){ + FLR_RESULT returncode = CLIENT_pkgTlinearGetLUT(mode, offset, a, b); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLUT() + +FLR_RESULT TLinearRefreshLUT(const FLR_BOSON_TABLETYPE_E mode){ + FLR_RESULT returncode = CLIENT_pkgTlinearRefreshLUT(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of RefreshLUT() + +FLR_RESULT agcSetPercentPerBin(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetPercentPerBin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPercentPerBin() + +FLR_RESULT agcGetPercentPerBin(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetPercentPerBin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPercentPerBin() + +FLR_RESULT agcSetLinearPercent(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetLinearPercent(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLinearPercent() + +FLR_RESULT agcGetLinearPercent(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetLinearPercent(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLinearPercent() + +FLR_RESULT agcSetOutlierCut(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetOutlierCut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutlierCut() + +FLR_RESULT agcGetOutlierCut(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetOutlierCut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutlierCut() + +FLR_RESULT agcGetDrOut(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetDrOut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDrOut() + +FLR_RESULT agcSetMaxGain(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetMaxGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxGain() + +FLR_RESULT agcGetMaxGain(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetMaxGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxGain() + +FLR_RESULT agcSetdf(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetdf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Setdf() + +FLR_RESULT agcGetdf(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetdf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Getdf() + +FLR_RESULT agcSetGamma(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetGamma(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGamma() + +FLR_RESULT agcGetGamma(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetGamma(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGamma() + +FLR_RESULT agcGetFirstBin(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetFirstBin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFirstBin() + +FLR_RESULT agcGetLastBin(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetLastBin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastBin() + +FLR_RESULT agcSetDetailHeadroom(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetDetailHeadroom(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDetailHeadroom() + +FLR_RESULT agcGetDetailHeadroom(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetDetailHeadroom(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDetailHeadroom() + +FLR_RESULT agcSetd2br(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetd2br(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Setd2br() + +FLR_RESULT agcGetd2br(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetd2br(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Getd2br() + +FLR_RESULT agcSetSigmaR(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetSigmaR(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSigmaR() + +FLR_RESULT agcGetSigmaR(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetSigmaR(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSigmaR() + +FLR_RESULT agcSetUseEntropy(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetUseEntropy(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetUseEntropy() + +FLR_RESULT agcGetUseEntropy(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetUseEntropy(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUseEntropy() + +FLR_RESULT agcSetROI(const FLR_ROI_T roi){ + FLR_RESULT returncode = CLIENT_pkgAgcSetROI(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetROI() + +FLR_RESULT agcGetROI(FLR_ROI_T *roi){ + FLR_RESULT returncode = CLIENT_pkgAgcGetROI(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetROI() + +FLR_RESULT agcGetMaxGainApplied(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetMaxGainApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxGainApplied() + +FLR_RESULT agcGetSigmaRApplied(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetSigmaRApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSigmaRApplied() + +FLR_RESULT agcSetOutlierCutBalance(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetOutlierCutBalance(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutlierCutBalance() + +FLR_RESULT agcGetOutlierCutBalance(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetOutlierCutBalance(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutlierCutBalance() + +FLR_RESULT agcGetOutlierCutApplied(float *percentHigh, float *percentLow){ + FLR_RESULT returncode = CLIENT_pkgAgcGetOutlierCutApplied(percentHigh, percentLow); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutlierCutApplied() + +FLR_RESULT agcSetDetailHeadroomBalance(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetDetailHeadroomBalance(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDetailHeadroomBalance() + +FLR_RESULT agcGetDetailHeadroomBalance(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetDetailHeadroomBalance(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDetailHeadroomBalance() + +FLR_RESULT agcGetDetailHeadroomApplied(float *countsHigh, float *countsLow){ + FLR_RESULT returncode = CLIENT_pkgAgcGetDetailHeadroomApplied(countsHigh, countsLow); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDetailHeadroomApplied() + +FLR_RESULT agcGetTfThresholds(uint16_t *tf_thresholdMin, uint16_t *tf_thresholdMax){ + FLR_RESULT returncode = CLIENT_pkgAgcGetTfThresholds(tf_thresholdMin, tf_thresholdMax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTfThresholds() + +FLR_RESULT agcSetTfThresholds(const uint16_t tf_thresholdMin, const uint16_t tf_thresholdMax){ + FLR_RESULT returncode = CLIENT_pkgAgcSetTfThresholds(tf_thresholdMin, tf_thresholdMax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTfThresholds() + +FLR_RESULT agcGetMode(FLR_AGC_MODE_E *mode){ + FLR_RESULT returncode = CLIENT_pkgAgcGetMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMode() + +FLR_RESULT agcSetMode(const FLR_AGC_MODE_E mode){ + FLR_RESULT returncode = CLIENT_pkgAgcSetMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMode() + +FLR_RESULT agcSetHighTempAlarmValues(const uint32_t lowGain, const uint32_t highGain, const uint32_t pixPopulation){ + FLR_RESULT returncode = CLIENT_pkgAgcSetHighTempAlarmValues(lowGain, highGain, pixPopulation); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetHighTempAlarmValues() + +FLR_RESULT agcGetContrast(int32_t *contrast){ + FLR_RESULT returncode = CLIENT_pkgAgcGetContrast(contrast); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetContrast() + +FLR_RESULT agcSetContrast(const int32_t contrast){ + FLR_RESULT returncode = CLIENT_pkgAgcSetContrast(contrast); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetContrast() + +FLR_RESULT agcGetBrightnessBias(int32_t *brightnessBias){ + FLR_RESULT returncode = CLIENT_pkgAgcGetBrightnessBias(brightnessBias); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBrightnessBias() + +FLR_RESULT agcSetBrightnessBias(const int32_t brightnessBias){ + FLR_RESULT returncode = CLIENT_pkgAgcSetBrightnessBias(brightnessBias); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetBrightnessBias() + +FLR_RESULT agcGetBrightness(int32_t *brightness){ + FLR_RESULT returncode = CLIENT_pkgAgcGetBrightness(brightness); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBrightness() + +FLR_RESULT agcSetBrightness(const int32_t brightness){ + FLR_RESULT returncode = CLIENT_pkgAgcSetBrightness(brightness); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetBrightness() + +FLR_RESULT agcSetMaxGainForLowGain(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetMaxGainForLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxGainForLowGain() + +FLR_RESULT agcGetMaxGainForLowGain(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetMaxGainForLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxGainForLowGain() + +FLR_RESULT agcSetRadius(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetRadius(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRadius() + +FLR_RESULT agcGetRadius(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetRadius(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRadius() + +FLR_RESULT agcSetGmax(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetGmax(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGmax() + +FLR_RESULT agcGetGmax(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetGmax(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGmax() + +FLR_RESULT agcSetGmin(const float data){ + FLR_RESULT returncode = CLIENT_pkgAgcSetGmin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGmin() + +FLR_RESULT agcGetGmin(float *data){ + FLR_RESULT returncode = CLIENT_pkgAgcGetGmin(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGmin() + +FLR_RESULT bosonGetCameraSN(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetCameraSN(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCameraSN() + +FLR_RESULT bosonGetCameraPN(FLR_BOSON_PARTNUMBER_T *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetCameraPN(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCameraPN() + +FLR_RESULT bosonGetSensorSN(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSensorSN(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorSN() + +FLR_RESULT bosonRunFFC(){ + FLR_RESULT returncode = CLIENT_pkgBosonRunFFC(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of RunFFC() + +FLR_RESULT bosonSetFFCTempThreshold(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCTempThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCTempThreshold() + +FLR_RESULT bosonGetFFCTempThreshold(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCTempThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCTempThreshold() + +FLR_RESULT bosonSetFFCFrameThreshold(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCFrameThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCFrameThreshold() + +FLR_RESULT bosonGetFFCFrameThreshold(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCFrameThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCFrameThreshold() + +FLR_RESULT bosonGetFFCInProgress(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCInProgress(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCInProgress() + +FLR_RESULT bosonReboot(){ + FLR_RESULT returncode = CLIENT_pkgBosonReboot(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Reboot() + +FLR_RESULT bosonSetFFCMode(const FLR_BOSON_FFCMODE_E ffcMode){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCMode(ffcMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCMode() + +FLR_RESULT bosonGetFFCMode(FLR_BOSON_FFCMODE_E *ffcMode){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCMode(ffcMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCMode() + +FLR_RESULT bosonSetGainMode(const FLR_BOSON_GAINMODE_E gainMode){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainMode(gainMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainMode() + +FLR_RESULT bosonGetGainMode(FLR_BOSON_GAINMODE_E *gainMode){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainMode(gainMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainMode() + +FLR_RESULT bosonWriteDynamicHeaderToFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteDynamicHeaderToFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteDynamicHeaderToFlash() + +FLR_RESULT bosonReadDynamicHeaderFromFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonReadDynamicHeaderFromFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReadDynamicHeaderFromFlash() + +FLR_RESULT bosonRestoreFactoryDefaultsFromFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonRestoreFactoryDefaultsFromFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of RestoreFactoryDefaultsFromFlash() + +FLR_RESULT bosonRestoreFactoryBadPixelsFromFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonRestoreFactoryBadPixelsFromFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of RestoreFactoryBadPixelsFromFlash() + +FLR_RESULT bosonWriteBadPixelsToFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteBadPixelsToFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteBadPixelsToFlash() + +FLR_RESULT bosonGetSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSoftwareRev(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSoftwareRev() + +FLR_RESULT bosonSetBadPixelLocation(const uint32_t row, const uint32_t col){ + FLR_RESULT returncode = CLIENT_pkgBosonSetBadPixelLocation(row, col); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetBadPixelLocation() + +FLR_RESULT bosonlookupFPATempDegCx10(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonlookupFPATempDegCx10(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of lookupFPATempDegCx10() + +FLR_RESULT bosonlookupFPATempDegKx10(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonlookupFPATempDegKx10(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of lookupFPATempDegKx10() + +FLR_RESULT bosonWriteLensNvFfcToFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteLensNvFfcToFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteLensNvFfcToFlash() + +FLR_RESULT bosonWriteLensGainToFlash(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteLensGainToFlash(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteLensGainToFlash() + +FLR_RESULT bosonSetLensNumber(const uint32_t lensNumber){ + FLR_RESULT returncode = CLIENT_pkgBosonSetLensNumber(lensNumber); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLensNumber() + +FLR_RESULT bosonGetLensNumber(uint32_t *lensNumber){ + FLR_RESULT returncode = CLIENT_pkgBosonGetLensNumber(lensNumber); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLensNumber() + +FLR_RESULT bosonSetTableNumber(const uint32_t tableNumber){ + FLR_RESULT returncode = CLIENT_pkgBosonSetTableNumber(tableNumber); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTableNumber() + +FLR_RESULT bosonGetTableNumber(uint32_t *tableNumber){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTableNumber(tableNumber); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTableNumber() + +FLR_RESULT bosonGetSensorPN(FLR_BOSON_SENSOR_PARTNUMBER_T *sensorPN){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSensorPN(sensorPN); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorPN() + +FLR_RESULT bosonSetGainSwitchParams(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchParams(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchParams() + +FLR_RESULT bosonGetGainSwitchParams(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchParams(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchParams() + +FLR_RESULT bosonGetSwitchToHighGainFlag(uint8_t *switchToHighGainFlag){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSwitchToHighGainFlag(switchToHighGainFlag); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSwitchToHighGainFlag() + +FLR_RESULT bosonGetSwitchToLowGainFlag(uint8_t *switchToLowGainFlag){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSwitchToLowGainFlag(switchToLowGainFlag); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSwitchToLowGainFlag() + +FLR_RESULT bosonGetCLowToHighPercent(uint32_t *cLowToHighPercent){ + FLR_RESULT returncode = CLIENT_pkgBosonGetCLowToHighPercent(cLowToHighPercent); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCLowToHighPercent() + +FLR_RESULT bosonGetMaxNUCTables(uint32_t *maxNUCTables){ + FLR_RESULT returncode = CLIENT_pkgBosonGetMaxNUCTables(maxNUCTables); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxNUCTables() + +FLR_RESULT bosonGetMaxLensTables(uint32_t *maxLensTables){ + FLR_RESULT returncode = CLIENT_pkgBosonGetMaxLensTables(maxLensTables); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxLensTables() + +FLR_RESULT bosonGetFfcWaitCloseFrames(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFfcWaitCloseFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcWaitCloseFrames() + +FLR_RESULT bosonSetFfcWaitCloseFrames(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFfcWaitCloseFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcWaitCloseFrames() + +FLR_RESULT bosonCheckForTableSwitch(){ + FLR_RESULT returncode = CLIENT_pkgBosonCheckForTableSwitch(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CheckForTableSwitch() + +FLR_RESULT bosonGetDesiredTableNumber(uint32_t *desiredTableNumber){ + FLR_RESULT returncode = CLIENT_pkgBosonGetDesiredTableNumber(desiredTableNumber); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDesiredTableNumber() + +FLR_RESULT bosonGetFfcStatus(FLR_BOSON_FFCSTATUS_E *ffcStatus){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFfcStatus(ffcStatus); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcStatus() + +FLR_RESULT bosonGetFfcDesired(uint32_t *ffcDesired){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFfcDesired(ffcDesired); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcDesired() + +FLR_RESULT bosonGetSwRevInHeader(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSwRevInHeader(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSwRevInHeader() + +FLR_RESULT bosonGetLastFFCFrameCount(uint32_t *frameCount){ + FLR_RESULT returncode = CLIENT_pkgBosonGetLastFFCFrameCount(frameCount); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastFFCFrameCount() + +FLR_RESULT bosonGetLastFFCTempDegKx10(uint16_t *temp){ + FLR_RESULT returncode = CLIENT_pkgBosonGetLastFFCTempDegKx10(temp); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastFFCTempDegKx10() + +FLR_RESULT bosonGetTableSwitchDesired(uint16_t *tableSwitchDesired){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTableSwitchDesired(tableSwitchDesired); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTableSwitchDesired() + +FLR_RESULT bosonGetOverTempThreshold(float *temperatureInC){ + FLR_RESULT returncode = CLIENT_pkgBosonGetOverTempThreshold(temperatureInC); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOverTempThreshold() + +FLR_RESULT bosonGetLowPowerMode(uint16_t *lowPowerMode){ + FLR_RESULT returncode = CLIENT_pkgBosonGetLowPowerMode(lowPowerMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLowPowerMode() + +FLR_RESULT bosonGetOverTempEventOccurred(uint16_t *overTempEventOccurred){ + FLR_RESULT returncode = CLIENT_pkgBosonGetOverTempEventOccurred(overTempEventOccurred); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOverTempEventOccurred() + +FLR_RESULT bosonSetPermitThermalShutdownOverride(const FLR_ENABLE_E permitThermalShutdownOverride){ + FLR_RESULT returncode = CLIENT_pkgBosonSetPermitThermalShutdownOverride(permitThermalShutdownOverride); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPermitThermalShutdownOverride() + +FLR_RESULT bosonGetPermitThermalShutdownOverride(FLR_ENABLE_E *permitThermalShutdownOverride){ + FLR_RESULT returncode = CLIENT_pkgBosonGetPermitThermalShutdownOverride(permitThermalShutdownOverride); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPermitThermalShutdownOverride() + +FLR_RESULT bosonGetMyriadTemp(float *myriadTemp){ + FLR_RESULT returncode = CLIENT_pkgBosonGetMyriadTemp(myriadTemp); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMyriadTemp() + +FLR_RESULT bosonGetNvFFCNucTableNumberLens0(int32_t *nvFFCNucTableNumberLens0){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCNucTableNumberLens0(nvFFCNucTableNumberLens0); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCNucTableNumberLens0() + +FLR_RESULT bosonGetNvFFCNucTableNumberLens1(int32_t *nvFFCNucTableNumberLens1){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCNucTableNumberLens1(nvFFCNucTableNumberLens1); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCNucTableNumberLens1() + +FLR_RESULT bosonGetNvFFCFPATempDegKx10Lens0(uint16_t *nvFFCFPATempDegKx10Lens0){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens0(nvFFCFPATempDegKx10Lens0); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCFPATempDegKx10Lens0() + +FLR_RESULT bosonGetNvFFCFPATempDegKx10Lens1(uint16_t *nvFFCFPATempDegKx10Lens1){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens1(nvFFCFPATempDegKx10Lens1); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCFPATempDegKx10Lens1() + +FLR_RESULT bosonSetFFCWarnTimeInSecx10(const uint16_t ffcWarnTime){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCWarnTimeInSecx10(ffcWarnTime); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCWarnTimeInSecx10() + +FLR_RESULT bosonGetFFCWarnTimeInSecx10(uint16_t *ffcWarnTime){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCWarnTimeInSecx10(ffcWarnTime); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCWarnTimeInSecx10() + +FLR_RESULT bosonGetOverTempEventCounter(uint32_t *overTempEventCounter){ + FLR_RESULT returncode = CLIENT_pkgBosonGetOverTempEventCounter(overTempEventCounter); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOverTempEventCounter() + +FLR_RESULT bosonSetOverTempTimerInSec(const uint16_t overTempTimerInSec){ + FLR_RESULT returncode = CLIENT_pkgBosonSetOverTempTimerInSec(overTempTimerInSec); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOverTempTimerInSec() + +FLR_RESULT bosonGetOverTempTimerInSec(uint16_t *overTempTimerInSec){ + FLR_RESULT returncode = CLIENT_pkgBosonGetOverTempTimerInSec(overTempTimerInSec); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOverTempTimerInSec() + +FLR_RESULT bosonUnloadCurrentLensCorrections(){ + FLR_RESULT returncode = CLIENT_pkgBosonUnloadCurrentLensCorrections(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of UnloadCurrentLensCorrections() + +FLR_RESULT bosonSetTimeForQuickFFCsInSecs(const uint32_t timeForQuickFFCsInSecs){ + FLR_RESULT returncode = CLIENT_pkgBosonSetTimeForQuickFFCsInSecs(timeForQuickFFCsInSecs); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTimeForQuickFFCsInSecs() + +FLR_RESULT bosonGetTimeForQuickFFCsInSecs(uint32_t *timeForQuickFFCsInSecs){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTimeForQuickFFCsInSecs(timeForQuickFFCsInSecs); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTimeForQuickFFCsInSecs() + +FLR_RESULT bosonReloadCurrentLensCorrections(){ + FLR_RESULT returncode = CLIENT_pkgBosonReloadCurrentLensCorrections(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReloadCurrentLensCorrections() + +FLR_RESULT bosonGetBootTimestamps(float *FirstLight, float *StartInit, float *BosonExecDone, float *Timestamp4){ + FLR_RESULT returncode = CLIENT_pkgBosonGetBootTimestamps(FirstLight, StartInit, BosonExecDone, Timestamp4); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBootTimestamps() + +FLR_RESULT bosonSetExtSyncMode(const FLR_BOSON_EXT_SYNC_MODE_E mode){ + FLR_RESULT returncode = CLIENT_pkgBosonSetExtSyncMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetExtSyncMode() + +FLR_RESULT bosonGetExtSyncMode(FLR_BOSON_EXT_SYNC_MODE_E *mode){ + FLR_RESULT returncode = CLIENT_pkgBosonGetExtSyncMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetExtSyncMode() + +FLR_RESULT bosonGetLastCommand(uint32_t *sequenceNum, uint32_t *cmdID){ + FLR_RESULT returncode = CLIENT_pkgBosonGetLastCommand(sequenceNum, cmdID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastCommand() + +FLR_RESULT bosonGetSensorHostCalVersion(uint32_t *version){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSensorHostCalVersion(version); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorHostCalVersion() + +FLR_RESULT bosonSetDesiredStartupTableNumber(const int32_t table){ + FLR_RESULT returncode = CLIENT_pkgBosonSetDesiredStartupTableNumber(table); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDesiredStartupTableNumber() + +FLR_RESULT bosonGetDesiredStartupTableNumber(int32_t *table){ + FLR_RESULT returncode = CLIENT_pkgBosonGetDesiredStartupTableNumber(table); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDesiredStartupTableNumber() + +FLR_RESULT bosonSetNvFFCMeanValueLens0(const float meanValue){ + FLR_RESULT returncode = CLIENT_pkgBosonSetNvFFCMeanValueLens0(meanValue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNvFFCMeanValueLens0() + +FLR_RESULT bosonGetNvFFCMeanValueLens0(float *meanValue){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCMeanValueLens0(meanValue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCMeanValueLens0() + +FLR_RESULT bosonSetNvFFCMeanValueLens1(const float meanValue){ + FLR_RESULT returncode = CLIENT_pkgBosonSetNvFFCMeanValueLens1(meanValue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNvFFCMeanValueLens1() + +FLR_RESULT bosonGetNvFFCMeanValueLens1(float *meanValue){ + FLR_RESULT returncode = CLIENT_pkgBosonGetNvFFCMeanValueLens1(meanValue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNvFFCMeanValueLens1() + +FLR_RESULT bosonSetInvertImage(const FLR_ENABLE_E invertImage){ + FLR_RESULT returncode = CLIENT_pkgBosonSetInvertImage(invertImage); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetInvertImage() + +FLR_RESULT bosonGetInvertImage(FLR_ENABLE_E *invertImage){ + FLR_RESULT returncode = CLIENT_pkgBosonGetInvertImage(invertImage); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetInvertImage() + +FLR_RESULT bosonSetRevertImage(const FLR_ENABLE_E revertImage){ + FLR_RESULT returncode = CLIENT_pkgBosonSetRevertImage(revertImage); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRevertImage() + +FLR_RESULT bosonGetRevertImage(FLR_ENABLE_E *revertImage){ + FLR_RESULT returncode = CLIENT_pkgBosonGetRevertImage(revertImage); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRevertImage() + +FLR_RESULT bosonGetTimeStamp(const FLR_BOSON_TIMESTAMPTYPE_E timeStampType, float *timeStamp){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTimeStamp(timeStampType, timeStamp); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTimeStamp() + +FLR_RESULT bosonGetISPFrameCount(uint32_t *ispFrameCount){ + FLR_RESULT returncode = CLIENT_pkgBosonGetISPFrameCount(ispFrameCount); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetISPFrameCount() + +FLR_RESULT bosonWriteUserBadPixelsToAllTables(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteUserBadPixelsToAllTables(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteUserBadPixelsToAllTables() + +FLR_RESULT bosonWriteFactoryBadPixelsToAllTables(){ + FLR_RESULT returncode = CLIENT_pkgBosonWriteFactoryBadPixelsToAllTables(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteFactoryBadPixelsToAllTables() + +FLR_RESULT bosonGetTempDiodeStatus(FLR_BOSON_TEMP_DIODE_STATUS_E *status){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTempDiodeStatus(status); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempDiodeStatus() + +FLR_RESULT bosonClearFactoryBadPixelsInDDR(){ + FLR_RESULT returncode = CLIENT_pkgBosonClearFactoryBadPixelsInDDR(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ClearFactoryBadPixelsInDDR() + +FLR_RESULT bosonGetFfcWaitOpenFrames(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFfcWaitOpenFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcWaitOpenFrames() + +FLR_RESULT bosonSetFfcWaitOpenFrames(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFfcWaitOpenFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcWaitOpenFrames() + +FLR_RESULT bosonGetFfcWaitOpenFlagSettleFrames(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFfcWaitOpenFlagSettleFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcWaitOpenFlagSettleFrames() + +FLR_RESULT bosonSetFfcWaitOpenFlagSettleFrames(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFfcWaitOpenFlagSettleFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcWaitOpenFlagSettleFrames() + +FLR_RESULT bosonGetTauExtFfcCompatibilityMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetTauExtFfcCompatibilityMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTauExtFfcCompatibilityMode() + +FLR_RESULT bosonSetTauExtFfcCompatibilityMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetTauExtFfcCompatibilityMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTauExtFfcCompatibilityMode() + +FLR_RESULT bosonGetInitialTableSelectionTempOffset(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetInitialTableSelectionTempOffset(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetInitialTableSelectionTempOffset() + +FLR_RESULT bosonSetInitialTableSelectionTempOffset(const int16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetInitialTableSelectionTempOffset(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetInitialTableSelectionTempOffset() + +FLR_RESULT bosonGetImageValid(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetImageValid(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetImageValid() + +FLR_RESULT bosonGetCurrentTableType(FLR_BOSON_TABLETYPE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetCurrentTableType(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCurrentTableType() + +FLR_RESULT bosonGetGainSwitchFrameThreshold(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchFrameThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchFrameThreshold() + +FLR_RESULT bosonSetGainSwitchFrameThreshold(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchFrameThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchFrameThreshold() + +FLR_RESULT bosonGetGainSwitchHysteresisTime(float *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchHysteresisTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchHysteresisTime() + +FLR_RESULT bosonSetGainSwitchHysteresisTime(const float data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchHysteresisTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchHysteresisTime() + +FLR_RESULT bosonGetGainSwitchDesired(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchDesired() + +FLR_RESULT bosonGetGainSwitchRadiometricParams(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchRadiometricParams(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchRadiometricParams() + +FLR_RESULT bosonSetGainSwitchRadiometricParams(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchRadiometricParams(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchRadiometricParams() + +FLR_RESULT bosonSetSaturationOverrideMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetSaturationOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSaturationOverrideMode() + +FLR_RESULT bosonGetSaturationOverrideMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSaturationOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSaturationOverrideMode() + +FLR_RESULT bosonSetSaturationOverrideValue(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetSaturationOverrideValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSaturationOverrideValue() + +FLR_RESULT bosonGetSaturationOverrideValue(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetSaturationOverrideValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSaturationOverrideValue() + +FLR_RESULT bosonSetffcHighLowGainThresholdMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetffcHighLowGainThresholdMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetffcHighLowGainThresholdMode() + +FLR_RESULT bosonGetffcHighLowGainThresholdMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetffcHighLowGainThresholdMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetffcHighLowGainThresholdMode() + +FLR_RESULT bosonSetFFCTempThresholdLowGain(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCTempThresholdLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCTempThresholdLowGain() + +FLR_RESULT bosonGetFFCTempThresholdLowGain(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCTempThresholdLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCTempThresholdLowGain() + +FLR_RESULT bosonSetFFCFrameThresholdLowGain(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetFFCFrameThresholdLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFCFrameThresholdLowGain() + +FLR_RESULT bosonGetFFCFrameThresholdLowGain(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetFFCFrameThresholdLowGain(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFCFrameThresholdLowGain() + +FLR_RESULT bosonGetBoardID(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetBoardID(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBoardID() + +FLR_RESULT bosonSetAutoGainSwitchConditions(const FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E data){ + FLR_RESULT returncode = CLIENT_pkgBosonSetAutoGainSwitchConditions(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAutoGainSwitchConditions() + +FLR_RESULT bosonGetAutoGainSwitchConditions(FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E *data){ + FLR_RESULT returncode = CLIENT_pkgBosonGetAutoGainSwitchConditions(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAutoGainSwitchConditions() + +FLR_RESULT bosonSetGainSwitchParamsCATS(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchParamsCATS(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchParamsCATS() + +FLR_RESULT bosonGetGainSwitchParamsCATS(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchParamsCATS(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchParamsCATS() + +FLR_RESULT bosonGetGainSwitchRadiometricParamsCATS(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonGetGainSwitchRadiometricParamsCATS(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSwitchRadiometricParamsCATS() + +FLR_RESULT bosonSetGainSwitchRadiometricParamsCATS(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct){ + FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchRadiometricParamsCATS(parm_struct); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainSwitchRadiometricParamsCATS() + +FLR_RESULT bosonGetCLowToHighPercentCATS(uint32_t *cLowToHighPercent){ + FLR_RESULT returncode = CLIENT_pkgBosonGetCLowToHighPercentCATS(cLowToHighPercent); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCLowToHighPercentCATS() + +FLR_RESULT bprGetState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBprGetState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetState() + +FLR_RESULT bprSetState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgBprSetState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetState() + +FLR_RESULT bprGetStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used){ + FLR_RESULT returncode = CLIENT_pkgBprGetStats(threeby, fiveby, rows, budget, used); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStats() + +FLR_RESULT bprGetDisplayMode(FLR_BPR_DISPLAY_MODE_E *data){ + FLR_RESULT returncode = CLIENT_pkgBprGetDisplayMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDisplayMode() + +FLR_RESULT bprSetDisplayMode(const FLR_BPR_DISPLAY_MODE_E data){ + FLR_RESULT returncode = CLIENT_pkgBprSetDisplayMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDisplayMode() + +FLR_RESULT bprGetDisplayModeMinValue(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBprGetDisplayModeMinValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDisplayModeMinValue() + +FLR_RESULT bprSetDisplayModeMinValue(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBprSetDisplayModeMinValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDisplayModeMinValue() + +FLR_RESULT bprGetDisplayModeMaxValue(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgBprGetDisplayModeMaxValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDisplayModeMaxValue() + +FLR_RESULT bprSetDisplayModeMaxValue(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgBprSetDisplayModeMaxValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDisplayModeMaxValue() + +FLR_RESULT bprGetWorkBufIndex(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgBprGetWorkBufIndex(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetWorkBufIndex() + +FLR_RESULT bprSetWorkBufIndex(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgBprSetWorkBufIndex(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetWorkBufIndex() + +FLR_RESULT bprGetWorkBufStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used){ + FLR_RESULT returncode = CLIENT_pkgBprGetWorkBufStats(threeby, fiveby, rows, budget, used); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetWorkBufStats() + +FLR_RESULT captureSingleFrame(){ + FLR_RESULT returncode = CLIENT_pkgCaptureSingleFrame(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SingleFrame() + +FLR_RESULT captureFrames(const FLR_CAPTURE_SETTINGS_T data){ + FLR_RESULT returncode = CLIENT_pkgCaptureFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Frames() + +FLR_RESULT captureSingleFrameWithSrc(const FLR_CAPTURE_SRC_E data){ + FLR_RESULT returncode = CLIENT_pkgCaptureSingleFrameWithSrc(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SingleFrameWithSrc() + +FLR_RESULT captureSingleFrameToFile(){ + FLR_RESULT returncode = CLIENT_pkgCaptureSingleFrameToFile(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SingleFrameToFile() + +FLR_RESULT captureGetStatus(FLR_CAPTURE_STATUS_T *status){ + FLR_RESULT returncode = CLIENT_pkgCaptureGetStatus(status); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStatus() + +FLR_RESULT colorLutSetControl(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgColorlutSetControl(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetControl() + +FLR_RESULT colorLutGetControl(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgColorlutGetControl(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetControl() + +FLR_RESULT colorLutSetId(const FLR_COLORLUT_ID_E data){ + FLR_RESULT returncode = CLIENT_pkgColorlutSetId(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetId() + +FLR_RESULT colorLutGetId(FLR_COLORLUT_ID_E *data){ + FLR_RESULT returncode = CLIENT_pkgColorlutGetId(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetId() + +FLR_RESULT colorLutSetOutlineColor(const uint8_t red, const uint8_t green, const uint8_t blue){ + FLR_RESULT returncode = CLIENT_pkgColorlutSetOutlineColor(red, green, blue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutlineColor() + +FLR_RESULT colorLutGetOutlineColor(uint8_t *red, uint8_t *green, uint8_t *blue){ + FLR_RESULT returncode = CLIENT_pkgColorlutGetOutlineColor(red, green, blue); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutlineColor() + +FLR_RESULT dummyBadCommand(){ + FLR_RESULT returncode = CLIENT_pkgDummyBadCommand(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of BadCommand() + +FLR_RESULT dvoSetAnalogVideoState(const FLR_ENABLE_E analogVideoState){ + FLR_RESULT returncode = CLIENT_pkgDvoSetAnalogVideoState(analogVideoState); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAnalogVideoState() + +FLR_RESULT dvoGetAnalogVideoState(FLR_ENABLE_E *analogVideoState){ + FLR_RESULT returncode = CLIENT_pkgDvoGetAnalogVideoState(analogVideoState); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAnalogVideoState() + +FLR_RESULT dvoSetOutputFormat(const FLR_DVO_OUTPUT_FORMAT_E format){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputFormat(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputFormat() + +FLR_RESULT dvoGetOutputFormat(FLR_DVO_OUTPUT_FORMAT_E *format){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputFormat(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputFormat() + +FLR_RESULT dvoSetOutputYCbCrSettings(const FLR_DVO_YCBCR_SETTINGS_T settings){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputYCbCrSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputYCbCrSettings() + +FLR_RESULT dvoGetOutputYCbCrSettings(FLR_DVO_YCBCR_SETTINGS_T *settings){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputYCbCrSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputYCbCrSettings() + +FLR_RESULT dvoSetOutputRGBSettings(const FLR_DVO_RGB_SETTINGS_T settings){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputRGBSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputRGBSettings() + +FLR_RESULT dvoGetOutputRGBSettings(FLR_DVO_RGB_SETTINGS_T *settings){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputRGBSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputRGBSettings() + +FLR_RESULT dvoApplyCustomSettings(){ + FLR_RESULT returncode = CLIENT_pkgDvoApplyCustomSettings(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ApplyCustomSettings() + +FLR_RESULT dvoSetDisplayMode(const FLR_DVO_DISPLAY_MODE_E displayMode){ + FLR_RESULT returncode = CLIENT_pkgDvoSetDisplayMode(displayMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDisplayMode() + +FLR_RESULT dvoGetDisplayMode(FLR_DVO_DISPLAY_MODE_E *displayMode){ + FLR_RESULT returncode = CLIENT_pkgDvoGetDisplayMode(displayMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDisplayMode() + +FLR_RESULT dvoSetType(const FLR_DVO_TYPE_E tap){ + FLR_RESULT returncode = CLIENT_pkgDvoSetType(tap); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetType() + +FLR_RESULT dvoGetType(FLR_DVO_TYPE_E *tap){ + FLR_RESULT returncode = CLIENT_pkgDvoGetType(tap); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetType() + +FLR_RESULT dvoSetVideoStandard(const FLR_DVO_VIDEO_STANDARD_E videoStandard){ + FLR_RESULT returncode = CLIENT_pkgDvoSetVideoStandard(videoStandard); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetVideoStandard() + +FLR_RESULT dvoGetVideoStandard(FLR_DVO_VIDEO_STANDARD_E *videoStandard){ + FLR_RESULT returncode = CLIENT_pkgDvoGetVideoStandard(videoStandard); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetVideoStandard() + +FLR_RESULT dvoSetCheckVideoDacPresent(const FLR_ENABLE_E checkVideoDacPresent){ + FLR_RESULT returncode = CLIENT_pkgDvoSetCheckVideoDacPresent(checkVideoDacPresent); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetCheckVideoDacPresent() + +FLR_RESULT dvoGetCheckVideoDacPresent(FLR_ENABLE_E *checkVideoDacPresent){ + FLR_RESULT returncode = CLIENT_pkgDvoGetCheckVideoDacPresent(checkVideoDacPresent); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCheckVideoDacPresent() + +FLR_RESULT dvoSetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, const FLR_DVO_LCD_CONFIG_T config){ + FLR_RESULT returncode = CLIENT_pkgDvoSetCustomLcdConfig(id, config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetCustomLcdConfig() + +FLR_RESULT dvoGetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, FLR_DVO_LCD_CONFIG_T *config){ + FLR_RESULT returncode = CLIENT_pkgDvoGetCustomLcdConfig(id, config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCustomLcdConfig() + +FLR_RESULT dvoSetLCDConfig(const FLR_DVO_LCD_CONFIG_ID_E id){ + FLR_RESULT returncode = CLIENT_pkgDvoSetLCDConfig(id); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLCDConfig() + +FLR_RESULT dvoGetLCDConfig(FLR_DVO_LCD_CONFIG_ID_E *id){ + FLR_RESULT returncode = CLIENT_pkgDvoGetLCDConfig(id); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLCDConfig() + +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 returncode = CLIENT_pkgDvoGetClockInfo(horizontalSyncWidth, verticalSyncWidth, clocksPerRowPeriod, horizontalFrontPorch, horizontalBackPorch, frontTelemetryPixels, rearTelemetryPixels, videoColumns, validColumns, telemetryRows, videoRows, validRows, verticalFrontPorch, verticalBackPorch, rowPeriodsPerFrame, clocksPerFrame, clockRateInMHz, frameRateInHz, validOnRisingEdge, dataWidthInBits); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetClockInfo() + +FLR_RESULT dvoSetAllCustomLcdConfigs(const FLR_DVO_LCD_CONFIG_T config0, const FLR_DVO_LCD_CONFIG_T config1){ + FLR_RESULT returncode = CLIENT_pkgDvoSetAllCustomLcdConfigs(config0, config1); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAllCustomLcdConfigs() + +FLR_RESULT dvoGetAllCustomLcdConfigs(FLR_DVO_LCD_CONFIG_T *config0, FLR_DVO_LCD_CONFIG_T *config1){ + FLR_RESULT returncode = CLIENT_pkgDvoGetAllCustomLcdConfigs(config0, config1); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAllCustomLcdConfigs() + +FLR_RESULT dvoSetOutputIr16Format(const FLR_DVO_OUTPUT_IR16_FORMAT_E format){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputIr16Format(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputIr16Format() + +FLR_RESULT dvoGetOutputIr16Format(FLR_DVO_OUTPUT_IR16_FORMAT_E *format){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputIr16Format(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputIr16Format() + +FLR_RESULT dvoSetLcdClockRate(const FLR_DVO_LCD_CLOCK_RATE_E clockRate){ + FLR_RESULT returncode = CLIENT_pkgDvoSetLcdClockRate(clockRate); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLcdClockRate() + +FLR_RESULT dvoGetLcdClockRate(FLR_DVO_LCD_CLOCK_RATE_E *clockRate){ + FLR_RESULT returncode = CLIENT_pkgDvoGetLcdClockRate(clockRate); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLcdClockRate() + +FLR_RESULT dvoSetLcdVideoFrameRate(const uint32_t framerate){ + FLR_RESULT returncode = CLIENT_pkgDvoSetLcdVideoFrameRate(framerate); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLcdVideoFrameRate() + +FLR_RESULT dvoGetLcdVideoFrameRate(uint32_t *framerate){ + FLR_RESULT returncode = CLIENT_pkgDvoGetLcdVideoFrameRate(framerate); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLcdVideoFrameRate() + +FLR_RESULT dvoSetMipiStartState(const FLR_DVO_MIPI_STATE_E state){ + FLR_RESULT returncode = CLIENT_pkgDvoSetMipiStartState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMipiStartState() + +FLR_RESULT dvoGetMipiStartState(FLR_DVO_MIPI_STATE_E *state){ + FLR_RESULT returncode = CLIENT_pkgDvoGetMipiStartState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMipiStartState() + +FLR_RESULT dvoSetMipiState(const FLR_DVO_MIPI_STATE_E state){ + FLR_RESULT returncode = CLIENT_pkgDvoSetMipiState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMipiState() + +FLR_RESULT dvoGetMipiState(FLR_DVO_MIPI_STATE_E *state){ + FLR_RESULT returncode = CLIENT_pkgDvoGetMipiState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMipiState() + +FLR_RESULT dvoSetMipiClockLaneMode(const FLR_DVO_MIPI_CLOCK_LANE_MODE_E mode){ + FLR_RESULT returncode = CLIENT_pkgDvoSetMipiClockLaneMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMipiClockLaneMode() + +FLR_RESULT dvoGetMipiClockLaneMode(FLR_DVO_MIPI_CLOCK_LANE_MODE_E *mode){ + FLR_RESULT returncode = CLIENT_pkgDvoGetMipiClockLaneMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMipiClockLaneMode() + +FLR_RESULT dvoSetOutputInterface(const FLR_DVO_OUTPUT_INTERFACE_E format){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputInterface(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputInterface() + +FLR_RESULT dvoGetOutputInterface(FLR_DVO_OUTPUT_INTERFACE_E *format){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputInterface(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputInterface() + +FLR_RESULT dvoSetOutputFormatVC1(const FLR_DVO_OUTPUT_FORMAT_E format){ + FLR_RESULT returncode = CLIENT_pkgDvoSetOutputFormatVC1(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOutputFormatVC1() + +FLR_RESULT dvoGetOutputFormatVC1(FLR_DVO_OUTPUT_FORMAT_E *format){ + FLR_RESULT returncode = CLIENT_pkgDvoGetOutputFormatVC1(format); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOutputFormatVC1() + +FLR_RESULT dvoMuxSetType(const FLR_DVOMUX_OUTPUT_IF_E output, const FLR_DVOMUX_SOURCE_E source, const FLR_DVOMUX_TYPE_E type){ + FLR_RESULT returncode = CLIENT_pkgDvomuxSetType(output, source, type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetType() + +FLR_RESULT dvoMuxGetType(const FLR_DVOMUX_OUTPUT_IF_E output, FLR_DVOMUX_SOURCE_E *source, FLR_DVOMUX_TYPE_E *type){ + FLR_RESULT returncode = CLIENT_pkgDvomuxGetType(output, source, type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetType() + +FLR_RESULT fileOpsDir(uint8_t dirent[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsDir(dirent); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Dir() + +FLR_RESULT fileOpsCd(const uint8_t path[], uint8_t pwd[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsCd(path, pwd); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Cd() + +FLR_RESULT fileOpsMd(const uint8_t path[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsMd(path); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Md() + +FLR_RESULT fileOpsFopen(const uint8_t path[], const uint8_t mode[], uint32_t *id){ + FLR_RESULT returncode = CLIENT_pkgFileopsFopen(path, mode, id); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Fopen() + +FLR_RESULT fileOpsFclose(const uint32_t id){ + FLR_RESULT returncode = CLIENT_pkgFileopsFclose(id); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Fclose() + +FLR_RESULT fileOpsFread(const uint32_t id, const uint32_t length, uint8_t buf[], uint32_t *ret){ + FLR_RESULT returncode = CLIENT_pkgFileopsFread(id, length, buf, ret); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Fread() + +FLR_RESULT fileOpsFwrite(const uint32_t id, const uint32_t length, const uint8_t buf[], uint32_t *ret){ + FLR_RESULT returncode = CLIENT_pkgFileopsFwrite(id, length, buf, ret); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Fwrite() + +FLR_RESULT fileOpsFtell(const uint32_t id, uint32_t *offset){ + FLR_RESULT returncode = CLIENT_pkgFileopsFtell(id, offset); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Ftell() + +FLR_RESULT fileOpsFseek(const uint32_t id, const uint32_t offset, const uint32_t origin){ + FLR_RESULT returncode = CLIENT_pkgFileopsFseek(id, offset, origin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Fseek() + +FLR_RESULT fileOpsFtruncate(const uint32_t id, const uint32_t length){ + FLR_RESULT returncode = CLIENT_pkgFileopsFtruncate(id, length); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Ftruncate() + +FLR_RESULT fileOpsRmdir(const uint8_t path[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsRmdir(path); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Rmdir() + +FLR_RESULT fileOpsRm(const uint8_t path[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsRm(path); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Rm() + +FLR_RESULT fileOpsRename(const uint8_t oldpath[], const uint8_t newpath[]){ + FLR_RESULT returncode = CLIENT_pkgFileopsRename(oldpath, newpath); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Rename() + +FLR_RESULT fileOpsGetFileSize(const uint8_t path[], uint32_t *fileLength){ + FLR_RESULT returncode = CLIENT_pkgFileopsGetFileSize(path, fileLength); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFileSize() + +FLR_RESULT flashIOSetProtectionState(const FLR_ENABLE_E protectionState){ + FLR_RESULT returncode = CLIENT_pkgFlashioSetProtectionState(protectionState); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetProtectionState() + +FLR_RESULT flashIOGetProtectionState(FLR_ENABLE_E *protectionState){ + FLR_RESULT returncode = CLIENT_pkgFlashioGetProtectionState(protectionState); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetProtectionState() + +FLR_RESULT flashMapFsGetHeaderVersion(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgFlashmapfsGetHeaderVersion(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetHeaderVersion() + +FLR_RESULT gaoSetGainState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetGainState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGainState() + +FLR_RESULT gaoGetGainState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetGainState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainState() + +FLR_RESULT gaoSetFfcState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetFfcState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcState() + +FLR_RESULT gaoGetFfcState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetFfcState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcState() + +FLR_RESULT gaoSetTempCorrectionState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetTempCorrectionState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempCorrectionState() + +FLR_RESULT gaoGetTempCorrectionState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetTempCorrectionState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempCorrectionState() + +FLR_RESULT gaoSetIConstL(const int16_t data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetIConstL(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIConstL() + +FLR_RESULT gaoGetIConstL(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetIConstL(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIConstL() + +FLR_RESULT gaoSetIConstM(const int16_t data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetIConstM(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIConstM() + +FLR_RESULT gaoGetIConstM(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetIConstM(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIConstM() + +FLR_RESULT gaoSetAveragerState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetAveragerState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAveragerState() + +FLR_RESULT gaoGetAveragerState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAveragerState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAveragerState() + +FLR_RESULT gaoSetNumFFCFrames(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetNumFFCFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNumFFCFrames() + +FLR_RESULT gaoGetNumFFCFrames(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetNumFFCFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNumFFCFrames() + +FLR_RESULT gaoGetAveragerThreshold(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAveragerThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAveragerThreshold() + +FLR_RESULT gaoSetTestRampState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetTestRampState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTestRampState() + +FLR_RESULT gaoGetTestRampState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetTestRampState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTestRampState() + +FLR_RESULT gaoSetSffcState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetSffcState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSffcState() + +FLR_RESULT gaoGetSffcState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetSffcState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSffcState() + +FLR_RESULT gaoSetNucType(const FLR_GAO_NUC_TYPE_E nucType){ + FLR_RESULT returncode = CLIENT_pkgGaoSetNucType(nucType); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNucType() + +FLR_RESULT gaoGetNucType(FLR_GAO_NUC_TYPE_E *nucType){ + FLR_RESULT returncode = CLIENT_pkgGaoGetNucType(nucType); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNucType() + +FLR_RESULT gaoSetFfcZeroMeanState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetFfcZeroMeanState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcZeroMeanState() + +FLR_RESULT gaoGetFfcZeroMeanState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetFfcZeroMeanState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcZeroMeanState() + +FLR_RESULT gaoGetAveragerDesiredState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAveragerDesiredState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAveragerDesiredState() + +FLR_RESULT gaoGetAppliedClip(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAppliedClip(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAppliedClip() + +FLR_RESULT gaoSetAppliedClipEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetAppliedClipEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAppliedClipEnable() + +FLR_RESULT gaoGetAppliedClipEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAppliedClipEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAppliedClipEnable() + +FLR_RESULT gaoSetFfcShutterSimulationState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetFfcShutterSimulationState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcShutterSimulationState() + +FLR_RESULT gaoGetFfcShutterSimulationState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetFfcShutterSimulationState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcShutterSimulationState() + +FLR_RESULT gaoSetFfcShutterSimulatorValue(const uint16_t value){ + FLR_RESULT returncode = CLIENT_pkgGaoSetFfcShutterSimulatorValue(value); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFfcShutterSimulatorValue() + +FLR_RESULT gaoGetFfcShutterSimulatorValue(uint16_t *value){ + FLR_RESULT returncode = CLIENT_pkgGaoGetFfcShutterSimulatorValue(value); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcShutterSimulatorValue() + +FLR_RESULT gaoSetBcnrState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgGaoSetBcnrState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetBcnrState() + +FLR_RESULT gaoGetBcnrState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetBcnrState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBcnrState() + +FLR_RESULT gaoGetAppliedSffcScaleFactor(float *data){ + FLR_RESULT returncode = CLIENT_pkgGaoGetAppliedSffcScaleFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAppliedSffcScaleFactor() + +FLR_RESULT gaoSetSffcMode(const FLR_GAO_SFFC_MODE_E mode){ + FLR_RESULT returncode = CLIENT_pkgGaoSetSffcMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSffcMode() + +FLR_RESULT gaoGetSffcMode(FLR_GAO_SFFC_MODE_E *mode){ + FLR_RESULT returncode = CLIENT_pkgGaoGetSffcMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSffcMode() + +FLR_RESULT imageStatsGetTotalHistPixelsInROI(uint32_t *totalPixelsInROI){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetTotalHistPixelsInROI(totalPixelsInROI); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTotalHistPixelsInROI() + +FLR_RESULT imageStatsGetPopBelowLowToHighThresh(uint32_t *popBelowLowToHighThresh){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopBelowLowToHighThresh(popBelowLowToHighThresh); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPopBelowLowToHighThresh() + +FLR_RESULT imageStatsGetPopAboveHighToLowThresh(uint32_t *popAboveHighToLowThresh){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopAboveHighToLowThresh(popAboveHighToLowThresh); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPopAboveHighToLowThresh() + +FLR_RESULT imageStatsSetROI(const FLR_ROI_T roi){ + FLR_RESULT returncode = CLIENT_pkgImagestatsSetROI(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetROI() + +FLR_RESULT imageStatsGetROI(FLR_ROI_T *roi){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetROI(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetROI() + +FLR_RESULT imageStatsGetFirstBin(uint16_t *firstBin){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetFirstBin(firstBin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFirstBin() + +FLR_RESULT imageStatsGetLastBin(uint16_t *lastBin){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetLastBin(lastBin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastBin() + +FLR_RESULT imageStatsGetMean(uint16_t *mean){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetMean(mean); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMean() + +FLR_RESULT imageStatsGetFirstBinInROI(uint16_t *firstBinInROI){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetFirstBinInROI(firstBinInROI); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFirstBinInROI() + +FLR_RESULT imageStatsGetLastBinInROI(uint16_t *lastBinInROI){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetLastBinInROI(lastBinInROI); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLastBinInROI() + +FLR_RESULT imageStatsGetMeanInROI(uint16_t *meanInROI){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetMeanInROI(meanInROI); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMeanInROI() + +FLR_RESULT imageStatsGetImageStats(uint16_t *meanIntensity, uint16_t *peakIntensity, uint16_t *baseIntensity){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetImageStats(meanIntensity, peakIntensity, baseIntensity); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetImageStats() + +FLR_RESULT imageStatsGetPopAboveLowToHighThreshCATS(uint32_t *popAboveLowToHighThresh){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopAboveLowToHighThreshCATS(popAboveLowToHighThresh); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPopAboveLowToHighThreshCATS() + +FLR_RESULT imageStatsGetPopBelowHighToLowThreshCATS(uint32_t *popBelowHighToLowThresh){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopBelowHighToLowThreshCATS(popBelowHighToLowThresh); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPopBelowHighToLowThreshCATS() + +FLR_RESULT imageStatsGetPopBetweenLthCATSAndLthSATS(uint32_t *popBetweenCatsAndSats){ + FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopBetweenLthCATSAndLthSATS(popBetweenCatsAndSats); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPopBetweenLthCATSAndLthSATS() + +FLR_RESULT isothermGetEnable(FLR_ENABLE_E *isothermEnable){ + FLR_RESULT returncode = CLIENT_pkgIsothermGetEnable(isothermEnable); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnable() + +FLR_RESULT isothermSetEnable(const FLR_ENABLE_E isothermEnable){ + FLR_RESULT returncode = CLIENT_pkgIsothermSetEnable(isothermEnable); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnable() + +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 returncode = CLIENT_pkgIsothermSetTemps(table, thIsoT1, thIsoT2, thIsoT3, thIsoT4, thIsoT5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTemps() + +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 returncode = CLIENT_pkgIsothermGetTemps(table, thIsoT1, thIsoT2, thIsoT3, thIsoT4, thIsoT5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTemps() + +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 returncode = CLIENT_pkgIsothermSetIsoColorValues(table, region0, region1, region2, region3, region4, region5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIsoColorValues() + +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 returncode = CLIENT_pkgIsothermGetIsoColorValues(table, region0, region1, region2, region3, region4, region5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIsoColorValues() + +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 returncode = CLIENT_pkgIsothermSetRegionMode(table, region0, region1, region2, region3, region4, region5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRegionMode() + +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 returncode = CLIENT_pkgIsothermGetRegionMode(table, region0, region1, region2, region3, region4, region5); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRegionMode() + +FLR_RESULT isothermGetUnit(FLR_ISOTHERM_UNIT_E *unit){ + FLR_RESULT returncode = CLIENT_pkgIsothermGetUnit(unit); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUnit() + +FLR_RESULT isothermSetUnit(const FLR_ISOTHERM_UNIT_E unit){ + FLR_RESULT returncode = CLIENT_pkgIsothermSetUnit(unit); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetUnit() + +FLR_RESULT isothermGetSettingsLowGain(FLR_ISOTHERM_SETTINGS_T *settings){ + FLR_RESULT returncode = CLIENT_pkgIsothermGetSettingsLowGain(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSettingsLowGain() + +FLR_RESULT isothermSetSettingsLowGain(const FLR_ISOTHERM_SETTINGS_T settings){ + FLR_RESULT returncode = CLIENT_pkgIsothermSetSettingsLowGain(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSettingsLowGain() + +FLR_RESULT isothermGetSettingsHighGain(FLR_ISOTHERM_SETTINGS_T *settings){ + FLR_RESULT returncode = CLIENT_pkgIsothermGetSettingsHighGain(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSettingsHighGain() + +FLR_RESULT isothermSetSettingsHighGain(const FLR_ISOTHERM_SETTINGS_T settings){ + FLR_RESULT returncode = CLIENT_pkgIsothermSetSettingsHighGain(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSettingsHighGain() + +FLR_RESULT isothermSetColorLutId(const FLR_COLORLUT_ID_E colorLutIdLowGain, const FLR_COLORLUT_ID_E colorLutIdHighGain){ + FLR_RESULT returncode = CLIENT_pkgIsothermSetColorLutId(colorLutIdLowGain, colorLutIdHighGain); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetColorLutId() + +FLR_RESULT isothermGetColorLutId(FLR_COLORLUT_ID_E *colorLutIdLowGain, FLR_COLORLUT_ID_E *colorLutIdHighGain){ + FLR_RESULT returncode = CLIENT_pkgIsothermGetColorLutId(colorLutIdLowGain, colorLutIdHighGain); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetColorLutId() + +FLR_RESULT jffs2Mount(){ + FLR_RESULT returncode = CLIENT_pkgJffs2Mount(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Mount() + +FLR_RESULT jffs2Unmount(){ + FLR_RESULT returncode = CLIENT_pkgJffs2Unmount(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Unmount() + +FLR_RESULT jffs2GetState(FLR_JFFS2_STATE_E *state){ + FLR_RESULT returncode = CLIENT_pkgJffs2GetState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetState() + +FLR_RESULT latencyCtrlSetLowLatencyState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlSetLowLatencyState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLowLatencyState() + +FLR_RESULT latencyCtrlGetLowLatencyState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlGetLowLatencyState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLowLatencyState() + +FLR_RESULT latencyCtrlSetJitterReduction(const FLR_ENABLE_E enable, const int32_t line){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlSetJitterReduction(enable, line); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetJitterReduction() + +FLR_RESULT latencyCtrlGetJitterReduction(FLR_ENABLE_E *enable, int32_t *line){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlGetJitterReduction(enable, line); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetJitterReduction() + +FLR_RESULT latencyCtrlLatencyResetStats(){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlLatencyResetStats(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of LatencyResetStats() + +FLR_RESULT latencyCtrlGetJitter(float *jitterMin, float *jitterMax){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlGetJitter(jitterMin, jitterMax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetJitter() + +FLR_RESULT latencyCtrlGetLatency(float *latencyMin, float *latencyMax){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlGetLatency(latencyMin, latencyMax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLatency() + +FLR_RESULT latencyCtrlSetUsbVideoLatencyReduction(const int32_t line){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction(line); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetUsbVideoLatencyReduction() + +FLR_RESULT latencyCtrlGetUsbVideoLatencyReduction(int32_t *line){ + FLR_RESULT returncode = CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction(line); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUsbVideoLatencyReduction() + +FLR_RESULT lfsrSetApplyOffsetEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetApplyOffsetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetApplyOffsetEnableState() + +FLR_RESULT lfsrGetApplyOffsetEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetApplyOffsetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetApplyOffsetEnableState() + +FLR_RESULT lfsrSetMaxIterations(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetMaxIterations(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxIterations() + +FLR_RESULT lfsrGetMaxIterations(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetMaxIterations(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxIterations() + +FLR_RESULT lfsrSetDf(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetDf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDf() + +FLR_RESULT lfsrGetDf(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetDf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDf() + +FLR_RESULT lfsrSetLambda1(const float data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetLambda1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLambda1() + +FLR_RESULT lfsrGetLambda1(float *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetLambda1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLambda1() + +FLR_RESULT lfsrSetLambda2(const float data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetLambda2(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLambda2() + +FLR_RESULT lfsrGetLambda2(float *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetLambda2(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLambda2() + +FLR_RESULT lfsrSetHaltEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetHaltEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetHaltEnable() + +FLR_RESULT lfsrGetHaltEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetHaltEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetHaltEnable() + +FLR_RESULT lfsrSetRandomMethod(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetRandomMethod(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRandomMethod() + +FLR_RESULT lfsrGetRandomMethod(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetRandomMethod(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRandomMethod() + +FLR_RESULT lfsrSetSingleStepEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetSingleStepEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSingleStepEnable() + +FLR_RESULT lfsrGetSingleStepEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetSingleStepEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSingleStepEnable() + +FLR_RESULT lfsrSetR_LocalBump(const float data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetR_LocalBump(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetR_LocalBump() + +FLR_RESULT lfsrGetR_LocalBump(float *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetR_LocalBump(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetR_LocalBump() + +FLR_RESULT lfsrSetR_CornerBump(const float data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetR_CornerBump(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetR_CornerBump() + +FLR_RESULT lfsrGetR_CornerBump(float *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetR_CornerBump(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetR_CornerBump() + +FLR_RESULT lfsrSetFFC_ResetEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetFFC_ResetEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFFC_ResetEnable() + +FLR_RESULT lfsrGetFFC_ResetEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetFFC_ResetEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFFC_ResetEnable() + +FLR_RESULT lfsrSetNormalizeAtCenterSpotState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgLfsrSetNormalizeAtCenterSpotState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNormalizeAtCenterSpotState() + +FLR_RESULT lfsrGetNormalizeAtCenterSpotState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgLfsrGetNormalizeAtCenterSpotState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNormalizeAtCenterSpotState() + +FLR_RESULT memReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){ + if (sizeInBytes > MaxMemoryChunk) + { + return FLR_DATA_SIZE_ERROR; + } + FLR_RESULT returncode = CLIENT_pkgMemReadCapture(bufferNum, offset, sizeInBytes, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReadCapture() + +FLR_RESULT memGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns){ + FLR_RESULT returncode = CLIENT_pkgMemGetCaptureSize(bytes, rows, columns); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCaptureSize() + +FLR_RESULT memWriteFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){ + if (sizeInBytes > MaxMemoryChunk) + { + return FLR_DATA_SIZE_ERROR; + } + FLR_RESULT returncode = CLIENT_pkgMemWriteFlash(location, index, offset, sizeInBytes, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of WriteFlash() + +FLR_RESULT memReadFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){ + if (sizeInBytes > MaxMemoryChunk) + { + return FLR_DATA_SIZE_ERROR; + } + FLR_RESULT returncode = CLIENT_pkgMemReadFlash(location, index, offset, sizeInBytes, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReadFlash() + +FLR_RESULT memGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes){ + FLR_RESULT returncode = CLIENT_pkgMemGetFlashSize(location, bytes); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFlashSize() + +FLR_RESULT memEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index){ + FLR_RESULT returncode = CLIENT_pkgMemEraseFlash(location, index); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of EraseFlash() + +FLR_RESULT memEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length){ + FLR_RESULT returncode = CLIENT_pkgMemEraseFlashPartial(location, index, offset, length); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of EraseFlashPartial() + +FLR_RESULT memReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){ + if (sizeInBytes > MaxMemoryChunk) + { + return FLR_DATA_SIZE_ERROR; + } + FLR_RESULT returncode = CLIENT_pkgMemReadCurrentGain(offset, sizeInBytes, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReadCurrentGain() + +FLR_RESULT memGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns){ + FLR_RESULT returncode = CLIENT_pkgMemGetGainSize(bytes, rows, columns); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGainSize() + +FLR_RESULT memGetCaptureSizeSrc(const FLR_CAPTURE_SRC_E src, uint32_t *bytes, uint16_t *rows, uint16_t *columns){ + FLR_RESULT returncode = CLIENT_pkgMemGetCaptureSizeSrc(src, bytes, rows, columns); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCaptureSizeSrc() + +FLR_RESULT memReadCaptureSrc(const FLR_CAPTURE_SRC_E src, const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){ + if (sizeInBytes > MaxMemoryChunk) + { + return FLR_DATA_SIZE_ERROR; + } + FLR_RESULT returncode = CLIENT_pkgMemReadCaptureSrc(src, bufferNum, offset, sizeInBytes, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReadCaptureSrc() + +FLR_RESULT radiometrySetTempStableEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempStableEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempStableEnable() + +FLR_RESULT radiometryGetTempStableEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempStableEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempStableEnable() + +FLR_RESULT radiometrySetFNumberLens0(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetFNumberLens0(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFNumberLens0() + +FLR_RESULT radiometryGetFNumberLens0(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetFNumberLens0(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFNumberLens0() + +FLR_RESULT radiometrySetFNumberLens1(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetFNumberLens1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFNumberLens1() + +FLR_RESULT radiometryGetFNumberLens1(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetFNumberLens1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFNumberLens1() + +FLR_RESULT radiometrySetTauLens0(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTauLens0(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTauLens0() + +FLR_RESULT radiometryGetTauLens0(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTauLens0(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTauLens0() + +FLR_RESULT radiometrySetTauLens1(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTauLens1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTauLens1() + +FLR_RESULT radiometryGetTauLens1(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTauLens1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTauLens1() + +FLR_RESULT radiometryGetGlobalGainDesired(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalGainDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalGainDesired() + +FLR_RESULT radiometryGetGlobalOffsetDesired(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalOffsetDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalOffsetDesired() + +FLR_RESULT radiometryGetGlobalGainApplied(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalGainApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalGainApplied() + +FLR_RESULT radiometryGetGlobalOffsetApplied(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalOffsetApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalOffsetApplied() + +FLR_RESULT radiometrySetTComponentOverrideMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTComponentOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTComponentOverrideMode() + +FLR_RESULT radiometryGetTComponentOverrideMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTComponentOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTComponentOverrideMode() + +FLR_RESULT radiometrySetGlobalGainOverride(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetGlobalGainOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGlobalGainOverride() + +FLR_RESULT radiometryGetGlobalGainOverride(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalGainOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalGainOverride() + +FLR_RESULT radiometrySetGlobalOffsetOverride(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetGlobalOffsetOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGlobalOffsetOverride() + +FLR_RESULT radiometryGetGlobalOffsetOverride(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalOffsetOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalOffsetOverride() + +FLR_RESULT radiometrySetGlobalParamOverrideMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetGlobalParamOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGlobalParamOverrideMode() + +FLR_RESULT radiometryGetGlobalParamOverrideMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGlobalParamOverrideMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGlobalParamOverrideMode() + +FLR_RESULT radiometrySetRBFOHighGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetRBFOHighGainDefault(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRBFOHighGainDefault() + +FLR_RESULT radiometryGetRBFOHighGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRBFOHighGainDefault(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRBFOHighGainDefault() + +FLR_RESULT radiometrySetRBFOLowGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetRBFOLowGainDefault(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRBFOLowGainDefault() + +FLR_RESULT radiometryGetRBFOLowGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRBFOLowGainDefault(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRBFOLowGainDefault() + +FLR_RESULT radiometrySetRBFOHighGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetRBFOHighGainFactory(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRBFOHighGainFactory() + +FLR_RESULT radiometryGetRBFOHighGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRBFOHighGainFactory(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRBFOHighGainFactory() + +FLR_RESULT radiometrySetRBFOLowGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetRBFOLowGainFactory(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRBFOLowGainFactory() + +FLR_RESULT radiometryGetRBFOLowGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRBFOLowGainFactory(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRBFOLowGainFactory() + +FLR_RESULT radiometrySetDampingFactor(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetDampingFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDampingFactor() + +FLR_RESULT radiometryGetDampingFactor(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetDampingFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDampingFactor() + +FLR_RESULT radiometryGetGoMEQ(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGoMEQ(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGoMEQ() + +FLR_RESULT radiometryGetGoMShutter(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGoMShutter(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGoMShutter() + +FLR_RESULT radiometryGetGoMLens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGoMLens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGoMLens() + +FLR_RESULT radiometryGetGoMLG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGoMLG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGoMLG() + +FLR_RESULT radiometryGetGoMFFC(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGoMFFC(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGoMFFC() + +FLR_RESULT radiometryGetTempLensHousing(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempLensHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempLensHousing() + +FLR_RESULT radiometryGetTempShutterHousing(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempShutterHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempShutterHousing() + +FLR_RESULT radiometryGetTempShutterPaddle(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempShutterPaddle(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempShutterPaddle() + +FLR_RESULT radiometrySetFNumberShutterHousing(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetFNumberShutterHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFNumberShutterHousing() + +FLR_RESULT radiometryGetFNumberShutterHousing(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetFNumberShutterHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFNumberShutterHousing() + +FLR_RESULT radiometrySetEmissivityShutterHousing(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetEmissivityShutterHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEmissivityShutterHousing() + +FLR_RESULT radiometryGetEmissivityShutterHousing(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetEmissivityShutterHousing(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEmissivityShutterHousing() + +FLR_RESULT radiometrySetM_DTfpa_Lens(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_DTfpa_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_DTfpa_Lens() + +FLR_RESULT radiometryGetM_DTfpa_Lens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_DTfpa_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_DTfpa_Lens() + +FLR_RESULT radiometrySetOffset_Lens(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetOffset_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOffset_Lens() + +FLR_RESULT radiometryGetOffset_Lens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetOffset_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOffset_Lens() + +FLR_RESULT radiometrySetM_Recursive_Lens(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Recursive_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Recursive_Lens() + +FLR_RESULT radiometryGetM_Recursive_Lens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Recursive_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Recursive_Lens() + +FLR_RESULT radiometryGetGgFfc(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGgFfc(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGgFfc() + +FLR_RESULT radiometryGetCountsFromTemp(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const float temp, uint16_t *counts){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetCountsFromTemp(rbfoType, temp, counts); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCountsFromTemp() + +FLR_RESULT radiometryGetTempFromCounts(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const uint16_t counts, float *temp){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempFromCounts(rbfoType, counts, temp); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempFromCounts() + +FLR_RESULT radiometrySetTempLensHousingOverride(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempLensHousingOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempLensHousingOverride() + +FLR_RESULT radiometryGetTempLensHousingOverride(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempLensHousingOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempLensHousingOverride() + +FLR_RESULT radiometrySetTempShutterHousingOverride(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempShutterHousingOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempShutterHousingOverride() + +FLR_RESULT radiometryGetTempShutterHousingOverride(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempShutterHousingOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempShutterHousingOverride() + +FLR_RESULT radiometrySetTempShutterPaddleOverride(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempShutterPaddleOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempShutterPaddleOverride() + +FLR_RESULT radiometryGetTempShutterPaddleOverride(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempShutterPaddleOverride(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempShutterPaddleOverride() + +FLR_RESULT radiometrySetSignalFactorLut(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetSignalFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSignalFactorLut() + +FLR_RESULT radiometryGetSignalFactorLut(FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetSignalFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSignalFactorLut() + +FLR_RESULT radiometrySetNoiseFactorLut(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetNoiseFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNoiseFactorLut() + +FLR_RESULT radiometryGetNoiseFactorLut(FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetNoiseFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNoiseFactorLut() + +FLR_RESULT radiometrySetM_tfpaK(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_tfpaK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_tfpaK() + +FLR_RESULT radiometryGetM_tfpaK(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_tfpaK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_tfpaK() + +FLR_RESULT radiometrySetB_tfpaK(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_tfpaK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_tfpaK() + +FLR_RESULT radiometryGetB_tfpaK(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_tfpaK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_tfpaK() + +FLR_RESULT radiometrySetTAuxParams(const FLR_RADIOMETRY_TAUX_PARAMS_T data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTAuxParams(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTAuxParams() + +FLR_RESULT radiometryGetTAuxParams(FLR_RADIOMETRY_TAUX_PARAMS_T *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTAuxParams(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTAuxParams() + +FLR_RESULT radiometrySetM_tAux(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_tAux(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_tAux() + +FLR_RESULT radiometryGetM_tAux(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_tAux(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_tAux() + +FLR_RESULT radiometrySetB_tAux(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_tAux(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_tAux() + +FLR_RESULT radiometryGetB_tAux(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_tAux(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_tAux() + +FLR_RESULT radiometrySetTsource_FFC(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTsource_FFC(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTsource_FFC() + +FLR_RESULT radiometryGetTsource_FFC(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTsource_FFC(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTsource_FFC() + +FLR_RESULT radiometrySetM_DTfpa_Sh_h(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_DTfpa_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_DTfpa_Sh_h() + +FLR_RESULT radiometryGetM_DTfpa_Sh_h(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_DTfpa_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_DTfpa_Sh_h() + +FLR_RESULT radiometrySetOffset_Sh_h(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetOffset_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOffset_Sh_h() + +FLR_RESULT radiometryGetOffset_Sh_h(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetOffset_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOffset_Sh_h() + +FLR_RESULT radiometrySetM_Recursive_Sh_h(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Recursive_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Recursive_Sh_h() + +FLR_RESULT radiometryGetM_Recursive_Sh_h(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Recursive_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Recursive_Sh_h() + +FLR_RESULT radiometrySetM_DTfpa_Sh_p(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_DTfpa_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_DTfpa_Sh_p() + +FLR_RESULT radiometryGetM_DTfpa_Sh_p(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_DTfpa_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_DTfpa_Sh_p() + +FLR_RESULT radiometrySetOffset_Sh_p(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetOffset_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOffset_Sh_p() + +FLR_RESULT radiometryGetOffset_Sh_p(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetOffset_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOffset_Sh_p() + +FLR_RESULT radiometrySetM_Recursive_Sh_p(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Recursive_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Recursive_Sh_p() + +FLR_RESULT radiometryGetM_Recursive_Sh_p(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Recursive_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Recursive_Sh_p() + +FLR_RESULT radiometrySetM_Delta_Sh_p(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_p() + +FLR_RESULT radiometryGetM_Delta_Sh_p(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_p() + +FLR_RESULT radiometrySetB_Delta_Sh_p(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_p() + +FLR_RESULT radiometryGetB_Delta_Sh_p(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_p(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_p() + +FLR_RESULT radiometryGetDtTfpaK(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetDtTfpaK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDtTfpaK() + +FLR_RESULT radiometryGetDtTfpaK_Damp(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetDtTfpaK_Damp(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDtTfpaK_Damp() + +FLR_RESULT radiometryGetTAuxK(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTAuxK(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTAuxK() + +FLR_RESULT radiometrySetExternalFfcUpdateMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetExternalFfcUpdateMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetExternalFfcUpdateMode() + +FLR_RESULT radiometryGetExternalFfcUpdateMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetExternalFfcUpdateMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetExternalFfcUpdateMode() + +FLR_RESULT radiometryGetGG_scale(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGG_scale(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGG_scale() + +FLR_RESULT radiometrySetTempWindow(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempWindow() + +FLR_RESULT radiometryGetTempWindow(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempWindow() + +FLR_RESULT radiometrySetTransmissionWindow(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTransmissionWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTransmissionWindow() + +FLR_RESULT radiometryGetTransmissionWindow(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTransmissionWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTransmissionWindow() + +FLR_RESULT radiometrySetReflectivityWindow(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetReflectivityWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetReflectivityWindow() + +FLR_RESULT radiometryGetReflectivityWindow(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetReflectivityWindow(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetReflectivityWindow() + +FLR_RESULT radiometrySetTempWindowReflection(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempWindowReflection(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempWindowReflection() + +FLR_RESULT radiometryGetTempWindowReflection(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempWindowReflection(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempWindowReflection() + +FLR_RESULT radiometrySetTransmissionAtmosphere(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTransmissionAtmosphere(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTransmissionAtmosphere() + +FLR_RESULT radiometryGetTransmissionAtmosphere(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTransmissionAtmosphere(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTransmissionAtmosphere() + +FLR_RESULT radiometrySetTempAtmosphere(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempAtmosphere(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempAtmosphere() + +FLR_RESULT radiometryGetTempAtmosphere(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempAtmosphere(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempAtmosphere() + +FLR_RESULT radiometrySetEmissivityTarget(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetEmissivityTarget(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEmissivityTarget() + +FLR_RESULT radiometryGetEmissivityTarget(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetEmissivityTarget(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEmissivityTarget() + +FLR_RESULT radiometrySetTempBackground(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTempBackground(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempBackground() + +FLR_RESULT radiometryGetTempBackground(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTempBackground(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempBackground() + +FLR_RESULT radiometryGetRadiometryCapable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRadiometryCapable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRadiometryCapable() + +FLR_RESULT radiometrySetdeltaTempDampingFactor(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetdeltaTempDampingFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetdeltaTempDampingFactor() + +FLR_RESULT radiometryGetdeltaTempDampingFactor(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetdeltaTempDampingFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetdeltaTempDampingFactor() + +FLR_RESULT radiometrySetdeltaTempIntervalTime(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetdeltaTempIntervalTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetdeltaTempIntervalTime() + +FLR_RESULT radiometryGetdeltaTempIntervalTime(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetdeltaTempIntervalTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetdeltaTempIntervalTime() + +FLR_RESULT radiometrySetdeltaTempMaxValue(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetdeltaTempMaxValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetdeltaTempMaxValue() + +FLR_RESULT radiometryGetdeltaTempMaxValue(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetdeltaTempMaxValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetdeltaTempMaxValue() + +FLR_RESULT radiometrySetdeltaTempMaxIncrement(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetdeltaTempMaxIncrement(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetdeltaTempMaxIncrement() + +FLR_RESULT radiometryGetdeltaTempMaxIncrement(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetdeltaTempMaxIncrement(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetdeltaTempMaxIncrement() + +FLR_RESULT radiometrySetdeltaTempDampingTime(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetdeltaTempDampingTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetdeltaTempDampingTime() + +FLR_RESULT radiometryGetdeltaTempDampingTime(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetdeltaTempDampingTime(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetdeltaTempDampingTime() + +FLR_RESULT radiometryGetResponsivityFpaTemp(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetResponsivityFpaTemp(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetResponsivityFpaTemp() + +FLR_RESULT radiometrySetM_Delta_Lens(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Lens() + +FLR_RESULT radiometryGetM_Delta_Lens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Lens() + +FLR_RESULT radiometrySetB_Delta_Lens(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Lens() + +FLR_RESULT radiometryGetB_Delta_Lens(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Lens(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Lens() + +FLR_RESULT radiometrySetM_Delta_Sh_h(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_h() + +FLR_RESULT radiometryGetM_Delta_Sh_h(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_h() + +FLR_RESULT radiometrySetB_Delta_Sh_h(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_h() + +FLR_RESULT radiometryGetB_Delta_Sh_h(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_h(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_h() + +FLR_RESULT radiometrySetGG_Scale_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetGG_Scale_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGG_Scale_HG() + +FLR_RESULT radiometryGetGG_Scale_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGG_Scale_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGG_Scale_HG() + +FLR_RESULT radiometrySetGG_Scale_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetGG_Scale_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetGG_Scale_LG() + +FLR_RESULT radiometryGetGG_Scale_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGG_Scale_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGG_Scale_LG() + +FLR_RESULT radiometrySetRbfoScaledMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetRbfoScaledMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRbfoScaledMode() + +FLR_RESULT radiometryGetRbfoScaledMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetRbfoScaledMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRbfoScaledMode() + +FLR_RESULT radiometryGetUncertaintyFactor(FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetUncertaintyFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUncertaintyFactor() + +FLR_RESULT radiometryGetTRoomMinThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTRoomMinThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTRoomMinThresh() + +FLR_RESULT radiometryGetTRoomMaxThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTRoomMaxThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTRoomMaxThresh() + +FLR_RESULT radiometryGetTOperatingMinThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTOperatingMinThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTOperatingMinThresh() + +FLR_RESULT radiometryGetTOperatingMaxThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTOperatingMaxThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTOperatingMaxThresh() + +FLR_RESULT radiometryGetStableTempThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetStableTempThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStableTempThresh() + +FLR_RESULT radiometryGetSlowDriftThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetSlowDriftThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSlowDriftThresh() + +FLR_RESULT radiometryGetFfcTempThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetFfcTempThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFfcTempThresh() + +FLR_RESULT radiometryGetTargetTempMinThreshLG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTargetTempMinThreshLG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTargetTempMinThreshLG() + +FLR_RESULT radiometryGetTargetTempMaxThreshLG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTargetTempMaxThreshLG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTargetTempMaxThreshLG() + +FLR_RESULT radiometryGetMFactorThresh(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetMFactorThresh(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMFactorThresh() + +FLR_RESULT radiometryGetTargetTempMinThreshHG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTargetTempMinThreshHG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTargetTempMinThreshHG() + +FLR_RESULT radiometryGetTargetTempMaxThreshHG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTargetTempMaxThreshHG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTargetTempMaxThreshHG() + +FLR_RESULT radiometryGetUncertaintyStatusBits(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetUncertaintyStatusBits(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUncertaintyStatusBits() + +FLR_RESULT radiometrySetTemperatureOffset_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTemperatureOffset_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTemperatureOffset_HG() + +FLR_RESULT radiometryGetTemperatureOffset_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTemperatureOffset_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTemperatureOffset_HG() + +FLR_RESULT radiometrySetTemperatureOffset_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetTemperatureOffset_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTemperatureOffset_LG() + +FLR_RESULT radiometryGetTemperatureOffset_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetTemperatureOffset_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTemperatureOffset_LG() + +FLR_RESULT radiometrySetM_Delta_Lens_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Lens_HG() + +FLR_RESULT radiometryGetM_Delta_Lens_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Lens_HG() + +FLR_RESULT radiometrySetB_Delta_Lens_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Lens_HG() + +FLR_RESULT radiometryGetB_Delta_Lens_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Lens_HG() + +FLR_RESULT radiometrySetM_Delta_Lens_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Lens_LG() + +FLR_RESULT radiometryGetM_Delta_Lens_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Lens_LG() + +FLR_RESULT radiometrySetB_Delta_Lens_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Lens_LG() + +FLR_RESULT radiometryGetB_Delta_Lens_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Lens_LG() + +FLR_RESULT radiometrySetOffset_Lens_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetOffset_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOffset_Lens_HG() + +FLR_RESULT radiometryGetOffset_Lens_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetOffset_Lens_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOffset_Lens_HG() + +FLR_RESULT radiometrySetOffset_Lens_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetOffset_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOffset_Lens_LG() + +FLR_RESULT radiometryGetOffset_Lens_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetOffset_Lens_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOffset_Lens_LG() + +FLR_RESULT radiometrySetM_Delta_Sh_p_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_p_HG() + +FLR_RESULT radiometryGetM_Delta_Sh_p_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_p_HG() + +FLR_RESULT radiometrySetB_Delta_Sh_p_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_p_HG() + +FLR_RESULT radiometryGetB_Delta_Sh_p_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_p_HG() + +FLR_RESULT radiometrySetM_Delta_Sh_p_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_p_LG() + +FLR_RESULT radiometryGetM_Delta_Sh_p_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_p_LG() + +FLR_RESULT radiometrySetB_Delta_Sh_p_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_p_LG() + +FLR_RESULT radiometryGetB_Delta_Sh_p_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_p_LG() + +FLR_RESULT radiometrySetM_Delta_Sh_h_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_h_HG() + +FLR_RESULT radiometryGetM_Delta_Sh_h_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_h_HG() + +FLR_RESULT radiometrySetB_Delta_Sh_h_HG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_h_HG() + +FLR_RESULT radiometryGetB_Delta_Sh_h_HG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_h_HG() + +FLR_RESULT radiometrySetM_Delta_Sh_h_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_Delta_Sh_h_LG() + +FLR_RESULT radiometryGetM_Delta_Sh_h_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_Delta_Sh_h_LG() + +FLR_RESULT radiometrySetB_Delta_Sh_h_LG(const float data){ + FLR_RESULT returncode = CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetB_Delta_Sh_h_LG() + +FLR_RESULT radiometryGetB_Delta_Sh_h_LG(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetB_Delta_Sh_h_LG() + +FLR_RESULT radiometryGetGG_RoomTemp(float *data){ + FLR_RESULT returncode = CLIENT_pkgRadiometryGetGG_RoomTemp(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetGG_RoomTemp() + +FLR_RESULT roicGetFPATemp(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPATemp(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPATemp() + +FLR_RESULT roicGetFrameCount(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFrameCount(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFrameCount() + +FLR_RESULT roicGetActiveNormalizationTarget(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetActiveNormalizationTarget(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetActiveNormalizationTarget() + +FLR_RESULT roicSetFPARampState(const FLR_ENABLE_E state){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFPARampState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFPARampState() + +FLR_RESULT roicGetFPARampState(FLR_ENABLE_E *state){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPARampState(state); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPARampState() + +FLR_RESULT roicGetSensorADC1(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetSensorADC1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorADC1() + +FLR_RESULT roicGetSensorADC2(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetSensorADC2(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorADC2() + +FLR_RESULT roicSetFPATempOffset(const int16_t data){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempOffset(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFPATempOffset() + +FLR_RESULT roicGetFPATempOffset(int16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempOffset(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPATempOffset() + +FLR_RESULT roicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFPATempMode() + +FLR_RESULT roicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPATempMode() + +FLR_RESULT roicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempTable(table); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPATempTable() + +FLR_RESULT roicSetFPATempValue(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFPATempValue() + +FLR_RESULT roicGetFPATempValue(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempValue(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFPATempValue() + +FLR_RESULT roicGetPreambleError(uint32_t *preambleError){ + FLR_RESULT returncode = CLIENT_pkgRoicGetPreambleError(preambleError); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPreambleError() + +FLR_RESULT roicInducePreambleError(const uint32_t everyNthFrame){ + FLR_RESULT returncode = CLIENT_pkgRoicInducePreambleError(everyNthFrame); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of InducePreambleError() + +FLR_RESULT roicGetRoicStarted(FLR_ENABLE_E *roicStarted){ + FLR_RESULT returncode = CLIENT_pkgRoicGetRoicStarted(roicStarted); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRoicStarted() + +FLR_RESULT roicSetFrameSkip(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFrameSkip(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFrameSkip() + +FLR_RESULT roicGetFrameSkip(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgRoicGetFrameSkip(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFrameSkip() + +FLR_RESULT roicSetFrameOneShot(){ + FLR_RESULT returncode = CLIENT_pkgRoicSetFrameOneShot(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFrameOneShot() + +FLR_RESULT scalerGetMaxZoom(uint32_t *zoom){ + FLR_RESULT returncode = CLIENT_pkgScalerGetMaxZoom(zoom); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxZoom() + +FLR_RESULT scalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams){ + FLR_RESULT returncode = CLIENT_pkgScalerSetZoom(zoomParams); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetZoom() + +FLR_RESULT scalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams){ + FLR_RESULT returncode = CLIENT_pkgScalerGetZoom(zoomParams); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetZoom() + +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 returncode = CLIENT_pkgScalerSetFractionalZoom(zoomNumerator, zoomDenominator, zoomXCenter, zoomYCenter, inChangeEnable, zoomOutXCenter, zoomOutYCenter, outChangeEnable); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFractionalZoom() + +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 returncode = CLIENT_pkgScalerSetIndexZoom(zoomIndex, zoomXCenter, zoomYCenter, inChangeEnable, zoomOutXCenter, zoomOutYCenter, outChangeEnable); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIndexZoom() + +FLR_RESULT scnrSetEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnableState() + +FLR_RESULT scnrGetEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnableState() + +FLR_RESULT scnrSetThColSum(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetThColSum(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThColSum() + +FLR_RESULT scnrGetThColSum(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetThColSum(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThColSum() + +FLR_RESULT scnrSetThPixel(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetThPixel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThPixel() + +FLR_RESULT scnrGetThPixel(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetThPixel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixel() + +FLR_RESULT scnrSetMaxCorr(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetMaxCorr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxCorr() + +FLR_RESULT scnrGetMaxCorr(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetMaxCorr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxCorr() + +FLR_RESULT scnrGetThPixelApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetThPixelApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixelApplied() + +FLR_RESULT scnrGetMaxCorrApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetMaxCorrApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxCorrApplied() + +FLR_RESULT scnrSetThColSumSafe(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetThColSumSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThColSumSafe() + +FLR_RESULT scnrGetThColSumSafe(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetThColSumSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThColSumSafe() + +FLR_RESULT scnrSetThPixelSafe(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetThPixelSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThPixelSafe() + +FLR_RESULT scnrGetThPixelSafe(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetThPixelSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixelSafe() + +FLR_RESULT scnrSetMaxCorrSafe(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetMaxCorrSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxCorrSafe() + +FLR_RESULT scnrGetMaxCorrSafe(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetMaxCorrSafe(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxCorrSafe() + +FLR_RESULT scnrSetCorrectionMethod(const FLR_SCNR_CORR_SELECT_E data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetCorrectionMethod(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetCorrectionMethod() + +FLR_RESULT scnrGetCorrectionMethod(FLR_SCNR_CORR_SELECT_E *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetCorrectionMethod(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCorrectionMethod() + +FLR_RESULT scnrSetStdThreshold(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetStdThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetStdThreshold() + +FLR_RESULT scnrGetStdThreshold(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetStdThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStdThreshold() + +FLR_RESULT scnrSetNFrames(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetNFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNFrames() + +FLR_RESULT scnrGetNFrames(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetNFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNFrames() + +FLR_RESULT scnrSetResetDesired(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetResetDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetResetDesired() + +FLR_RESULT scnrGetResetDesired(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetResetDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetResetDesired() + +FLR_RESULT scnrSetM_modeOnly(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetM_modeOnly(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetM_modeOnly() + +FLR_RESULT scnrGetM_modeOnly(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetM_modeOnly(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetM_modeOnly() + +FLR_RESULT scnrGetMode(FLR_SCNR_MODE_E *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMode() + +FLR_RESULT scnrSetSpecklesEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetSpecklesEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpecklesEnableState() + +FLR_RESULT scnrGetSpecklesEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesEnableState() + +FLR_RESULT scnrSetSpecklesThreshold(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetSpecklesThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpecklesThreshold() + +FLR_RESULT scnrGetSpecklesThreshold(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesThreshold() + +FLR_RESULT scnrSetSpecklesRatio(const float data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetSpecklesRatio(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpecklesRatio() + +FLR_RESULT scnrGetSpecklesRatio(float *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesRatio(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesRatio() + +FLR_RESULT scnrSetSpecklesDF(const float data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetSpecklesDF(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpecklesDF() + +FLR_RESULT scnrGetSpecklesDF(float *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesDF(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesDF() + +FLR_RESULT scnrGetSpecklesDiffsBufferAddr(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesDiffsBufferAddr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesDiffsBufferAddr() + +FLR_RESULT scnrGetSpecklesOffsBufferAddr(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesOffsBufferAddr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesOffsBufferAddr() + +FLR_RESULT scnrSetSpecklesResetDesired(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgScnrSetSpecklesResetDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpecklesResetDesired() + +FLR_RESULT scnrGetSpecklesResetDesired(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgScnrGetSpecklesResetDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpecklesResetDesired() + +FLR_RESULT sffcGetScaleFactor(float *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetScaleFactor(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetScaleFactor() + +FLR_RESULT sffcGetDeltaTempLinearCoeff(float *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetDeltaTempLinearCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDeltaTempLinearCoeff() + +FLR_RESULT sffcSetDeltaTempLinearCoeff(const float data){ + FLR_RESULT returncode = CLIENT_pkgSffcSetDeltaTempLinearCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDeltaTempLinearCoeff() + +FLR_RESULT sffcGetDeltaTempOffsetCoeff(float *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetDeltaTempOffsetCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDeltaTempOffsetCoeff() + +FLR_RESULT sffcSetDeltaTempOffsetCoeff(const float data){ + FLR_RESULT returncode = CLIENT_pkgSffcSetDeltaTempOffsetCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDeltaTempOffsetCoeff() + +FLR_RESULT sffcGetFpaTempLinearCoeff(float *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetFpaTempLinearCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFpaTempLinearCoeff() + +FLR_RESULT sffcSetFpaTempLinearCoeff(const float data){ + FLR_RESULT returncode = CLIENT_pkgSffcSetFpaTempLinearCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFpaTempLinearCoeff() + +FLR_RESULT sffcGetFpaTempOffsetCoeff(float *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetFpaTempOffsetCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFpaTempOffsetCoeff() + +FLR_RESULT sffcSetFpaTempOffsetCoeff(const float data){ + FLR_RESULT returncode = CLIENT_pkgSffcSetFpaTempOffsetCoeff(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFpaTempOffsetCoeff() + +FLR_RESULT sffcGetDeltaTempTimeLimitInSecs(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDeltaTempTimeLimitInSecs() + +FLR_RESULT sffcSetDeltaTempTimeLimitInSecs(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDeltaTempTimeLimitInSecs() + +FLR_RESULT spnrSetEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnableState() + +FLR_RESULT spnrGetEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnableState() + +FLR_RESULT spnrGetState(FLR_SPNR_STATE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetState() + +FLR_RESULT spnrSetFrameDelay(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetFrameDelay(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFrameDelay() + +FLR_RESULT spnrGetFrameDelay(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetFrameDelay(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFrameDelay() + +FLR_RESULT spnrSetSF(const float sf){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetSF(sf); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSF() + +FLR_RESULT spnrGetSF(float *sf){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetSF(sf); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSF() + +FLR_RESULT spnrGetSFApplied(float *sf){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetSFApplied(sf); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSFApplied() + +FLR_RESULT spnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetPSDKernel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPSDKernel() + +FLR_RESULT spnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetPSDKernel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPSDKernel() + +FLR_RESULT spnrSetSFMin(const float sfmin){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetSFMin(sfmin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSFMin() + +FLR_RESULT spnrGetSFMin(float *sfmin){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetSFMin(sfmin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSFMin() + +FLR_RESULT spnrSetSFMax(const float sfmax){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetSFMax(sfmax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSFMax() + +FLR_RESULT spnrGetSFMax(float *sfmax){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetSFMax(sfmax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSFMax() + +FLR_RESULT spnrSetDFMin(const float dfmin){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetDFMin(dfmin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDFMin() + +FLR_RESULT spnrGetDFMin(float *dfmin){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetDFMin(dfmin); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDFMin() + +FLR_RESULT spnrSetDFMax(const float dfmax){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetDFMax(dfmax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDFMax() + +FLR_RESULT spnrGetDFMax(float *dfmax){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetDFMax(dfmax); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDFMax() + +FLR_RESULT spnrSetNormTarget(const float normTarget){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetNormTarget(normTarget); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetNormTarget() + +FLR_RESULT spnrGetNormTarget(float *normTarget){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetNormTarget(normTarget); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNormTarget() + +FLR_RESULT spnrGetNormTargetApplied(float *normTargetApplied){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetNormTargetApplied(normTargetApplied); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetNormTargetApplied() + +FLR_RESULT spnrSetThPix(const uint16_t th_pix){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetThPix(th_pix); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThPix() + +FLR_RESULT spnrGetThPix(uint16_t *th_pix){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetThPix(th_pix); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPix() + +FLR_RESULT spnrSetThPixSum(const uint16_t th_pixSum){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetThPixSum(th_pixSum); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThPixSum() + +FLR_RESULT spnrGetThPixSum(uint16_t *th_pixSum){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetThPixSum(th_pixSum); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixSum() + +FLR_RESULT spnrSetMaxcorr(const uint16_t maxcorr){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetMaxcorr(maxcorr); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxcorr() + +FLR_RESULT spnrGetMaxcorr(uint16_t *maxcorr){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetMaxcorr(maxcorr); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxcorr() + +FLR_RESULT spnrGetAlgorithm(FLR_SPNR_ALGORITHM_E *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetAlgorithm(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAlgorithm() + +FLR_RESULT spnrSetAlgorithmDesired(const FLR_SPNR_ALGORITHM_E data){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetAlgorithmDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAlgorithmDesired() + +FLR_RESULT spnrGetAlgorithmDesired(FLR_SPNR_ALGORITHM_E *data){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetAlgorithmDesired(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAlgorithmDesired() + +FLR_RESULT spnrSetDFFast(const float dffast){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetDFFast(dffast); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDFFast() + +FLR_RESULT spnrGetDFFast(float *dffast){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetDFFast(dffast); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDFFast() + +FLR_RESULT spnrSetDFSlow(const float dfslow){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetDFSlow(dfslow); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDFSlow() + +FLR_RESULT spnrGetDFSlow(float *dfslow){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetDFSlow(dfslow); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDFSlow() + +FLR_RESULT spnrSetSensitivityThreshold(const float threshold){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetSensitivityThreshold(threshold); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSensitivityThreshold() + +FLR_RESULT spnrGetSensitivityThreshold(float *threshold){ + FLR_RESULT returncode = CLIENT_pkgSpnrGetSensitivityThreshold(threshold); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensitivityThreshold() + +FLR_RESULT spnrSetReset(const FLR_SPNR_RESET_E resetType){ + FLR_RESULT returncode = CLIENT_pkgSpnrSetReset(resetType); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetReset() + +FLR_RESULT spotMeterSetEnable(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterSetEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnable() + +FLR_RESULT spotMeterGetEnable(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetEnable(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnable() + +FLR_RESULT spotMeterGetRoiMaxSize(uint16_t *width, uint16_t *height){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetRoiMaxSize(width, height); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRoiMaxSize() + +FLR_RESULT spotMeterSetRoi(const FLR_ROI_T roi){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterSetRoi(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetRoi() + +FLR_RESULT spotMeterGetRoi(FLR_ROI_T *roi){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetRoi(roi); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRoi() + +FLR_RESULT spotMeterGetSpotStats(uint16_t *mean, uint16_t *deviation, FLR_SPOTMETER_SPOT_PARAM_T *min, FLR_SPOTMETER_SPOT_PARAM_T *max){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetSpotStats(mean, deviation, min, max); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpotStats() + +FLR_RESULT spotMeterSetStatsMode(const FLR_SPOTMETER_STATS_TEMP_MODE_E mode){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterSetStatsMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetStatsMode() + +FLR_RESULT spotMeterGetStatsMode(FLR_SPOTMETER_STATS_TEMP_MODE_E *mode){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetStatsMode(mode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStatsMode() + +FLR_RESULT spotMeterGetTempStats(float *mean, float *deviation, FLR_SPOTMETER_STAT_PARAM_TEMP_T *min, FLR_SPOTMETER_STAT_PARAM_TEMP_T *max){ + FLR_RESULT returncode = CLIENT_pkgSpotmeterGetTempStats(mean, deviation, min, max); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempStats() + +FLR_RESULT srnrSetEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgSrnrSetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnableState() + +FLR_RESULT srnrGetEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnableState() + +FLR_RESULT srnrSetThRowSum(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgSrnrSetThRowSum(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThRowSum() + +FLR_RESULT srnrGetThRowSum(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetThRowSum(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThRowSum() + +FLR_RESULT srnrSetThPixel(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgSrnrSetThPixel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetThPixel() + +FLR_RESULT srnrGetThPixel(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetThPixel(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixel() + +FLR_RESULT srnrSetMaxCorr(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgSrnrSetMaxCorr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMaxCorr() + +FLR_RESULT srnrGetMaxCorr(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetMaxCorr(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxCorr() + +FLR_RESULT srnrGetThPixelApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetThPixelApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetThPixelApplied() + +FLR_RESULT srnrGetMaxCorrApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSrnrGetMaxCorrApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxCorrApplied() + +FLR_RESULT symbologySetEnable(const FLR_ENABLE_E draw_symbols){ + FLR_RESULT returncode = CLIENT_pkgSymbologySetEnable(draw_symbols); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnable() + +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 returncode = CLIENT_pkgSymbologyCreateBitmap(ID, pos_X, pos_Y, width, height); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateBitmap() + +FLR_RESULT symbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[]){ + FLR_RESULT returncode = CLIENT_pkgSymbologySendData(ID, size, text); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SendData() + +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 returncode = CLIENT_pkgSymbologyCreateArc(ID, pos_X, pos_Y, width, height, start_angle, end_angle, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateArc() + +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 returncode = CLIENT_pkgSymbologyCreateText(ID, pos_X, pos_Y, width, height, font, size, alignment, color, text); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateText() + +FLR_RESULT symbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyMoveSprite(ID, pos_X, pos_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of MoveSprite() + +FLR_RESULT symbologyAddToGroup(const uint8_t ID, const uint8_t group_ID){ + FLR_RESULT returncode = CLIENT_pkgSymbologyAddToGroup(ID, group_ID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of AddToGroup() + +FLR_RESULT symbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID){ + FLR_RESULT returncode = CLIENT_pkgSymbologyRemoveFromGroup(ID, group_ID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of RemoveFromGroup() + +FLR_RESULT symbologyUpdateAndShow(const uint8_t ID, const uint8_t visible){ + FLR_RESULT returncode = CLIENT_pkgSymbologyUpdateAndShow(ID, visible); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of UpdateAndShow() + +FLR_RESULT symbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible){ + FLR_RESULT returncode = CLIENT_pkgSymbologyUpdateAndShowGroup(group_ID, visible); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of UpdateAndShowGroup() + +FLR_RESULT symbologyDelete(const uint8_t ID){ + FLR_RESULT returncode = CLIENT_pkgSymbologyDelete(ID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of Delete() + +FLR_RESULT symbologyDeleteGroup(const uint8_t group_ID){ + FLR_RESULT returncode = CLIENT_pkgSymbologyDeleteGroup(group_ID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of DeleteGroup() + +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 returncode = CLIENT_pkgSymbologyCreateFilledRectangle(ID, pos_X, pos_Y, width, height, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateFilledRectangle() + +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 returncode = CLIENT_pkgSymbologyCreateOutlinedRectangle(ID, pos_X, pos_Y, width, height, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateOutlinedRectangle() + +FLR_RESULT symbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size){ + FLR_RESULT returncode = CLIENT_pkgSymbologyCreateBitmapFromPng(ID, pos_X, pos_Y, size); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateBitmapFromPng() + +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 returncode = CLIENT_pkgSymbologyCreateCompressedBitmap(ID, pos_X, pos_Y, width, height); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateCompressedBitmap() + +FLR_RESULT symbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[]){ + FLR_RESULT returncode = CLIENT_pkgSymbologyCreateBitmapFromPngFile(ID, pos_X, pos_Y, path); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateBitmapFromPngFile() + +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 returncode = CLIENT_pkgSymbologyCreateBitmapFromFile(ID, pos_X, pos_Y, path, imageType); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateBitmapFromFile() + +FLR_RESULT symbologyResetWritePosition(const uint8_t ID){ + FLR_RESULT returncode = CLIENT_pkgSymbologyResetWritePosition(ID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ResetWritePosition() + +FLR_RESULT symbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyMoveByOffset(ID, off_X, off_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of MoveByOffset() + +FLR_RESULT symbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyMoveGroupByOffset(ID, off_X, off_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of MoveGroupByOffset() + +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 returncode = CLIENT_pkgSymbologyCreateFilledEllipse(ID, pos_X, pos_Y, width, height, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateFilledEllipse() + +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 returncode = CLIENT_pkgSymbologyCreateLine(ID, pos_X, pos_Y, pos_X2, pos_Y2, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateLine() + +FLR_RESULT symbologySetZorder(const uint8_t ID, const uint8_t zorder){ + FLR_RESULT returncode = CLIENT_pkgSymbologySetZorder(ID, zorder); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetZorder() + +FLR_RESULT symbologySaveConfiguration(){ + FLR_RESULT returncode = CLIENT_pkgSymbologySaveConfiguration(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SaveConfiguration() + +FLR_RESULT symbologyReloadConfiguration(){ + FLR_RESULT returncode = CLIENT_pkgSymbologyReloadConfiguration(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of ReloadConfiguration() + +FLR_RESULT symbologyGetEnable(FLR_ENABLE_E *draw_symbols){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetEnable(draw_symbols); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnable() + +FLR_RESULT symbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones){ + FLR_RESULT returncode = CLIENT_pkgSymbologySetClonesNumber(ID, numberOfClones); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetClonesNumber() + +FLR_RESULT symbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyMoveCloneByOffset(ID, cloneID, pos_X, pos_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of MoveCloneByOffset() + +FLR_RESULT symbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyMoveCloneSprite(ID, cloneID, pos_X, pos_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of MoveCloneSprite() + +FLR_RESULT symbologySetTransformation(const FLR_SYMBOLOGY_TRANSFORMATION_E transformation){ + FLR_RESULT returncode = CLIENT_pkgSymbologySetTransformation(transformation); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTransformation() + +FLR_RESULT symbologyUpdateAllVisible(){ + FLR_RESULT returncode = CLIENT_pkgSymbologyUpdateAllVisible(); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of UpdateAllVisible() + +FLR_RESULT symbologySetSizeAndScalingMode(const uint8_t ID, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode){ + FLR_RESULT returncode = CLIENT_pkgSymbologySetSizeAndScalingMode(ID, width, height, scalingMode); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSizeAndScalingMode() + +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 returncode = CLIENT_pkgSymbologyCreateLineHVT(ID, pos_X, pos_Y, pos_X2, pos_Y2, color1, color2, dashLen, thickness); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateLineHVT() + +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 returncode = CLIENT_pkgSymbologyCreateTextHVT(ID, pos_X, pos_Y, width, height, font, size, alignment, color1, color2, dashLen, text); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateTextHVT() + +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 returncode = CLIENT_pkgSymbologyCreateTextBg(ID, pos_X, pos_Y, width, height, font, size, alignment, color, bgColor, text); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateTextBg() + +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 returncode = CLIENT_pkgSymbologyCreateScaledBitmapFromFile(ID, pos_X, pos_Y, width, height, scalingMode, path, imageType); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CreateScaledBitmapFromFile() + +FLR_RESULT symbologyGetLocation(const uint8_t ID, int16_t *pos_X, int16_t *pos_Y){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetLocation(ID, pos_X, pos_Y); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLocation() + +FLR_RESULT symbologyGetSize(const uint8_t ID, int16_t *width, int16_t *height){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetSize(ID, width, height); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSize() + +FLR_RESULT symbologyGetZorder(const uint8_t ID, uint8_t *zorder){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetZorder(ID, zorder); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetZorder() + +FLR_RESULT symbologyGetColor(const uint8_t ID, uint32_t *color){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetColor(ID, color); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetColor() + +FLR_RESULT symbologyGetType(const uint8_t ID, FLR_SYMBOLOGY_TYPE_E *type){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetType(ID, type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetType() + +FLR_RESULT symbologyCopySymbol(const uint8_t source, const uint8_t destination){ + FLR_RESULT returncode = CLIENT_pkgSymbologyCopySymbol(source, destination); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of CopySymbol() + +FLR_RESULT symbologyGetTextFontSize(const uint8_t ID, int16_t *size){ + FLR_RESULT returncode = CLIENT_pkgSymbologyGetTextFontSize(ID, size); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTextFontSize() + +FLR_RESULT sysctrlSetFreezeState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlSetFreezeState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFreezeState() + +FLR_RESULT sysctrlGetFreezeState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetFreezeState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFreezeState() + +FLR_RESULT sysctrlGetCameraFrameRate(uint32_t *frameRate){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetCameraFrameRate(frameRate); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCameraFrameRate() + +FLR_RESULT sysctrlGetUptimeSecs(uint32_t *uptime){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetUptimeSecs(uptime); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUptimeSecs() + +FLR_RESULT sysctrlSetUsbVideoIR16Mode(const FLR_SYSCTRL_USBIR16_MODE_E data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlSetUsbVideoIR16Mode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetUsbVideoIR16Mode() + +FLR_RESULT sysctrlGetUsbVideoIR16Mode(FLR_SYSCTRL_USBIR16_MODE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetUsbVideoIR16Mode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetUsbVideoIR16Mode() + +FLR_RESULT sysctrlSetOperatingMode(const FLR_SYSCTRL_OPERATING_MODE_E data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlSetOperatingMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOperatingMode() + +FLR_RESULT sysctrlGetOperatingMode(FLR_SYSCTRL_OPERATING_MODE_E *data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetOperatingMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOperatingMode() + +FLR_RESULT sysctrlGetAvgFpaTempCounts(float *data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetAvgFpaTempCounts(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAvgFpaTempCounts() + +FLR_RESULT sysctrlSetFpaTempFrames(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlSetFpaTempFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetFpaTempFrames() + +FLR_RESULT sysctrlGetFpaTempFrames(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgSysctrlGetFpaTempFrames(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetFpaTempFrames() + +FLR_RESULT sysinfoGetMonitorSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetMonitorSoftwareRev(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMonitorSoftwareRev() + +FLR_RESULT sysinfoGetMonitorBuildVariant(FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *monitorBuildVariant){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetMonitorBuildVariant(monitorBuildVariant); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMonitorBuildVariant() + +FLR_RESULT sysinfoGetProductName(uint8_t name[]){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetProductName(name); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetProductName() + +FLR_RESULT sysinfoGetCameraSN(uint8_t number[]){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetCameraSN(number); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetCameraSN() + +FLR_RESULT sysinfoGetBootLocation(uint32_t *bootSwLocation){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetBootLocation(bootSwLocation); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBootLocation() + +FLR_RESULT sysinfoGetSwConfigID(FLR_SYSINFO_SW_CONFIG_ID_E *swConfigID){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetSwConfigID(swConfigID); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSwConfigID() + +FLR_RESULT sysinfoGetSwPermissions(FLR_SYSINFO_SW_PERMISSIONS_E *swPermissions){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetSwPermissions(swPermissions); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSwPermissions() + +FLR_RESULT sysinfoGetIs9HzBuild(uint32_t *is9HzBuild){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetIs9HzBuild(is9HzBuild); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIs9HzBuild() + +FLR_RESULT sysinfoGetProductVersion(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetProductVersion(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetProductVersion() + +FLR_RESULT sysinfoGetMonitorProductRev(uint32_t *major, uint32_t *minor, uint32_t *patch){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetMonitorProductRev(major, minor, patch); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMonitorProductRev() + +FLR_RESULT sysinfoGetOpticalRevision(uint16_t *revision){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetOpticalRevision(revision); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOpticalRevision() + +FLR_RESULT sysinfoGetSensorRevision(uint16_t *revision){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetSensorRevision(revision); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSensorRevision() + +FLR_RESULT sysinfoGetProbeTipSN(uint8_t number[]){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetProbeTipSN(number); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetProbeTipSN() + +FLR_RESULT sysinfoGetMechanicalRevision(uint16_t *revision){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetMechanicalRevision(revision); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMechanicalRevision() + +FLR_RESULT sysinfoGetProbeTipType(FLR_SYSINFO_PROBE_TIP_TYPE *type){ + FLR_RESULT returncode = CLIENT_pkgSysinfoGetProbeTipType(type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetProbeTipType() + +FLR_RESULT systemSymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetID(symbol, id, id_type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetID() + +FLR_RESULT systemSymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetID(symbol, id, id_type); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetID() + +FLR_RESULT systemSymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetEnable(symbol, enabled); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnable() + +FLR_RESULT systemSymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetEnable(symbol, enabled); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnable() + +FLR_RESULT systemSymbolsGetSpotConfig(FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetSpotConfig(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpotConfig() + +FLR_RESULT systemSymbolsSetSpotConfig(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetSpotConfig(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpotConfig() + +FLR_RESULT systemSymbolsGetIsoConfig(FLR_SYSTEMSYMBOLS_ISOCONFIG_T *config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetIsoConfig(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIsoConfig() + +FLR_RESULT systemSymbolsSetIsoConfig(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetIsoConfig(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIsoConfig() + +FLR_RESULT systemSymbolsGetBarConfig(FLR_SYSTEMSYMBOLS_BARCONFIG_T *lowGainConfig, FLR_SYSTEMSYMBOLS_BARCONFIG_T *highGainConfig, FLR_TEMPERATURE_UNIT_E *unit){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetBarConfig(lowGainConfig, highGainConfig, unit); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetBarConfig() + +FLR_RESULT systemSymbolsSetBarConfig(const FLR_SYSTEMSYMBOLS_BARCONFIG_T lowGainConfig, const FLR_SYSTEMSYMBOLS_BARCONFIG_T highGainConfig, const FLR_TEMPERATURE_UNIT_E unit){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetBarConfig(lowGainConfig, highGainConfig, unit); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetBarConfig() + +FLR_RESULT systemSymbolsGetSpotConfigIds(FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetSpotConfigIds(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSpotConfigIds() + +FLR_RESULT systemSymbolsSetSpotConfigIds(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetSpotConfigIds(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSpotConfigIds() + +FLR_RESULT systemSymbolsGetIsoConfigIds(FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetIsoConfigIds(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIsoConfigIds() + +FLR_RESULT systemSymbolsSetIsoConfigIds(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T config){ + FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetIsoConfigIds(config); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIsoConfigIds() + +FLR_RESULT telemetrySetState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetState() + +FLR_RESULT telemetryGetState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetState() + +FLR_RESULT telemetrySetLocation(const FLR_TELEMETRY_LOC_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetLocation(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetLocation() + +FLR_RESULT telemetryGetLocation(FLR_TELEMETRY_LOC_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetLocation(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetLocation() + +FLR_RESULT telemetrySetPacking(const FLR_TELEMETRY_PACKING_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetPacking(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPacking() + +FLR_RESULT telemetryGetPacking(FLR_TELEMETRY_PACKING_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetPacking(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPacking() + +FLR_RESULT telemetrySetOrder(const FLR_TELEMETRY_ORDER_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetOrder(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetOrder() + +FLR_RESULT telemetryGetOrder(FLR_TELEMETRY_ORDER_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetOrder(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetOrder() + +FLR_RESULT telemetrySetPackingVC1(const FLR_TELEMETRY_PACKING_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetPackingVC1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPackingVC1() + +FLR_RESULT telemetryGetPackingVC1(FLR_TELEMETRY_PACKING_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetPackingVC1(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPackingVC1() + +FLR_RESULT telemetrySetMipiEmbeddedDataTag(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTelemetrySetMipiEmbeddedDataTag(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMipiEmbeddedDataTag() + +FLR_RESULT telemetryGetMipiEmbeddedDataTag(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTelemetryGetMipiEmbeddedDataTag(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMipiEmbeddedDataTag() + +FLR_RESULT testRampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetType(index, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetType() + +FLR_RESULT testRampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetType(index, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetType() + +FLR_RESULT testRampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetSettings(index, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetSettings() + +FLR_RESULT testRampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetSettings(index, data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetSettings() + +FLR_RESULT testRampSetMotionState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetMotionState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMotionState() + +FLR_RESULT testRampGetMotionState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetMotionState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMotionState() + +FLR_RESULT testRampSetIndex(const uint8_t data){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetIndex(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetIndex() + +FLR_RESULT testRampGetIndex(uint8_t *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetIndex(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetIndex() + +FLR_RESULT testRampGetMaxIndex(uint8_t *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetMaxIndex(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMaxIndex() + +FLR_RESULT testRampSetPN9ContinuousMode(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetPN9ContinuousMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetPN9ContinuousMode() + +FLR_RESULT testRampGetPN9ContinuousMode(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetPN9ContinuousMode(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetPN9ContinuousMode() + +FLR_RESULT testRampSetAnimationSettings(const FLR_TESTRAMP_ANIMATION_SETTINGS_T settings){ + FLR_RESULT returncode = CLIENT_pkgTestrampSetAnimationSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetAnimationSettings() + +FLR_RESULT testRampGetAnimationSettings(FLR_TESTRAMP_ANIMATION_SETTINGS_T *settings){ + FLR_RESULT returncode = CLIENT_pkgTestrampGetAnimationSettings(settings); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetAnimationSettings() + +FLR_RESULT tfSetEnableState(const FLR_ENABLE_E data){ + FLR_RESULT returncode = CLIENT_pkgTfSetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetEnableState() + +FLR_RESULT tfGetEnableState(FLR_ENABLE_E *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetEnableState(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetEnableState() + +FLR_RESULT tfSetDelta_nf(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgTfSetDelta_nf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetDelta_nf() + +FLR_RESULT tfGetDelta_nf(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetDelta_nf(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDelta_nf() + +FLR_RESULT tfSetTHDeltaMotion(const uint16_t data){ + FLR_RESULT returncode = CLIENT_pkgTfSetTHDeltaMotion(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTHDeltaMotion() + +FLR_RESULT tfGetTHDeltaMotion(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetTHDeltaMotion(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTHDeltaMotion() + +FLR_RESULT tfSetWLut(const FLR_TF_WLUT_T data){ + FLR_RESULT returncode = CLIENT_pkgTfSetWLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetWLut() + +FLR_RESULT tfGetWLut(FLR_TF_WLUT_T *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetWLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetWLut() + +FLR_RESULT tfGetMotionCount(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetMotionCount(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMotionCount() + +FLR_RESULT tfSetMotionThreshold(const uint32_t data){ + FLR_RESULT returncode = CLIENT_pkgTfSetMotionThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetMotionThreshold() + +FLR_RESULT tfGetMotionThreshold(uint32_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetMotionThreshold(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetMotionThreshold() + +FLR_RESULT tfGetDelta_nfApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetDelta_nfApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetDelta_nfApplied() + +FLR_RESULT tfGetTHDeltaMotionApplied(uint16_t *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetTHDeltaMotionApplied(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTHDeltaMotionApplied() + +FLR_RESULT tfSetTempSignalCompFactorLut(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T data){ + FLR_RESULT returncode = CLIENT_pkgTfSetTempSignalCompFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetTempSignalCompFactorLut() + +FLR_RESULT tfGetTempSignalCompFactorLut(FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *data){ + FLR_RESULT returncode = CLIENT_pkgTfGetTempSignalCompFactorLut(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetTempSignalCompFactorLut() + +FLR_RESULT tfGetRnf(uint16_t *rnf){ + FLR_RESULT returncode = CLIENT_pkgTfGetRnf(rnf); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetRnf() + +FLR_RESULT uartSetStartupBaudRate(const FLR_UART_STARTUP_BAUDRATE_E data){ + FLR_RESULT returncode = CLIENT_pkgUartSetStartupBaudRate(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of SetStartupBaudRate() + +FLR_RESULT uartGetStartupBaudRate(FLR_UART_STARTUP_BAUDRATE_E *data){ + FLR_RESULT returncode = CLIENT_pkgUartGetStartupBaudRate(data); + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + return R_SUCCESS; +} // End of GetStartupBaudRate() + diff --git a/src/drivers/boson/src/Client_Dispatcher.c b/src/drivers/boson/src/Client_Dispatcher.c new file mode 100644 index 000000000..e9d6c18f5 --- /dev/null +++ b/src/drivers/boson/src/Client_Dispatcher.c @@ -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= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TLINEAR_SETCONTROL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTlinearSetControl() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTlinearGetControl(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TLINEAR_GETCONTROL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTlinearGetControl() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTlinearGetLUT(const FLR_BOSON_TABLETYPE_E mode, const uint16_t offset, float *a, float *b) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 6; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_TABLETYPE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = offset; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TLINEAR_GETLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read a from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal[16]; + byteToFLOATArray( (const uint8_t *) inPtr, outVal, (uint16_t)16); + a[0] = outVal[0]; + a[1] = outVal[1]; + a[2] = outVal[2]; + a[3] = outVal[3]; + a[4] = outVal[4]; + a[5] = outVal[5]; + a[6] = outVal[6]; + a[7] = outVal[7]; + a[8] = outVal[8]; + a[9] = outVal[9]; + a[10] = outVal[10]; + a[11] = outVal[11]; + a[12] = outVal[12]; + a[13] = outVal[13]; + a[14] = outVal[14]; + a[15] = outVal[15]; + inPtr+=64; + }// end of a handling + + // read b from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal[16]; + byteToFLOATArray( (const uint8_t *) inPtr, outVal, (uint16_t)16); + b[0] = outVal[0]; + b[1] = outVal[1]; + b[2] = outVal[2]; + b[3] = outVal[3]; + b[4] = outVal[4]; + b[5] = outVal[5]; + b[6] = outVal[6]; + b[7] = outVal[7]; + b[8] = outVal[8]; + b[9] = outVal[9]; + b[10] = outVal[10]; + b[11] = outVal[11]; + b[12] = outVal[12]; + b[13] = outVal[13]; + b[14] = outVal[14]; + b[15] = outVal[15]; + inPtr+=64; + }// end of b handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTlinearGetLUT() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTlinearRefreshLUT(const FLR_BOSON_TABLETYPE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_TABLETYPE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TLINEAR_REFRESHLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTlinearRefreshLUT() + +// End Module: TLinear +// Begin Module: agc +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetPercentPerBin(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETPERCENTPERBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetPercentPerBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetPercentPerBin(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETPERCENTPERBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetPercentPerBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetLinearPercent(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETLINEARPERCENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetLinearPercent() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetLinearPercent(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETLINEARPERCENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetLinearPercent() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetOutlierCut(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETOUTLIERCUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetOutlierCut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetOutlierCut(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETOUTLIERCUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetOutlierCut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetDrOut(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETDROUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetDrOut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetMaxGain(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETMAXGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetMaxGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetMaxGain(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETMAXGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetMaxGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetdf(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetdf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetdf(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetdf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetGamma(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETGAMMA, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetGamma() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetGamma(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETGAMMA, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetGamma() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetFirstBin(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETFIRSTBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetFirstBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetLastBin(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETLASTBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetLastBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetDetailHeadroom(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETDETAILHEADROOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetDetailHeadroom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetDetailHeadroom(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETDETAILHEADROOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetDetailHeadroom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetd2br(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETD2BR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetd2br() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetd2br(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETD2BR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetd2br() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetSigmaR(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETSIGMAR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetSigmaR() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetSigmaR(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETSIGMAR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetSigmaR() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetUseEntropy(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETUSEENTROPY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetUseEntropy() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetUseEntropy(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETUSEENTROPY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetUseEntropy() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetROI(const FLR_ROI_T roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write roi to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ROI_T *inVal = (const FLR_ROI_T *) &roi; + FLR_ROI_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 8; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetROI(FLR_ROI_T *roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read roi from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ROI_T outVal; + byteToFLR_ROI_T( (const uint8_t *) inPtr, &outVal); + *roi = (FLR_ROI_T)outVal; + inPtr+=8; + }// end of roi handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetMaxGainApplied(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETMAXGAINAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetMaxGainApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetSigmaRApplied(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETSIGMARAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetSigmaRApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetOutlierCutBalance(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETOUTLIERCUTBALANCE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetOutlierCutBalance() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetOutlierCutBalance(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETOUTLIERCUTBALANCE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetOutlierCutBalance() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetOutlierCutApplied(float *percentHigh, float *percentLow) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETOUTLIERCUTAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read percentHigh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *percentHigh = (float)outVal; + inPtr+=4; + }// end of percentHigh handling + + // read percentLow from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *percentLow = (float)outVal; + inPtr+=4; + }// end of percentLow handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetOutlierCutApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetDetailHeadroomBalance(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETDETAILHEADROOMBALANCE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetDetailHeadroomBalance() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetDetailHeadroomBalance(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETDETAILHEADROOMBALANCE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetDetailHeadroomBalance() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetDetailHeadroomApplied(float *countsHigh, float *countsLow) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETDETAILHEADROOMAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read countsHigh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *countsHigh = (float)outVal; + inPtr+=4; + }// end of countsHigh handling + + // read countsLow from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *countsLow = (float)outVal; + inPtr+=4; + }// end of countsLow handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetDetailHeadroomApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetTfThresholds(uint16_t *tf_thresholdMin, uint16_t *tf_thresholdMax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETTFTHRESHOLDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read tf_thresholdMin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *tf_thresholdMin = (uint16_t)outVal; + inPtr+=2; + }// end of tf_thresholdMin handling + + // read tf_thresholdMax from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *tf_thresholdMax = (uint16_t)outVal; + inPtr+=2; + }// end of tf_thresholdMax handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetTfThresholds() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetTfThresholds(const uint16_t tf_thresholdMin, const uint16_t tf_thresholdMax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write tf_thresholdMin to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = tf_thresholdMin; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write tf_thresholdMax to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = tf_thresholdMax; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETTFTHRESHOLDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetTfThresholds() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetMode(FLR_AGC_MODE_E *mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *mode = (FLR_AGC_MODE_E)outVal; + inPtr+=4; + }// end of mode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetMode(const FLR_AGC_MODE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_AGC_MODE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetHighTempAlarmValues(const uint32_t lowGain, const uint32_t highGain, const uint32_t pixPopulation) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 12; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write lowGain to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = lowGain; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write highGain to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = highGain; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write pixPopulation to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = pixPopulation; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETHIGHTEMPALARMVALUES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetHighTempAlarmValues() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetContrast(int32_t *contrast) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETCONTRAST, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read contrast from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *contrast = (int32_t)outVal; + inPtr+=4; + }// end of contrast handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetContrast() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetContrast(const int32_t contrast) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write contrast to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = contrast; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETCONTRAST, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetContrast() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetBrightnessBias(int32_t *brightnessBias) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETBRIGHTNESSBIAS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read brightnessBias from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *brightnessBias = (int32_t)outVal; + inPtr+=4; + }// end of brightnessBias handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetBrightnessBias() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetBrightnessBias(const int32_t brightnessBias) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write brightnessBias to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = brightnessBias; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETBRIGHTNESSBIAS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetBrightnessBias() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetBrightness(int32_t *brightness) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETBRIGHTNESS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read brightness from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *brightness = (int32_t)outVal; + inPtr+=4; + }// end of brightness handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetBrightness() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetBrightness(const int32_t brightness) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write brightness to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = brightness; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETBRIGHTNESS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetBrightness() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetMaxGainForLowGain(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETMAXGAINFORLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetMaxGainForLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetMaxGainForLowGain(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETMAXGAINFORLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetMaxGainForLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetRadius(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETRADIUS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetRadius() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetRadius(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETRADIUS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetRadius() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetGmax(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETGMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetGmax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetGmax(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETGMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetGmax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcSetGmin(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_SETGMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcSetGmin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgAgcGetGmin(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, AGC_GETGMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgAgcGetGmin() + +// End Module: agc +// Begin Module: boson +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetCameraSN(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETCAMERASN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetCameraSN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetCameraPN(FLR_BOSON_PARTNUMBER_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 20; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETCAMERAPN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_PARTNUMBER_T outVal; + byteToFLR_BOSON_PARTNUMBER_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_BOSON_PARTNUMBER_T)outVal; + inPtr+=20; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetCameraPN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSensorSN(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSENSORSN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSensorSN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonRunFFC() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_RUNFFC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonRunFFC() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCTempThreshold(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCTEMPTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCTempThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCTempThreshold(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCTEMPTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCTempThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCFrameThreshold(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCFRAMETHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCFrameThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCFrameThreshold(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCFRAMETHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCFrameThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCInProgress(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCINPROGRESS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCInProgress() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonReboot() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_REBOOT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonReboot() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCMode(const FLR_BOSON_FFCMODE_E ffcMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ffcMode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_FFCMODE_E inVal = ffcMode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCMode(FLR_BOSON_FFCMODE_E *ffcMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ffcMode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *ffcMode = (FLR_BOSON_FFCMODE_E)outVal; + inPtr+=4; + }// end of ffcMode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainMode(const FLR_BOSON_GAINMODE_E gainMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write gainMode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_GAINMODE_E inVal = gainMode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainMode(FLR_BOSON_GAINMODE_E *gainMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read gainMode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *gainMode = (FLR_BOSON_GAINMODE_E)outVal; + inPtr+=4; + }// end of gainMode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteDynamicHeaderToFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITEDYNAMICHEADERTOFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteDynamicHeaderToFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonReadDynamicHeaderFromFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_READDYNAMICHEADERFROMFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonReadDynamicHeaderFromFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonRestoreFactoryDefaultsFromFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_RESTOREFACTORYDEFAULTSFROMFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonRestoreFactoryDefaultsFromFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonRestoreFactoryBadPixelsFromFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_RESTOREFACTORYBADPIXELSFROMFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonRestoreFactoryBadPixelsFromFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteBadPixelsToFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITEBADPIXELSTOFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteBadPixelsToFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSOFTWAREREV, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSoftwareRev() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetBadPixelLocation(const uint32_t row, const uint32_t col) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write row to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = row; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write col to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = col; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETBADPIXELLOCATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetBadPixelLocation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonlookupFPATempDegCx10(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_LOOKUPFPATEMPDEGCX10, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonlookupFPATempDegCx10() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonlookupFPATempDegKx10(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_LOOKUPFPATEMPDEGKX10, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonlookupFPATempDegKx10() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteLensNvFfcToFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITELENSNVFFCTOFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteLensNvFfcToFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteLensGainToFlash() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITELENSGAINTOFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteLensGainToFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetLensNumber(const uint32_t lensNumber) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write lensNumber to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = lensNumber; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETLENSNUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetLensNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetLensNumber(uint32_t *lensNumber) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETLENSNUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read lensNumber from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *lensNumber = (uint32_t)outVal; + inPtr+=4; + }// end of lensNumber handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetLensNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetTableNumber(const uint32_t tableNumber) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write tableNumber to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = tableNumber; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETTABLENUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetTableNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTableNumber(uint32_t *tableNumber) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTABLENUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read tableNumber from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *tableNumber = (uint32_t)outVal; + inPtr+=4; + }// end of tableNumber handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTableNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSensorPN(FLR_BOSON_SENSOR_PARTNUMBER_T *sensorPN) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 32; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSENSORPN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sensorPN from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_SENSOR_PARTNUMBER_T outVal; + byteToFLR_BOSON_SENSOR_PARTNUMBER_T( (const uint8_t *) inPtr, &outVal); + *sensorPN = (FLR_BOSON_SENSOR_PARTNUMBER_T)outVal; + inPtr+=32; + }// end of sensorPN handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSensorPN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchParams(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write parm_struct to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_GAIN_SWITCH_PARAMS_T *inVal = (const FLR_BOSON_GAIN_SWITCH_PARAMS_T *) &parm_struct; + FLR_BOSON_GAIN_SWITCH_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchParams(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read parm_struct from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_GAIN_SWITCH_PARAMS_T outVal; + byteToFLR_BOSON_GAIN_SWITCH_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *parm_struct = (FLR_BOSON_GAIN_SWITCH_PARAMS_T)outVal; + inPtr+=16; + }// end of parm_struct handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSwitchToHighGainFlag(uint8_t *switchToHighGainFlag) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSWITCHTOHIGHGAINFLAG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read switchToHighGainFlag from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *switchToHighGainFlag = (uint8_t)outVal; + inPtr+=1; + }// end of switchToHighGainFlag handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSwitchToHighGainFlag() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSwitchToLowGainFlag(uint8_t *switchToLowGainFlag) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSWITCHTOLOWGAINFLAG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read switchToLowGainFlag from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *switchToLowGainFlag = (uint8_t)outVal; + inPtr+=1; + }// end of switchToLowGainFlag handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSwitchToLowGainFlag() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetCLowToHighPercent(uint32_t *cLowToHighPercent) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETCLOWTOHIGHPERCENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read cLowToHighPercent from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *cLowToHighPercent = (uint32_t)outVal; + inPtr+=4; + }// end of cLowToHighPercent handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetCLowToHighPercent() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetMaxNUCTables(uint32_t *maxNUCTables) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETMAXNUCTABLES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read maxNUCTables from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *maxNUCTables = (uint32_t)outVal; + inPtr+=4; + }// end of maxNUCTables handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetMaxNUCTables() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetMaxLensTables(uint32_t *maxLensTables) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETMAXLENSTABLES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read maxLensTables from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *maxLensTables = (uint32_t)outVal; + inPtr+=4; + }// end of maxLensTables handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetMaxLensTables() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFfcWaitCloseFrames(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCWAITCLOSEFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFfcWaitCloseFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFfcWaitCloseFrames(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCWAITCLOSEFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFfcWaitCloseFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonCheckForTableSwitch() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_CHECKFORTABLESWITCH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonCheckForTableSwitch() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetDesiredTableNumber(uint32_t *desiredTableNumber) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETDESIREDTABLENUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read desiredTableNumber from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *desiredTableNumber = (uint32_t)outVal; + inPtr+=4; + }// end of desiredTableNumber handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetDesiredTableNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFfcStatus(FLR_BOSON_FFCSTATUS_E *ffcStatus) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCSTATUS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ffcStatus from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *ffcStatus = (FLR_BOSON_FFCSTATUS_E)outVal; + inPtr+=4; + }// end of ffcStatus handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFfcStatus() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFfcDesired(uint32_t *ffcDesired) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ffcDesired from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *ffcDesired = (uint32_t)outVal; + inPtr+=4; + }// end of ffcDesired handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFfcDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSwRevInHeader(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSWREVINHEADER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSwRevInHeader() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetLastFFCFrameCount(uint32_t *frameCount) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETLASTFFCFRAMECOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read frameCount from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *frameCount = (uint32_t)outVal; + inPtr+=4; + }// end of frameCount handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetLastFFCFrameCount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetLastFFCTempDegKx10(uint16_t *temp) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETLASTFFCTEMPDEGKX10, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read temp from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *temp = (uint16_t)outVal; + inPtr+=2; + }// end of temp handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetLastFFCTempDegKx10() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTableSwitchDesired(uint16_t *tableSwitchDesired) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTABLESWITCHDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read tableSwitchDesired from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *tableSwitchDesired = (uint16_t)outVal; + inPtr+=2; + }// end of tableSwitchDesired handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTableSwitchDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetOverTempThreshold(float *temperatureInC) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETOVERTEMPTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read temperatureInC from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *temperatureInC = (float)outVal; + inPtr+=4; + }// end of temperatureInC handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetOverTempThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetLowPowerMode(uint16_t *lowPowerMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETLOWPOWERMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read lowPowerMode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *lowPowerMode = (uint16_t)outVal; + inPtr+=2; + }// end of lowPowerMode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetLowPowerMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetOverTempEventOccurred(uint16_t *overTempEventOccurred) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETOVERTEMPEVENTOCCURRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read overTempEventOccurred from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *overTempEventOccurred = (uint16_t)outVal; + inPtr+=2; + }// end of overTempEventOccurred handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetOverTempEventOccurred() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetPermitThermalShutdownOverride(const FLR_ENABLE_E permitThermalShutdownOverride) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write permitThermalShutdownOverride to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = permitThermalShutdownOverride; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETPERMITTHERMALSHUTDOWNOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetPermitThermalShutdownOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetPermitThermalShutdownOverride(FLR_ENABLE_E *permitThermalShutdownOverride) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETPERMITTHERMALSHUTDOWNOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read permitThermalShutdownOverride from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *permitThermalShutdownOverride = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of permitThermalShutdownOverride handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetPermitThermalShutdownOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetMyriadTemp(float *myriadTemp) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETMYRIADTEMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read myriadTemp from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *myriadTemp = (float)outVal; + inPtr+=4; + }// end of myriadTemp handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetMyriadTemp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCNucTableNumberLens0(int32_t *nvFFCNucTableNumberLens0) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCNUCTABLENUMBERLENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read nvFFCNucTableNumberLens0 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *nvFFCNucTableNumberLens0 = (int32_t)outVal; + inPtr+=4; + }// end of nvFFCNucTableNumberLens0 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCNucTableNumberLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCNucTableNumberLens1(int32_t *nvFFCNucTableNumberLens1) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCNUCTABLENUMBERLENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read nvFFCNucTableNumberLens1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *nvFFCNucTableNumberLens1 = (int32_t)outVal; + inPtr+=4; + }// end of nvFFCNucTableNumberLens1 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCNucTableNumberLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens0(uint16_t *nvFFCFPATempDegKx10Lens0) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCFPATEMPDEGKX10LENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read nvFFCFPATempDegKx10Lens0 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *nvFFCFPATempDegKx10Lens0 = (uint16_t)outVal; + inPtr+=2; + }// end of nvFFCFPATempDegKx10Lens0 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens1(uint16_t *nvFFCFPATempDegKx10Lens1) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCFPATEMPDEGKX10LENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read nvFFCFPATempDegKx10Lens1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *nvFFCFPATempDegKx10Lens1 = (uint16_t)outVal; + inPtr+=2; + }// end of nvFFCFPATempDegKx10Lens1 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCFPATempDegKx10Lens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCWarnTimeInSecx10(const uint16_t ffcWarnTime) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ffcWarnTime to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = ffcWarnTime; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCWARNTIMEINSECX10, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCWarnTimeInSecx10() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCWarnTimeInSecx10(uint16_t *ffcWarnTime) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCWARNTIMEINSECX10, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ffcWarnTime from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *ffcWarnTime = (uint16_t)outVal; + inPtr+=2; + }// end of ffcWarnTime handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCWarnTimeInSecx10() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetOverTempEventCounter(uint32_t *overTempEventCounter) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETOVERTEMPEVENTCOUNTER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read overTempEventCounter from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *overTempEventCounter = (uint32_t)outVal; + inPtr+=4; + }// end of overTempEventCounter handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetOverTempEventCounter() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetOverTempTimerInSec(const uint16_t overTempTimerInSec) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write overTempTimerInSec to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = overTempTimerInSec; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETOVERTEMPTIMERINSEC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetOverTempTimerInSec() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetOverTempTimerInSec(uint16_t *overTempTimerInSec) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETOVERTEMPTIMERINSEC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read overTempTimerInSec from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *overTempTimerInSec = (uint16_t)outVal; + inPtr+=2; + }// end of overTempTimerInSec handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetOverTempTimerInSec() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonUnloadCurrentLensCorrections() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_UNLOADCURRENTLENSCORRECTIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonUnloadCurrentLensCorrections() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetTimeForQuickFFCsInSecs(const uint32_t timeForQuickFFCsInSecs) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write timeForQuickFFCsInSecs to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = timeForQuickFFCsInSecs; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETTIMEFORQUICKFFCSINSECS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetTimeForQuickFFCsInSecs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTimeForQuickFFCsInSecs(uint32_t *timeForQuickFFCsInSecs) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTIMEFORQUICKFFCSINSECS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read timeForQuickFFCsInSecs from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *timeForQuickFFCsInSecs = (uint32_t)outVal; + inPtr+=4; + }// end of timeForQuickFFCsInSecs handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTimeForQuickFFCsInSecs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonReloadCurrentLensCorrections() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_RELOADCURRENTLENSCORRECTIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonReloadCurrentLensCorrections() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetBootTimestamps(float *FirstLight, float *StartInit, float *BosonExecDone, float *Timestamp4) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETBOOTTIMESTAMPS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read FirstLight from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *FirstLight = (float)outVal; + inPtr+=4; + }// end of FirstLight handling + + // read StartInit from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *StartInit = (float)outVal; + inPtr+=4; + }// end of StartInit handling + + // read BosonExecDone from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *BosonExecDone = (float)outVal; + inPtr+=4; + }// end of BosonExecDone handling + + // read Timestamp4 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *Timestamp4 = (float)outVal; + inPtr+=4; + }// end of Timestamp4 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetBootTimestamps() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetExtSyncMode(const FLR_BOSON_EXT_SYNC_MODE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_EXT_SYNC_MODE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETEXTSYNCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetExtSyncMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetExtSyncMode(FLR_BOSON_EXT_SYNC_MODE_E *mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETEXTSYNCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *mode = (FLR_BOSON_EXT_SYNC_MODE_E)outVal; + inPtr+=4; + }// end of mode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetExtSyncMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetLastCommand(uint32_t *sequenceNum, uint32_t *cmdID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETLASTCOMMAND, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sequenceNum from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *sequenceNum = (uint32_t)outVal; + inPtr+=4; + }// end of sequenceNum handling + + // read cmdID from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *cmdID = (uint32_t)outVal; + inPtr+=4; + }// end of cmdID handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetLastCommand() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSensorHostCalVersion(uint32_t *version) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSENSORHOSTCALVERSION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read version from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *version = (uint32_t)outVal; + inPtr+=4; + }// end of version handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSensorHostCalVersion() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetDesiredStartupTableNumber(const int32_t table) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETDESIREDSTARTUPTABLENUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetDesiredStartupTableNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetDesiredStartupTableNumber(int32_t *table) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETDESIREDSTARTUPTABLENUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read table from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *table = (int32_t)outVal; + inPtr+=4; + }// end of table handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetDesiredStartupTableNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetNvFFCMeanValueLens0(const float meanValue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write meanValue to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = meanValue; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETNVFFCMEANVALUELENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetNvFFCMeanValueLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCMeanValueLens0(float *meanValue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCMEANVALUELENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read meanValue from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *meanValue = (float)outVal; + inPtr+=4; + }// end of meanValue handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCMeanValueLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetNvFFCMeanValueLens1(const float meanValue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write meanValue to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = meanValue; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETNVFFCMEANVALUELENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetNvFFCMeanValueLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetNvFFCMeanValueLens1(float *meanValue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETNVFFCMEANVALUELENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read meanValue from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *meanValue = (float)outVal; + inPtr+=4; + }// end of meanValue handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetNvFFCMeanValueLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetInvertImage(const FLR_ENABLE_E invertImage) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write invertImage to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = invertImage; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETINVERTIMAGE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetInvertImage() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetInvertImage(FLR_ENABLE_E *invertImage) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETINVERTIMAGE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read invertImage from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *invertImage = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of invertImage handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetInvertImage() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetRevertImage(const FLR_ENABLE_E revertImage) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write revertImage to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = revertImage; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETREVERTIMAGE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetRevertImage() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetRevertImage(FLR_ENABLE_E *revertImage) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETREVERTIMAGE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read revertImage from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *revertImage = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of revertImage handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetRevertImage() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTimeStamp(const FLR_BOSON_TIMESTAMPTYPE_E timeStampType, float *timeStamp) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write timeStampType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_TIMESTAMPTYPE_E inVal = timeStampType; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTIMESTAMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read timeStamp from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *timeStamp = (float)outVal; + inPtr+=4; + }// end of timeStamp handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTimeStamp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetISPFrameCount(uint32_t *ispFrameCount) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETISPFRAMECOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ispFrameCount from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *ispFrameCount = (uint32_t)outVal; + inPtr+=4; + }// end of ispFrameCount handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetISPFrameCount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteUserBadPixelsToAllTables() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITEUSERBADPIXELSTOALLTABLES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteUserBadPixelsToAllTables() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonWriteFactoryBadPixelsToAllTables() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_WRITEFACTORYBADPIXELSTOALLTABLES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonWriteFactoryBadPixelsToAllTables() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTempDiodeStatus(FLR_BOSON_TEMP_DIODE_STATUS_E *status) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTEMPDIODESTATUS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read status from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *status = (FLR_BOSON_TEMP_DIODE_STATUS_E)outVal; + inPtr+=4; + }// end of status handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTempDiodeStatus() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonClearFactoryBadPixelsInDDR() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_CLEARFACTORYBADPIXELSINDDR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonClearFactoryBadPixelsInDDR() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFfcWaitOpenFrames(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCWAITOPENFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFfcWaitOpenFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFfcWaitOpenFrames(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCWAITOPENFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFfcWaitOpenFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFfcWaitOpenFlagSettleFrames(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCWAITOPENFLAGSETTLEFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFfcWaitOpenFlagSettleFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFfcWaitOpenFlagSettleFrames(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCWAITOPENFLAGSETTLEFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFfcWaitOpenFlagSettleFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetTauExtFfcCompatibilityMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETTAUEXTFFCCOMPATIBILITYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetTauExtFfcCompatibilityMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetTauExtFfcCompatibilityMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETTAUEXTFFCCOMPATIBILITYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetTauExtFfcCompatibilityMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetInitialTableSelectionTempOffset(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETINITIALTABLESELECTIONTEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetInitialTableSelectionTempOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetInitialTableSelectionTempOffset(const int16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = data; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETINITIALTABLESELECTIONTEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetInitialTableSelectionTempOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetImageValid(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETIMAGEVALID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetImageValid() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetCurrentTableType(FLR_BOSON_TABLETYPE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETCURRENTTABLETYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_BOSON_TABLETYPE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetCurrentTableType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchFrameThreshold(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHFRAMETHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchFrameThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchFrameThreshold(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHFRAMETHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchFrameThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchHysteresisTime(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHHYSTERESISTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchHysteresisTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchHysteresisTime(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHHYSTERESISTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchHysteresisTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchDesired(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchRadiometricParams(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHRADIOMETRICPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read parm_struct from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T outVal; + byteToFLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *parm_struct = (FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T)outVal; + inPtr+=16; + }// end of parm_struct handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchRadiometricParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchRadiometricParams(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write parm_struct to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *inVal = (const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *) &parm_struct; + FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHRADIOMETRICPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchRadiometricParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetSaturationOverrideMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETSATURATIONOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetSaturationOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSaturationOverrideMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSATURATIONOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSaturationOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetSaturationOverrideValue(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETSATURATIONOVERRIDEVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetSaturationOverrideValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetSaturationOverrideValue(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETSATURATIONOVERRIDEVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetSaturationOverrideValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetffcHighLowGainThresholdMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCHIGHLOWGAINTHRESHOLDMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetffcHighLowGainThresholdMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetffcHighLowGainThresholdMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCHIGHLOWGAINTHRESHOLDMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetffcHighLowGainThresholdMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCTempThresholdLowGain(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCTEMPTHRESHOLDLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCTempThresholdLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCTempThresholdLowGain(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCTEMPTHRESHOLDLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCTempThresholdLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetFFCFrameThresholdLowGain(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETFFCFRAMETHRESHOLDLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetFFCFrameThresholdLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetFFCFrameThresholdLowGain(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETFFCFRAMETHRESHOLDLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetFFCFrameThresholdLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetBoardID(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETBOARDID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetBoardID() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetAutoGainSwitchConditions(const FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETAUTOGAINSWITCHCONDITIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetAutoGainSwitchConditions() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetAutoGainSwitchConditions(FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETAUTOGAINSWITCHCONDITIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_BOSON_AUTOGAIN_SWITCH_CONDITION_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetAutoGainSwitchConditions() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchParamsCATS(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write parm_struct to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_GAIN_SWITCH_PARAMS_T *inVal = (const FLR_BOSON_GAIN_SWITCH_PARAMS_T *) &parm_struct; + FLR_BOSON_GAIN_SWITCH_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHPARAMSCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchParamsCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchParamsCATS(FLR_BOSON_GAIN_SWITCH_PARAMS_T *parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHPARAMSCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read parm_struct from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_GAIN_SWITCH_PARAMS_T outVal; + byteToFLR_BOSON_GAIN_SWITCH_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *parm_struct = (FLR_BOSON_GAIN_SWITCH_PARAMS_T)outVal; + inPtr+=16; + }// end of parm_struct handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchParamsCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetGainSwitchRadiometricParamsCATS(FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETGAINSWITCHRADIOMETRICPARAMSCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read parm_struct from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T outVal; + byteToFLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *parm_struct = (FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T)outVal; + inPtr+=16; + }// end of parm_struct handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetGainSwitchRadiometricParamsCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonSetGainSwitchRadiometricParamsCATS(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T parm_struct) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write parm_struct to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *inVal = (const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *) &parm_struct; + FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_SETGAINSWITCHRADIOMETRICPARAMSCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonSetGainSwitchRadiometricParamsCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBosonGetCLowToHighPercentCATS(uint32_t *cLowToHighPercent) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BOSON_GETCLOWTOHIGHPERCENTCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read cLowToHighPercent from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *cLowToHighPercent = (uint32_t)outVal; + inPtr+=4; + }// end of cLowToHighPercent handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBosonGetCLowToHighPercentCATS() + +// End Module: boson +// Begin Module: bpr +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprSetState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_SETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBprSetState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 20; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETSTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read threeby from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *threeby = (uint32_t)outVal; + inPtr+=4; + }// end of threeby handling + + // read fiveby from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *fiveby = (uint32_t)outVal; + inPtr+=4; + }// end of fiveby handling + + // read rows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *rows = (uint32_t)outVal; + inPtr+=4; + }// end of rows handling + + // read budget from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *budget = (uint32_t)outVal; + inPtr+=4; + }// end of budget handling + + // read used from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *used = (uint32_t)outVal; + inPtr+=4; + }// end of used handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetStats() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetDisplayMode(FLR_BPR_DISPLAY_MODE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETDISPLAYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_BPR_DISPLAY_MODE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetDisplayMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprSetDisplayMode(const FLR_BPR_DISPLAY_MODE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_BPR_DISPLAY_MODE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_SETDISPLAYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBprSetDisplayMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetDisplayModeMinValue(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETDISPLAYMODEMINVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetDisplayModeMinValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprSetDisplayModeMinValue(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_SETDISPLAYMODEMINVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBprSetDisplayModeMinValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetDisplayModeMaxValue(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETDISPLAYMODEMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetDisplayModeMaxValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprSetDisplayModeMaxValue(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_SETDISPLAYMODEMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBprSetDisplayModeMaxValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetWorkBufIndex(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETWORKBUFINDEX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetWorkBufIndex() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprSetWorkBufIndex(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_SETWORKBUFINDEX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgBprSetWorkBufIndex() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgBprGetWorkBufStats(uint32_t *threeby, uint32_t *fiveby, uint32_t *rows, uint32_t *budget, uint32_t *used) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 20; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, BPR_GETWORKBUFSTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read threeby from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *threeby = (uint32_t)outVal; + inPtr+=4; + }// end of threeby handling + + // read fiveby from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *fiveby = (uint32_t)outVal; + inPtr+=4; + }// end of fiveby handling + + // read rows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *rows = (uint32_t)outVal; + inPtr+=4; + }// end of rows handling + + // read budget from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *budget = (uint32_t)outVal; + inPtr+=4; + }// end of budget handling + + // read used from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *used = (uint32_t)outVal; + inPtr+=4; + }// end of used handling + + return R_SUCCESS; + +}// End of CLIENT_pkgBprGetWorkBufStats() + +// End Module: bpr +// Begin Module: capture +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgCaptureSingleFrame() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, CAPTURE_SINGLEFRAME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgCaptureSingleFrame() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgCaptureFrames(const FLR_CAPTURE_SETTINGS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 10; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_CAPTURE_SETTINGS_T *inVal = (const FLR_CAPTURE_SETTINGS_T *) &data; + FLR_CAPTURE_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 10; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, CAPTURE_FRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgCaptureFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgCaptureSingleFrameWithSrc(const FLR_CAPTURE_SRC_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_CAPTURE_SRC_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, CAPTURE_SINGLEFRAMEWITHSRC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgCaptureSingleFrameWithSrc() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgCaptureSingleFrameToFile() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, CAPTURE_SINGLEFRAMETOFILE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgCaptureSingleFrameToFile() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgCaptureGetStatus(FLR_CAPTURE_STATUS_T *status) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 24; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, CAPTURE_GETSTATUS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read status from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_CAPTURE_STATUS_T outVal; + byteToFLR_CAPTURE_STATUS_T( (const uint8_t *) inPtr, &outVal); + *status = (FLR_CAPTURE_STATUS_T)outVal; + inPtr+=24; + }// end of status handling + + return R_SUCCESS; + +}// End of CLIENT_pkgCaptureGetStatus() + +// End Module: capture +// Begin Module: colorLut +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutSetControl(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_SETCONTROL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutSetControl() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutGetControl(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_GETCONTROL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutGetControl() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutSetId(const FLR_COLORLUT_ID_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_COLORLUT_ID_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_SETID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutSetId() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutGetId(FLR_COLORLUT_ID_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_GETID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_COLORLUT_ID_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutGetId() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutSetOutlineColor(const uint8_t red, const uint8_t green, const uint8_t blue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 3; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write red to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = red; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write green to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = green; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write blue to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = blue; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_SETOUTLINECOLOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutSetOutlineColor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgColorlutGetOutlineColor(uint8_t *red, uint8_t *green, uint8_t *blue) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 3; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, COLORLUT_GETOUTLINECOLOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read red from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *red = (uint8_t)outVal; + inPtr+=1; + }// end of red handling + + // read green from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *green = (uint8_t)outVal; + inPtr+=1; + }// end of green handling + + // read blue from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *blue = (uint8_t)outVal; + inPtr+=1; + }// end of blue handling + + return R_SUCCESS; + +}// End of CLIENT_pkgColorlutGetOutlineColor() + +// End Module: colorLut +// Begin Module: dummy +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDummyBadCommand() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DUMMY_BADCOMMAND, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDummyBadCommand() + +// End Module: dummy +// Begin Module: dvo +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetAnalogVideoState(const FLR_ENABLE_E analogVideoState) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write analogVideoState to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = analogVideoState; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETANALOGVIDEOSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetAnalogVideoState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetAnalogVideoState(FLR_ENABLE_E *analogVideoState) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETANALOGVIDEOSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read analogVideoState from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *analogVideoState = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of analogVideoState handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetAnalogVideoState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputFormat(const FLR_DVO_OUTPUT_FORMAT_E format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write format to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_OUTPUT_FORMAT_E inVal = format; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTFORMAT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputFormat() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputFormat(FLR_DVO_OUTPUT_FORMAT_E *format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTFORMAT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read format from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *format = (FLR_DVO_OUTPUT_FORMAT_E)outVal; + inPtr+=4; + }// end of format handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputFormat() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputYCbCrSettings(const FLR_DVO_YCBCR_SETTINGS_T settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 12; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write settings to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_YCBCR_SETTINGS_T *inVal = (const FLR_DVO_YCBCR_SETTINGS_T *) &settings; + FLR_DVO_YCBCR_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 12; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTYCBCRSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputYCbCrSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputYCbCrSettings(FLR_DVO_YCBCR_SETTINGS_T *settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTYCBCRSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read settings from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_DVO_YCBCR_SETTINGS_T outVal; + byteToFLR_DVO_YCBCR_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *settings = (FLR_DVO_YCBCR_SETTINGS_T)outVal; + inPtr+=12; + }// end of settings handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputYCbCrSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputRGBSettings(const FLR_DVO_RGB_SETTINGS_T settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write settings to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_RGB_SETTINGS_T *inVal = (const FLR_DVO_RGB_SETTINGS_T *) &settings; + FLR_DVO_RGB_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 8; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTRGBSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputRGBSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputRGBSettings(FLR_DVO_RGB_SETTINGS_T *settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTRGBSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read settings from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_DVO_RGB_SETTINGS_T outVal; + byteToFLR_DVO_RGB_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *settings = (FLR_DVO_RGB_SETTINGS_T)outVal; + inPtr+=8; + }// end of settings handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputRGBSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoApplyCustomSettings() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_APPLYCUSTOMSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoApplyCustomSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetDisplayMode(const FLR_DVO_DISPLAY_MODE_E displayMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write displayMode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_DISPLAY_MODE_E inVal = displayMode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETDISPLAYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetDisplayMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetDisplayMode(FLR_DVO_DISPLAY_MODE_E *displayMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETDISPLAYMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read displayMode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *displayMode = (FLR_DVO_DISPLAY_MODE_E)outVal; + inPtr+=4; + }// end of displayMode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetDisplayMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetType(const FLR_DVO_TYPE_E tap) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write tap to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_TYPE_E inVal = tap; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetType(FLR_DVO_TYPE_E *tap) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read tap from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *tap = (FLR_DVO_TYPE_E)outVal; + inPtr+=4; + }// end of tap handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetVideoStandard(const FLR_DVO_VIDEO_STANDARD_E videoStandard) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write videoStandard to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_VIDEO_STANDARD_E inVal = videoStandard; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETVIDEOSTANDARD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetVideoStandard() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetVideoStandard(FLR_DVO_VIDEO_STANDARD_E *videoStandard) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETVIDEOSTANDARD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read videoStandard from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *videoStandard = (FLR_DVO_VIDEO_STANDARD_E)outVal; + inPtr+=4; + }// end of videoStandard handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetVideoStandard() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetCheckVideoDacPresent(const FLR_ENABLE_E checkVideoDacPresent) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write checkVideoDacPresent to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = checkVideoDacPresent; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETCHECKVIDEODACPRESENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetCheckVideoDacPresent() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetCheckVideoDacPresent(FLR_ENABLE_E *checkVideoDacPresent) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETCHECKVIDEODACPRESENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read checkVideoDacPresent from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *checkVideoDacPresent = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of checkVideoDacPresent handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetCheckVideoDacPresent() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, const FLR_DVO_LCD_CONFIG_T config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 52; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_ID_E inVal = id; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write config to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_T *inVal = (const FLR_DVO_LCD_CONFIG_T *) &config; + FLR_DVO_LCD_CONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 48; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETCUSTOMLCDCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetCustomLcdConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetCustomLcdConfig(const FLR_DVO_LCD_CONFIG_ID_E id, FLR_DVO_LCD_CONFIG_T *config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 48; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_ID_E inVal = id; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETCUSTOMLCDCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_DVO_LCD_CONFIG_T outVal; + byteToFLR_DVO_LCD_CONFIG_T( (const uint8_t *) inPtr, &outVal); + *config = (FLR_DVO_LCD_CONFIG_T)outVal; + inPtr+=48; + }// end of config handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetCustomLcdConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetLCDConfig(const FLR_DVO_LCD_CONFIG_ID_E id) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_ID_E inVal = id; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETLCDCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetLCDConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetLCDConfig(FLR_DVO_LCD_CONFIG_ID_E *id) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETLCDCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read id from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *id = (FLR_DVO_LCD_CONFIG_ID_E)outVal; + inPtr+=4; + }// end of id handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetLCDConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 80; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETCLOCKINFO, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read horizontalSyncWidth from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *horizontalSyncWidth = (uint32_t)outVal; + inPtr+=4; + }// end of horizontalSyncWidth handling + + // read verticalSyncWidth from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *verticalSyncWidth = (uint32_t)outVal; + inPtr+=4; + }// end of verticalSyncWidth handling + + // read clocksPerRowPeriod from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *clocksPerRowPeriod = (uint32_t)outVal; + inPtr+=4; + }// end of clocksPerRowPeriod handling + + // read horizontalFrontPorch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *horizontalFrontPorch = (uint32_t)outVal; + inPtr+=4; + }// end of horizontalFrontPorch handling + + // read horizontalBackPorch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *horizontalBackPorch = (uint32_t)outVal; + inPtr+=4; + }// end of horizontalBackPorch handling + + // read frontTelemetryPixels from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *frontTelemetryPixels = (uint32_t)outVal; + inPtr+=4; + }// end of frontTelemetryPixels handling + + // read rearTelemetryPixels from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *rearTelemetryPixels = (uint32_t)outVal; + inPtr+=4; + }// end of rearTelemetryPixels handling + + // read videoColumns from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *videoColumns = (uint32_t)outVal; + inPtr+=4; + }// end of videoColumns handling + + // read validColumns from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *validColumns = (uint32_t)outVal; + inPtr+=4; + }// end of validColumns handling + + // read telemetryRows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *telemetryRows = (uint32_t)outVal; + inPtr+=4; + }// end of telemetryRows handling + + // read videoRows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *videoRows = (uint32_t)outVal; + inPtr+=4; + }// end of videoRows handling + + // read validRows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *validRows = (uint32_t)outVal; + inPtr+=4; + }// end of validRows handling + + // read verticalFrontPorch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *verticalFrontPorch = (uint32_t)outVal; + inPtr+=4; + }// end of verticalFrontPorch handling + + // read verticalBackPorch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *verticalBackPorch = (uint32_t)outVal; + inPtr+=4; + }// end of verticalBackPorch handling + + // read rowPeriodsPerFrame from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *rowPeriodsPerFrame = (uint32_t)outVal; + inPtr+=4; + }// end of rowPeriodsPerFrame handling + + // read clocksPerFrame from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *clocksPerFrame = (uint32_t)outVal; + inPtr+=4; + }// end of clocksPerFrame handling + + // read clockRateInMHz from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *clockRateInMHz = (float)outVal; + inPtr+=4; + }// end of clockRateInMHz handling + + // read frameRateInHz from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *frameRateInHz = (float)outVal; + inPtr+=4; + }// end of frameRateInHz handling + + // read validOnRisingEdge from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *validOnRisingEdge = (uint32_t)outVal; + inPtr+=4; + }// end of validOnRisingEdge handling + + // read dataWidthInBits from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *dataWidthInBits = (uint32_t)outVal; + inPtr+=4; + }// end of dataWidthInBits handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetClockInfo() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetAllCustomLcdConfigs(const FLR_DVO_LCD_CONFIG_T config0, const FLR_DVO_LCD_CONFIG_T config1) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 96; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write config0 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_T *inVal = (const FLR_DVO_LCD_CONFIG_T *) &config0; + FLR_DVO_LCD_CONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 48; + } + + //write config1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CONFIG_T *inVal = (const FLR_DVO_LCD_CONFIG_T *) &config1; + FLR_DVO_LCD_CONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 48; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETALLCUSTOMLCDCONFIGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetAllCustomLcdConfigs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetAllCustomLcdConfigs(FLR_DVO_LCD_CONFIG_T *config0, FLR_DVO_LCD_CONFIG_T *config1) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 96; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETALLCUSTOMLCDCONFIGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config0 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_DVO_LCD_CONFIG_T outVal; + byteToFLR_DVO_LCD_CONFIG_T( (const uint8_t *) inPtr, &outVal); + *config0 = (FLR_DVO_LCD_CONFIG_T)outVal; + inPtr+=48; + }// end of config0 handling + + // read config1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_DVO_LCD_CONFIG_T outVal; + byteToFLR_DVO_LCD_CONFIG_T( (const uint8_t *) inPtr, &outVal); + *config1 = (FLR_DVO_LCD_CONFIG_T)outVal; + inPtr+=48; + }// end of config1 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetAllCustomLcdConfigs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputIr16Format(const FLR_DVO_OUTPUT_IR16_FORMAT_E format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write format to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_OUTPUT_IR16_FORMAT_E inVal = format; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTIR16FORMAT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputIr16Format() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputIr16Format(FLR_DVO_OUTPUT_IR16_FORMAT_E *format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTIR16FORMAT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read format from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *format = (FLR_DVO_OUTPUT_IR16_FORMAT_E)outVal; + inPtr+=4; + }// end of format handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputIr16Format() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetLcdClockRate(const FLR_DVO_LCD_CLOCK_RATE_E clockRate) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write clockRate to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_LCD_CLOCK_RATE_E inVal = clockRate; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETLCDCLOCKRATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetLcdClockRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetLcdClockRate(FLR_DVO_LCD_CLOCK_RATE_E *clockRate) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETLCDCLOCKRATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read clockRate from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *clockRate = (FLR_DVO_LCD_CLOCK_RATE_E)outVal; + inPtr+=4; + }// end of clockRate handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetLcdClockRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetLcdVideoFrameRate(const uint32_t framerate) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write framerate to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = framerate; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETLCDVIDEOFRAMERATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetLcdVideoFrameRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetLcdVideoFrameRate(uint32_t *framerate) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETLCDVIDEOFRAMERATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read framerate from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *framerate = (uint32_t)outVal; + inPtr+=4; + }// end of framerate handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetLcdVideoFrameRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetMipiStartState(const FLR_DVO_MIPI_STATE_E state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write state to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_MIPI_STATE_E inVal = state; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETMIPISTARTSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetMipiStartState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetMipiStartState(FLR_DVO_MIPI_STATE_E *state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETMIPISTARTSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read state from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *state = (FLR_DVO_MIPI_STATE_E)outVal; + inPtr+=4; + }// end of state handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetMipiStartState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetMipiState(const FLR_DVO_MIPI_STATE_E state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write state to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_MIPI_STATE_E inVal = state; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETMIPISTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetMipiState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetMipiState(FLR_DVO_MIPI_STATE_E *state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETMIPISTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read state from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *state = (FLR_DVO_MIPI_STATE_E)outVal; + inPtr+=4; + }// end of state handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetMipiState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetMipiClockLaneMode(const FLR_DVO_MIPI_CLOCK_LANE_MODE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_MIPI_CLOCK_LANE_MODE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETMIPICLOCKLANEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetMipiClockLaneMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetMipiClockLaneMode(FLR_DVO_MIPI_CLOCK_LANE_MODE_E *mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETMIPICLOCKLANEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *mode = (FLR_DVO_MIPI_CLOCK_LANE_MODE_E)outVal; + inPtr+=4; + }// end of mode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetMipiClockLaneMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputInterface(const FLR_DVO_OUTPUT_INTERFACE_E format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write format to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_OUTPUT_INTERFACE_E inVal = format; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTINTERFACE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputInterface() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputInterface(FLR_DVO_OUTPUT_INTERFACE_E *format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTINTERFACE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read format from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *format = (FLR_DVO_OUTPUT_INTERFACE_E)outVal; + inPtr+=4; + }// end of format handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputInterface() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoSetOutputFormatVC1(const FLR_DVO_OUTPUT_FORMAT_E format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write format to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVO_OUTPUT_FORMAT_E inVal = format; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_SETOUTPUTFORMATVC1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoSetOutputFormatVC1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvoGetOutputFormatVC1(FLR_DVO_OUTPUT_FORMAT_E *format) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVO_GETOUTPUTFORMATVC1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read format from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *format = (FLR_DVO_OUTPUT_FORMAT_E)outVal; + inPtr+=4; + }// end of format handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvoGetOutputFormatVC1() + +// End Module: dvo +// Begin Module: dvoMux +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvomuxSetType(const FLR_DVOMUX_OUTPUT_IF_E output, const FLR_DVOMUX_SOURCE_E source, const FLR_DVOMUX_TYPE_E type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 12; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write output to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVOMUX_OUTPUT_IF_E inVal = output; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write source to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVOMUX_SOURCE_E inVal = source; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write type to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVOMUX_TYPE_E inVal = type; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVOMUX_SETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgDvomuxSetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgDvomuxGetType(const FLR_DVOMUX_OUTPUT_IF_E output, FLR_DVOMUX_SOURCE_E *source, FLR_DVOMUX_TYPE_E *type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write output to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_DVOMUX_OUTPUT_IF_E inVal = output; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, DVOMUX_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read source from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *source = (FLR_DVOMUX_SOURCE_E)outVal; + inPtr+=4; + }// end of source handling + + // read type from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *type = (FLR_DVOMUX_TYPE_E)outVal; + inPtr+=4; + }// end of type handling + + return R_SUCCESS; + +}// End of CLIENT_pkgDvomuxGetType() + +// End Module: dvoMux +// Begin Module: fileOps +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsDir(uint8_t *dirent) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_DIR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read dirent from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + dirent[0] = outVal[0]; + dirent[1] = outVal[1]; + dirent[2] = outVal[2]; + dirent[3] = outVal[3]; + dirent[4] = outVal[4]; + dirent[5] = outVal[5]; + dirent[6] = outVal[6]; + dirent[7] = outVal[7]; + dirent[8] = outVal[8]; + dirent[9] = outVal[9]; + dirent[10] = outVal[10]; + dirent[11] = outVal[11]; + dirent[12] = outVal[12]; + dirent[13] = outVal[13]; + dirent[14] = outVal[14]; + dirent[15] = outVal[15]; + dirent[16] = outVal[16]; + dirent[17] = outVal[17]; + dirent[18] = outVal[18]; + dirent[19] = outVal[19]; + dirent[20] = outVal[20]; + dirent[21] = outVal[21]; + dirent[22] = outVal[22]; + dirent[23] = outVal[23]; + dirent[24] = outVal[24]; + dirent[25] = outVal[25]; + dirent[26] = outVal[26]; + dirent[27] = outVal[27]; + dirent[28] = outVal[28]; + dirent[29] = outVal[29]; + dirent[30] = outVal[30]; + dirent[31] = outVal[31]; + dirent[32] = outVal[32]; + dirent[33] = outVal[33]; + dirent[34] = outVal[34]; + dirent[35] = outVal[35]; + dirent[36] = outVal[36]; + dirent[37] = outVal[37]; + dirent[38] = outVal[38]; + dirent[39] = outVal[39]; + dirent[40] = outVal[40]; + dirent[41] = outVal[41]; + dirent[42] = outVal[42]; + dirent[43] = outVal[43]; + dirent[44] = outVal[44]; + dirent[45] = outVal[45]; + dirent[46] = outVal[46]; + dirent[47] = outVal[47]; + dirent[48] = outVal[48]; + dirent[49] = outVal[49]; + dirent[50] = outVal[50]; + dirent[51] = outVal[51]; + dirent[52] = outVal[52]; + dirent[53] = outVal[53]; + dirent[54] = outVal[54]; + dirent[55] = outVal[55]; + dirent[56] = outVal[56]; + dirent[57] = outVal[57]; + dirent[58] = outVal[58]; + dirent[59] = outVal[59]; + dirent[60] = outVal[60]; + dirent[61] = outVal[61]; + dirent[62] = outVal[62]; + dirent[63] = outVal[63]; + dirent[64] = outVal[64]; + dirent[65] = outVal[65]; + dirent[66] = outVal[66]; + dirent[67] = outVal[67]; + dirent[68] = outVal[68]; + dirent[69] = outVal[69]; + dirent[70] = outVal[70]; + dirent[71] = outVal[71]; + dirent[72] = outVal[72]; + dirent[73] = outVal[73]; + dirent[74] = outVal[74]; + dirent[75] = outVal[75]; + dirent[76] = outVal[76]; + dirent[77] = outVal[77]; + dirent[78] = outVal[78]; + dirent[79] = outVal[79]; + dirent[80] = outVal[80]; + dirent[81] = outVal[81]; + dirent[82] = outVal[82]; + dirent[83] = outVal[83]; + dirent[84] = outVal[84]; + dirent[85] = outVal[85]; + dirent[86] = outVal[86]; + dirent[87] = outVal[87]; + dirent[88] = outVal[88]; + dirent[89] = outVal[89]; + dirent[90] = outVal[90]; + dirent[91] = outVal[91]; + dirent[92] = outVal[92]; + dirent[93] = outVal[93]; + dirent[94] = outVal[94]; + dirent[95] = outVal[95]; + dirent[96] = outVal[96]; + dirent[97] = outVal[97]; + dirent[98] = outVal[98]; + dirent[99] = outVal[99]; + dirent[100] = outVal[100]; + dirent[101] = outVal[101]; + dirent[102] = outVal[102]; + dirent[103] = outVal[103]; + dirent[104] = outVal[104]; + dirent[105] = outVal[105]; + dirent[106] = outVal[106]; + dirent[107] = outVal[107]; + dirent[108] = outVal[108]; + dirent[109] = outVal[109]; + dirent[110] = outVal[110]; + dirent[111] = outVal[111]; + dirent[112] = outVal[112]; + dirent[113] = outVal[113]; + dirent[114] = outVal[114]; + dirent[115] = outVal[115]; + dirent[116] = outVal[116]; + dirent[117] = outVal[117]; + dirent[118] = outVal[118]; + dirent[119] = outVal[119]; + dirent[120] = outVal[120]; + dirent[121] = outVal[121]; + dirent[122] = outVal[122]; + dirent[123] = outVal[123]; + dirent[124] = outVal[124]; + dirent[125] = outVal[125]; + dirent[126] = outVal[126]; + dirent[127] = outVal[127]; + inPtr+=128; + }// end of dirent handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsDir() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsCd(const uint8_t path[], uint8_t *pwd) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 128; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_CD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read pwd from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + pwd[0] = outVal[0]; + pwd[1] = outVal[1]; + pwd[2] = outVal[2]; + pwd[3] = outVal[3]; + pwd[4] = outVal[4]; + pwd[5] = outVal[5]; + pwd[6] = outVal[6]; + pwd[7] = outVal[7]; + pwd[8] = outVal[8]; + pwd[9] = outVal[9]; + pwd[10] = outVal[10]; + pwd[11] = outVal[11]; + pwd[12] = outVal[12]; + pwd[13] = outVal[13]; + pwd[14] = outVal[14]; + pwd[15] = outVal[15]; + pwd[16] = outVal[16]; + pwd[17] = outVal[17]; + pwd[18] = outVal[18]; + pwd[19] = outVal[19]; + pwd[20] = outVal[20]; + pwd[21] = outVal[21]; + pwd[22] = outVal[22]; + pwd[23] = outVal[23]; + pwd[24] = outVal[24]; + pwd[25] = outVal[25]; + pwd[26] = outVal[26]; + pwd[27] = outVal[27]; + pwd[28] = outVal[28]; + pwd[29] = outVal[29]; + pwd[30] = outVal[30]; + pwd[31] = outVal[31]; + pwd[32] = outVal[32]; + pwd[33] = outVal[33]; + pwd[34] = outVal[34]; + pwd[35] = outVal[35]; + pwd[36] = outVal[36]; + pwd[37] = outVal[37]; + pwd[38] = outVal[38]; + pwd[39] = outVal[39]; + pwd[40] = outVal[40]; + pwd[41] = outVal[41]; + pwd[42] = outVal[42]; + pwd[43] = outVal[43]; + pwd[44] = outVal[44]; + pwd[45] = outVal[45]; + pwd[46] = outVal[46]; + pwd[47] = outVal[47]; + pwd[48] = outVal[48]; + pwd[49] = outVal[49]; + pwd[50] = outVal[50]; + pwd[51] = outVal[51]; + pwd[52] = outVal[52]; + pwd[53] = outVal[53]; + pwd[54] = outVal[54]; + pwd[55] = outVal[55]; + pwd[56] = outVal[56]; + pwd[57] = outVal[57]; + pwd[58] = outVal[58]; + pwd[59] = outVal[59]; + pwd[60] = outVal[60]; + pwd[61] = outVal[61]; + pwd[62] = outVal[62]; + pwd[63] = outVal[63]; + pwd[64] = outVal[64]; + pwd[65] = outVal[65]; + pwd[66] = outVal[66]; + pwd[67] = outVal[67]; + pwd[68] = outVal[68]; + pwd[69] = outVal[69]; + pwd[70] = outVal[70]; + pwd[71] = outVal[71]; + pwd[72] = outVal[72]; + pwd[73] = outVal[73]; + pwd[74] = outVal[74]; + pwd[75] = outVal[75]; + pwd[76] = outVal[76]; + pwd[77] = outVal[77]; + pwd[78] = outVal[78]; + pwd[79] = outVal[79]; + pwd[80] = outVal[80]; + pwd[81] = outVal[81]; + pwd[82] = outVal[82]; + pwd[83] = outVal[83]; + pwd[84] = outVal[84]; + pwd[85] = outVal[85]; + pwd[86] = outVal[86]; + pwd[87] = outVal[87]; + pwd[88] = outVal[88]; + pwd[89] = outVal[89]; + pwd[90] = outVal[90]; + pwd[91] = outVal[91]; + pwd[92] = outVal[92]; + pwd[93] = outVal[93]; + pwd[94] = outVal[94]; + pwd[95] = outVal[95]; + pwd[96] = outVal[96]; + pwd[97] = outVal[97]; + pwd[98] = outVal[98]; + pwd[99] = outVal[99]; + pwd[100] = outVal[100]; + pwd[101] = outVal[101]; + pwd[102] = outVal[102]; + pwd[103] = outVal[103]; + pwd[104] = outVal[104]; + pwd[105] = outVal[105]; + pwd[106] = outVal[106]; + pwd[107] = outVal[107]; + pwd[108] = outVal[108]; + pwd[109] = outVal[109]; + pwd[110] = outVal[110]; + pwd[111] = outVal[111]; + pwd[112] = outVal[112]; + pwd[113] = outVal[113]; + pwd[114] = outVal[114]; + pwd[115] = outVal[115]; + pwd[116] = outVal[116]; + pwd[117] = outVal[117]; + pwd[118] = outVal[118]; + pwd[119] = outVal[119]; + pwd[120] = outVal[120]; + pwd[121] = outVal[121]; + pwd[122] = outVal[122]; + pwd[123] = outVal[123]; + pwd[124] = outVal[124]; + pwd[125] = outVal[125]; + pwd[126] = outVal[126]; + pwd[127] = outVal[127]; + inPtr+=128; + }// end of pwd handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsCd() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsMd(const uint8_t path[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 128; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_MD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsMd() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFopen(const uint8_t path[], const uint8_t mode[], uint32_t *id) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 256; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {mode[0], mode[1], mode[2], mode[3], mode[4], mode[5], mode[6], mode[7], mode[8], mode[9], mode[10], mode[11], mode[12], mode[13], mode[14], mode[15], mode[16], mode[17], mode[18], mode[19], mode[20], mode[21], mode[22], mode[23], mode[24], mode[25], mode[26], mode[27], mode[28], mode[29], mode[30], mode[31], mode[32], mode[33], mode[34], mode[35], mode[36], mode[37], mode[38], mode[39], mode[40], mode[41], mode[42], mode[43], mode[44], mode[45], mode[46], mode[47], mode[48], mode[49], mode[50], mode[51], mode[52], mode[53], mode[54], mode[55], mode[56], mode[57], mode[58], mode[59], mode[60], mode[61], mode[62], mode[63], mode[64], mode[65], mode[66], mode[67], mode[68], mode[69], mode[70], mode[71], mode[72], mode[73], mode[74], mode[75], mode[76], mode[77], mode[78], mode[79], mode[80], mode[81], mode[82], mode[83], mode[84], mode[85], mode[86], mode[87], mode[88], mode[89], mode[90], mode[91], mode[92], mode[93], mode[94], mode[95], mode[96], mode[97], mode[98], mode[99], mode[100], mode[101], mode[102], mode[103], mode[104], mode[105], mode[106], mode[107], mode[108], mode[109], mode[110], mode[111], mode[112], mode[113], mode[114], mode[115], mode[116], mode[117], mode[118], mode[119], mode[120], mode[121], mode[122], mode[123], mode[124], mode[125], mode[126], mode[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FOPEN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read id from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *id = (uint32_t)outVal; + inPtr+=4; + }// end of id handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFopen() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFclose(const uint32_t id) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FCLOSE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFclose() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFread(const uint32_t id, const uint32_t length, uint8_t *buf, uint32_t *ret) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 132; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write length to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = length; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FREAD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read buf from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + buf[0] = outVal[0]; + buf[1] = outVal[1]; + buf[2] = outVal[2]; + buf[3] = outVal[3]; + buf[4] = outVal[4]; + buf[5] = outVal[5]; + buf[6] = outVal[6]; + buf[7] = outVal[7]; + buf[8] = outVal[8]; + buf[9] = outVal[9]; + buf[10] = outVal[10]; + buf[11] = outVal[11]; + buf[12] = outVal[12]; + buf[13] = outVal[13]; + buf[14] = outVal[14]; + buf[15] = outVal[15]; + buf[16] = outVal[16]; + buf[17] = outVal[17]; + buf[18] = outVal[18]; + buf[19] = outVal[19]; + buf[20] = outVal[20]; + buf[21] = outVal[21]; + buf[22] = outVal[22]; + buf[23] = outVal[23]; + buf[24] = outVal[24]; + buf[25] = outVal[25]; + buf[26] = outVal[26]; + buf[27] = outVal[27]; + buf[28] = outVal[28]; + buf[29] = outVal[29]; + buf[30] = outVal[30]; + buf[31] = outVal[31]; + buf[32] = outVal[32]; + buf[33] = outVal[33]; + buf[34] = outVal[34]; + buf[35] = outVal[35]; + buf[36] = outVal[36]; + buf[37] = outVal[37]; + buf[38] = outVal[38]; + buf[39] = outVal[39]; + buf[40] = outVal[40]; + buf[41] = outVal[41]; + buf[42] = outVal[42]; + buf[43] = outVal[43]; + buf[44] = outVal[44]; + buf[45] = outVal[45]; + buf[46] = outVal[46]; + buf[47] = outVal[47]; + buf[48] = outVal[48]; + buf[49] = outVal[49]; + buf[50] = outVal[50]; + buf[51] = outVal[51]; + buf[52] = outVal[52]; + buf[53] = outVal[53]; + buf[54] = outVal[54]; + buf[55] = outVal[55]; + buf[56] = outVal[56]; + buf[57] = outVal[57]; + buf[58] = outVal[58]; + buf[59] = outVal[59]; + buf[60] = outVal[60]; + buf[61] = outVal[61]; + buf[62] = outVal[62]; + buf[63] = outVal[63]; + buf[64] = outVal[64]; + buf[65] = outVal[65]; + buf[66] = outVal[66]; + buf[67] = outVal[67]; + buf[68] = outVal[68]; + buf[69] = outVal[69]; + buf[70] = outVal[70]; + buf[71] = outVal[71]; + buf[72] = outVal[72]; + buf[73] = outVal[73]; + buf[74] = outVal[74]; + buf[75] = outVal[75]; + buf[76] = outVal[76]; + buf[77] = outVal[77]; + buf[78] = outVal[78]; + buf[79] = outVal[79]; + buf[80] = outVal[80]; + buf[81] = outVal[81]; + buf[82] = outVal[82]; + buf[83] = outVal[83]; + buf[84] = outVal[84]; + buf[85] = outVal[85]; + buf[86] = outVal[86]; + buf[87] = outVal[87]; + buf[88] = outVal[88]; + buf[89] = outVal[89]; + buf[90] = outVal[90]; + buf[91] = outVal[91]; + buf[92] = outVal[92]; + buf[93] = outVal[93]; + buf[94] = outVal[94]; + buf[95] = outVal[95]; + buf[96] = outVal[96]; + buf[97] = outVal[97]; + buf[98] = outVal[98]; + buf[99] = outVal[99]; + buf[100] = outVal[100]; + buf[101] = outVal[101]; + buf[102] = outVal[102]; + buf[103] = outVal[103]; + buf[104] = outVal[104]; + buf[105] = outVal[105]; + buf[106] = outVal[106]; + buf[107] = outVal[107]; + buf[108] = outVal[108]; + buf[109] = outVal[109]; + buf[110] = outVal[110]; + buf[111] = outVal[111]; + buf[112] = outVal[112]; + buf[113] = outVal[113]; + buf[114] = outVal[114]; + buf[115] = outVal[115]; + buf[116] = outVal[116]; + buf[117] = outVal[117]; + buf[118] = outVal[118]; + buf[119] = outVal[119]; + buf[120] = outVal[120]; + buf[121] = outVal[121]; + buf[122] = outVal[122]; + buf[123] = outVal[123]; + buf[124] = outVal[124]; + buf[125] = outVal[125]; + buf[126] = outVal[126]; + buf[127] = outVal[127]; + inPtr+=128; + }// end of buf handling + + // read ret from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *ret = (uint32_t)outVal; + inPtr+=4; + }// end of ret handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFread() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFwrite(const uint32_t id, const uint32_t length, const uint8_t buf[], uint32_t *ret) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 136; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write length to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = length; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write buf to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15], buf[16], buf[17], buf[18], buf[19], buf[20], buf[21], buf[22], buf[23], buf[24], buf[25], buf[26], buf[27], buf[28], buf[29], buf[30], buf[31], buf[32], buf[33], buf[34], buf[35], buf[36], buf[37], buf[38], buf[39], buf[40], buf[41], buf[42], buf[43], buf[44], buf[45], buf[46], buf[47], buf[48], buf[49], buf[50], buf[51], buf[52], buf[53], buf[54], buf[55], buf[56], buf[57], buf[58], buf[59], buf[60], buf[61], buf[62], buf[63], buf[64], buf[65], buf[66], buf[67], buf[68], buf[69], buf[70], buf[71], buf[72], buf[73], buf[74], buf[75], buf[76], buf[77], buf[78], buf[79], buf[80], buf[81], buf[82], buf[83], buf[84], buf[85], buf[86], buf[87], buf[88], buf[89], buf[90], buf[91], buf[92], buf[93], buf[94], buf[95], buf[96], buf[97], buf[98], buf[99], buf[100], buf[101], buf[102], buf[103], buf[104], buf[105], buf[106], buf[107], buf[108], buf[109], buf[110], buf[111], buf[112], buf[113], buf[114], buf[115], buf[116], buf[117], buf[118], buf[119], buf[120], buf[121], buf[122], buf[123], buf[124], buf[125], buf[126], buf[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FWRITE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read ret from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *ret = (uint32_t)outVal; + inPtr+=4; + }// end of ret handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFwrite() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFtell(const uint32_t id, uint32_t *offset) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FTELL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read offset from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *offset = (uint32_t)outVal; + inPtr+=4; + }// end of offset handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFtell() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFseek(const uint32_t id, const uint32_t offset, const uint32_t origin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 12; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write origin to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = origin; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FSEEK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFseek() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsFtruncate(const uint32_t id, const uint32_t length) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = id; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write length to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = length; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_FTRUNCATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsFtruncate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsRmdir(const uint8_t path[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 128; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_RMDIR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsRmdir() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsRm(const uint8_t path[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 128; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_RM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsRm() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsRename(const uint8_t oldpath[], const uint8_t newpath[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 256; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write oldpath to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {oldpath[0], oldpath[1], oldpath[2], oldpath[3], oldpath[4], oldpath[5], oldpath[6], oldpath[7], oldpath[8], oldpath[9], oldpath[10], oldpath[11], oldpath[12], oldpath[13], oldpath[14], oldpath[15], oldpath[16], oldpath[17], oldpath[18], oldpath[19], oldpath[20], oldpath[21], oldpath[22], oldpath[23], oldpath[24], oldpath[25], oldpath[26], oldpath[27], oldpath[28], oldpath[29], oldpath[30], oldpath[31], oldpath[32], oldpath[33], oldpath[34], oldpath[35], oldpath[36], oldpath[37], oldpath[38], oldpath[39], oldpath[40], oldpath[41], oldpath[42], oldpath[43], oldpath[44], oldpath[45], oldpath[46], oldpath[47], oldpath[48], oldpath[49], oldpath[50], oldpath[51], oldpath[52], oldpath[53], oldpath[54], oldpath[55], oldpath[56], oldpath[57], oldpath[58], oldpath[59], oldpath[60], oldpath[61], oldpath[62], oldpath[63], oldpath[64], oldpath[65], oldpath[66], oldpath[67], oldpath[68], oldpath[69], oldpath[70], oldpath[71], oldpath[72], oldpath[73], oldpath[74], oldpath[75], oldpath[76], oldpath[77], oldpath[78], oldpath[79], oldpath[80], oldpath[81], oldpath[82], oldpath[83], oldpath[84], oldpath[85], oldpath[86], oldpath[87], oldpath[88], oldpath[89], oldpath[90], oldpath[91], oldpath[92], oldpath[93], oldpath[94], oldpath[95], oldpath[96], oldpath[97], oldpath[98], oldpath[99], oldpath[100], oldpath[101], oldpath[102], oldpath[103], oldpath[104], oldpath[105], oldpath[106], oldpath[107], oldpath[108], oldpath[109], oldpath[110], oldpath[111], oldpath[112], oldpath[113], oldpath[114], oldpath[115], oldpath[116], oldpath[117], oldpath[118], oldpath[119], oldpath[120], oldpath[121], oldpath[122], oldpath[123], oldpath[124], oldpath[125], oldpath[126], oldpath[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + //write newpath to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {newpath[0], newpath[1], newpath[2], newpath[3], newpath[4], newpath[5], newpath[6], newpath[7], newpath[8], newpath[9], newpath[10], newpath[11], newpath[12], newpath[13], newpath[14], newpath[15], newpath[16], newpath[17], newpath[18], newpath[19], newpath[20], newpath[21], newpath[22], newpath[23], newpath[24], newpath[25], newpath[26], newpath[27], newpath[28], newpath[29], newpath[30], newpath[31], newpath[32], newpath[33], newpath[34], newpath[35], newpath[36], newpath[37], newpath[38], newpath[39], newpath[40], newpath[41], newpath[42], newpath[43], newpath[44], newpath[45], newpath[46], newpath[47], newpath[48], newpath[49], newpath[50], newpath[51], newpath[52], newpath[53], newpath[54], newpath[55], newpath[56], newpath[57], newpath[58], newpath[59], newpath[60], newpath[61], newpath[62], newpath[63], newpath[64], newpath[65], newpath[66], newpath[67], newpath[68], newpath[69], newpath[70], newpath[71], newpath[72], newpath[73], newpath[74], newpath[75], newpath[76], newpath[77], newpath[78], newpath[79], newpath[80], newpath[81], newpath[82], newpath[83], newpath[84], newpath[85], newpath[86], newpath[87], newpath[88], newpath[89], newpath[90], newpath[91], newpath[92], newpath[93], newpath[94], newpath[95], newpath[96], newpath[97], newpath[98], newpath[99], newpath[100], newpath[101], newpath[102], newpath[103], newpath[104], newpath[105], newpath[106], newpath[107], newpath[108], newpath[109], newpath[110], newpath[111], newpath[112], newpath[113], newpath[114], newpath[115], newpath[116], newpath[117], newpath[118], newpath[119], newpath[120], newpath[121], newpath[122], newpath[123], newpath[124], newpath[125], newpath[126], newpath[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_RENAME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsRename() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFileopsGetFileSize(const uint8_t path[], uint32_t *fileLength) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 128; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FILEOPS_GETFILESIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read fileLength from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *fileLength = (uint32_t)outVal; + inPtr+=4; + }// end of fileLength handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFileopsGetFileSize() + +// End Module: fileOps +// Begin Module: flashIO +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFlashioSetProtectionState(const FLR_ENABLE_E protectionState) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write protectionState to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = protectionState; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FLASHIO_SETPROTECTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgFlashioSetProtectionState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFlashioGetProtectionState(FLR_ENABLE_E *protectionState) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FLASHIO_GETPROTECTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read protectionState from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *protectionState = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of protectionState handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFlashioGetProtectionState() + +// End Module: flashIO +// Begin Module: flashMapFs +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgFlashmapfsGetHeaderVersion(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, FLASHMAPFS_GETHEADERVERSION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgFlashmapfsGetHeaderVersion() + +// End Module: flashMapFs +// Begin Module: gao +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetGainState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETGAINSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetGainState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetGainState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETGAINSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetGainState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetFfcState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETFFCSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetFfcState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetFfcState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETFFCSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetFfcState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetTempCorrectionState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETTEMPCORRECTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetTempCorrectionState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetTempCorrectionState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETTEMPCORRECTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetTempCorrectionState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetIConstL(const int16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = data; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETICONSTL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetIConstL() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetIConstL(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETICONSTL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetIConstL() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetIConstM(const int16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = data; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETICONSTM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetIConstM() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetIConstM(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETICONSTM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetIConstM() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetAveragerState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETAVERAGERSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetAveragerState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAveragerState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAVERAGERSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAveragerState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetNumFFCFrames(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETNUMFFCFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetNumFFCFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetNumFFCFrames(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETNUMFFCFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetNumFFCFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAveragerThreshold(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAVERAGERTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAveragerThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetTestRampState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETTESTRAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetTestRampState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetTestRampState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETTESTRAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetTestRampState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetSffcState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETSFFCSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetSffcState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetSffcState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETSFFCSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetSffcState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetNucType(const FLR_GAO_NUC_TYPE_E nucType) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write nucType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_GAO_NUC_TYPE_E inVal = nucType; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETNUCTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetNucType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetNucType(FLR_GAO_NUC_TYPE_E *nucType) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETNUCTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read nucType from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *nucType = (FLR_GAO_NUC_TYPE_E)outVal; + inPtr+=4; + }// end of nucType handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetNucType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetFfcZeroMeanState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETFFCZEROMEANSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetFfcZeroMeanState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetFfcZeroMeanState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETFFCZEROMEANSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetFfcZeroMeanState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAveragerDesiredState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAVERAGERDESIREDSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAveragerDesiredState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAppliedClip(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAPPLIEDCLIP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAppliedClip() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetAppliedClipEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETAPPLIEDCLIPENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetAppliedClipEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAppliedClipEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAPPLIEDCLIPENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAppliedClipEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetFfcShutterSimulationState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETFFCSHUTTERSIMULATIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetFfcShutterSimulationState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetFfcShutterSimulationState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETFFCSHUTTERSIMULATIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetFfcShutterSimulationState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetFfcShutterSimulatorValue(const uint16_t value) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write value to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = value; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETFFCSHUTTERSIMULATORVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetFfcShutterSimulatorValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetFfcShutterSimulatorValue(uint16_t *value) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETFFCSHUTTERSIMULATORVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read value from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *value = (uint16_t)outVal; + inPtr+=2; + }// end of value handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetFfcShutterSimulatorValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetBcnrState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETBCNRSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetBcnrState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetBcnrState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETBCNRSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetBcnrState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetAppliedSffcScaleFactor(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETAPPLIEDSFFCSCALEFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetAppliedSffcScaleFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoSetSffcMode(const FLR_GAO_SFFC_MODE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_GAO_SFFC_MODE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETSFFCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoSetSffcMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgGaoGetSffcMode(FLR_GAO_SFFC_MODE_E *mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_GETSFFCMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *mode = (FLR_GAO_SFFC_MODE_E)outVal; + inPtr+=4; + }// end of mode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgGaoGetSffcMode() + +// End Module: gao +// Begin Module: imageStats +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetTotalHistPixelsInROI(uint32_t *totalPixelsInROI) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETTOTALHISTPIXELSINROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read totalPixelsInROI from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *totalPixelsInROI = (uint32_t)outVal; + inPtr+=4; + }// end of totalPixelsInROI handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetTotalHistPixelsInROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetPopBelowLowToHighThresh(uint32_t *popBelowLowToHighThresh) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETPOPBELOWLOWTOHIGHTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read popBelowLowToHighThresh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *popBelowLowToHighThresh = (uint32_t)outVal; + inPtr+=4; + }// end of popBelowLowToHighThresh handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetPopBelowLowToHighThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetPopAboveHighToLowThresh(uint32_t *popAboveHighToLowThresh) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETPOPABOVEHIGHTOLOWTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read popAboveHighToLowThresh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *popAboveHighToLowThresh = (uint32_t)outVal; + inPtr+=4; + }// end of popAboveHighToLowThresh handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetPopAboveHighToLowThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsSetROI(const FLR_ROI_T roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write roi to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ROI_T *inVal = (const FLR_ROI_T *) &roi; + FLR_ROI_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 8; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_SETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsSetROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetROI(FLR_ROI_T *roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read roi from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ROI_T outVal; + byteToFLR_ROI_T( (const uint8_t *) inPtr, &outVal); + *roi = (FLR_ROI_T)outVal; + inPtr+=8; + }// end of roi handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetFirstBin(uint16_t *firstBin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETFIRSTBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read firstBin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *firstBin = (uint16_t)outVal; + inPtr+=2; + }// end of firstBin handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetFirstBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetLastBin(uint16_t *lastBin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETLASTBIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read lastBin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *lastBin = (uint16_t)outVal; + inPtr+=2; + }// end of lastBin handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetLastBin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetMean(uint16_t *mean) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETMEAN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mean from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *mean = (uint16_t)outVal; + inPtr+=2; + }// end of mean handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetMean() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetFirstBinInROI(uint16_t *firstBinInROI) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETFIRSTBININROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read firstBinInROI from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *firstBinInROI = (uint16_t)outVal; + inPtr+=2; + }// end of firstBinInROI handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetFirstBinInROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetLastBinInROI(uint16_t *lastBinInROI) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETLASTBININROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read lastBinInROI from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *lastBinInROI = (uint16_t)outVal; + inPtr+=2; + }// end of lastBinInROI handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetLastBinInROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetMeanInROI(uint16_t *meanInROI) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETMEANINROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read meanInROI from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *meanInROI = (uint16_t)outVal; + inPtr+=2; + }// end of meanInROI handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetMeanInROI() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetImageStats(uint16_t *meanIntensity, uint16_t *peakIntensity, uint16_t *baseIntensity) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 6; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETIMAGESTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read meanIntensity from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *meanIntensity = (uint16_t)outVal; + inPtr+=2; + }// end of meanIntensity handling + + // read peakIntensity from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *peakIntensity = (uint16_t)outVal; + inPtr+=2; + }// end of peakIntensity handling + + // read baseIntensity from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *baseIntensity = (uint16_t)outVal; + inPtr+=2; + }// end of baseIntensity handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetImageStats() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetPopAboveLowToHighThreshCATS(uint32_t *popAboveLowToHighThresh) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETPOPABOVELOWTOHIGHTHRESHCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read popAboveLowToHighThresh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *popAboveLowToHighThresh = (uint32_t)outVal; + inPtr+=4; + }// end of popAboveLowToHighThresh handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetPopAboveLowToHighThreshCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetPopBelowHighToLowThreshCATS(uint32_t *popBelowHighToLowThresh) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETPOPBELOWHIGHTOLOWTHRESHCATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read popBelowHighToLowThresh from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *popBelowHighToLowThresh = (uint32_t)outVal; + inPtr+=4; + }// end of popBelowHighToLowThresh handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetPopBelowHighToLowThreshCATS() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgImagestatsGetPopBetweenLthCATSAndLthSATS(uint32_t *popBetweenCatsAndSats) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, IMAGESTATS_GETPOPBETWEENLTHCATSANDLTHSATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read popBetweenCatsAndSats from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *popBetweenCatsAndSats = (uint32_t)outVal; + inPtr+=4; + }// end of popBetweenCatsAndSats handling + + return R_SUCCESS; + +}// End of CLIENT_pkgImagestatsGetPopBetweenLthCATSAndLthSATS() + +// End Module: imageStats +// Begin Module: isotherm +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermGetEnable(FLR_ENABLE_E *isothermEnable) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read isothermEnable from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *isothermEnable = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of isothermEnable handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermSetEnable(const FLR_ENABLE_E isothermEnable) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write isothermEnable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = isothermEnable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 24; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write thIsoT1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = thIsoT1; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write thIsoT2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = thIsoT2; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write thIsoT3 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = thIsoT3; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write thIsoT4 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = thIsoT4; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write thIsoT5 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = thIsoT5; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETTEMPS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetTemps() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 20; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETTEMPS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read thIsoT1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *thIsoT1 = (int32_t)outVal; + inPtr+=4; + }// end of thIsoT1 handling + + // read thIsoT2 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *thIsoT2 = (int32_t)outVal; + inPtr+=4; + }// end of thIsoT2 handling + + // read thIsoT3 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *thIsoT3 = (int32_t)outVal; + inPtr+=4; + }// end of thIsoT3 handling + + // read thIsoT4 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *thIsoT4 = (int32_t)outVal; + inPtr+=4; + }// end of thIsoT4 handling + + // read thIsoT5 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *thIsoT5 = (int32_t)outVal; + inPtr+=4; + }// end of thIsoT5 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetTemps() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 124; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region0 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion0; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + //write region1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion1; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + //write region2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion2; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + //write region3 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion3; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + //write region4 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion4; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + //write region5 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion5; + FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 20; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETISOCOLORVALUES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetIsoColorValues() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 120; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETISOCOLORVALUES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read region0 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region0 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region0 handling + + // read region1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region1 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region1 handling + + // read region2 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region2 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region2 handling + + // read region3 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region3 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region3 handling + + // read region4 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region4 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region4 handling + + // read region5 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_T outVal; + byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); + *region5 = (FLR_ISOTHERM_COLORS_T)outVal; + inPtr+=20; + }// end of region5 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetIsoColorValues() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 28; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region0 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region0; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region1; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region2; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region3 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region3; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region4 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region4; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write region5 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_REGION_E inVal = region5; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETREGIONMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetRegionMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 24; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write table to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_GAIN_E inVal = table; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETREGIONMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read region0 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region0 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region0 handling + + // read region1 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region1 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region1 handling + + // read region2 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region2 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region2 handling + + // read region3 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region3 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region3 handling + + // read region4 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region4 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region4 handling + + // read region5 from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *region5 = (FLR_ISOTHERM_REGION_E)outVal; + inPtr+=4; + }// end of region5 handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetRegionMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermGetUnit(FLR_ISOTHERM_UNIT_E *unit) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETUNIT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read unit from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *unit = (FLR_ISOTHERM_UNIT_E)outVal; + inPtr+=4; + }// end of unit handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetUnit() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermSetUnit(const FLR_ISOTHERM_UNIT_E unit) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write unit to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_UNIT_E inVal = unit; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETUNIT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetUnit() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermGetSettingsLowGain(FLR_ISOTHERM_SETTINGS_T *settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 164; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETSETTINGSLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read settings from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_SETTINGS_T outVal; + byteToFLR_ISOTHERM_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *settings = (FLR_ISOTHERM_SETTINGS_T)outVal; + inPtr+=164; + }// end of settings handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetSettingsLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermSetSettingsLowGain(const FLR_ISOTHERM_SETTINGS_T settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 164; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write settings to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_SETTINGS_T *inVal = (const FLR_ISOTHERM_SETTINGS_T *) &settings; + FLR_ISOTHERM_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 164; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETSETTINGSLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetSettingsLowGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermGetSettingsHighGain(FLR_ISOTHERM_SETTINGS_T *settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 164; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETSETTINGSHIGHGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read settings from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_SETTINGS_T outVal; + byteToFLR_ISOTHERM_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *settings = (FLR_ISOTHERM_SETTINGS_T)outVal; + inPtr+=164; + }// end of settings handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetSettingsHighGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermSetSettingsHighGain(const FLR_ISOTHERM_SETTINGS_T settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 164; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write settings to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ISOTHERM_SETTINGS_T *inVal = (const FLR_ISOTHERM_SETTINGS_T *) &settings; + FLR_ISOTHERM_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 164; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETSETTINGSHIGHGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetSettingsHighGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermSetColorLutId(const FLR_COLORLUT_ID_E colorLutIdLowGain, const FLR_COLORLUT_ID_E colorLutIdHighGain) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write colorLutIdLowGain to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_COLORLUT_ID_E inVal = colorLutIdLowGain; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write colorLutIdHighGain to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_COLORLUT_ID_E inVal = colorLutIdHighGain; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETCOLORLUTID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermSetColorLutId() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgIsothermGetColorLutId(FLR_COLORLUT_ID_E *colorLutIdLowGain, FLR_COLORLUT_ID_E *colorLutIdHighGain) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETCOLORLUTID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read colorLutIdLowGain from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *colorLutIdLowGain = (FLR_COLORLUT_ID_E)outVal; + inPtr+=4; + }// end of colorLutIdLowGain handling + + // read colorLutIdHighGain from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *colorLutIdHighGain = (FLR_COLORLUT_ID_E)outVal; + inPtr+=4; + }// end of colorLutIdHighGain handling + + return R_SUCCESS; + +}// End of CLIENT_pkgIsothermGetColorLutId() + +// End Module: isotherm +// Begin Module: jffs2 +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgJffs2Mount() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_MOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgJffs2Mount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgJffs2Unmount() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_UNMOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgJffs2Unmount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgJffs2GetState(FLR_JFFS2_STATE_E *state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read state from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *state = (FLR_JFFS2_STATE_E)outVal; + inPtr+=4; + }// end of state handling + + return R_SUCCESS; + +}// End of CLIENT_pkgJffs2GetState() + +// End Module: jffs2 +// Begin Module: lagrange +// End Module: lagrange +// Begin Module: latencyCtrl +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlSetLowLatencyState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETLOWLATENCYSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlSetLowLatencyState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlGetLowLatencyState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETLOWLATENCYSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlGetLowLatencyState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlSetJitterReduction(const FLR_ENABLE_E enable, const int32_t line) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write enable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = enable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write line to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = line; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETJITTERREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlSetJitterReduction() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlGetJitterReduction(FLR_ENABLE_E *enable, int32_t *line) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETJITTERREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read enable from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *enable = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of enable handling + + // read line from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *line = (int32_t)outVal; + inPtr+=4; + }// end of line handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlGetJitterReduction() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlLatencyResetStats() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_LATENCYRESETSTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlLatencyResetStats() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlGetJitter(float *jitterMin, float *jitterMax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETJITTER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read jitterMin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *jitterMin = (float)outVal; + inPtr+=4; + }// end of jitterMin handling + + // read jitterMax from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *jitterMax = (float)outVal; + inPtr+=4; + }// end of jitterMax handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlGetJitter() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlGetLatency(float *latencyMin, float *latencyMax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETLATENCY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read latencyMin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *latencyMin = (float)outVal; + inPtr+=4; + }// end of latencyMin handling + + // read latencyMax from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *latencyMax = (float)outVal; + inPtr+=4; + }// end of latencyMax handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlGetLatency() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction(const int32_t line) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write line to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int32_t inVal = line; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETUSBVIDEOLATENCYREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction(int32_t *line) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETUSBVIDEOLATENCYREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read line from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *line = (int32_t)outVal; + inPtr+=4; + }// end of line handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction() + +// End Module: latencyCtrl +// Begin Module: lfsr +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetApplyOffsetEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETAPPLYOFFSETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetApplyOffsetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetApplyOffsetEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETAPPLYOFFSETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetApplyOffsetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetMaxIterations(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETMAXITERATIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetMaxIterations() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetMaxIterations(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETMAXITERATIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetMaxIterations() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetDf(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetDf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetDf(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetDf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetLambda1(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETLAMBDA1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetLambda1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetLambda1(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETLAMBDA1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetLambda1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetLambda2(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETLAMBDA2, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetLambda2() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetLambda2(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETLAMBDA2, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetLambda2() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetHaltEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETHALTENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetHaltEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetHaltEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETHALTENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetHaltEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetRandomMethod(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETRANDOMMETHOD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetRandomMethod() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetRandomMethod(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETRANDOMMETHOD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetRandomMethod() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetSingleStepEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETSINGLESTEPENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetSingleStepEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetSingleStepEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETSINGLESTEPENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetSingleStepEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetR_LocalBump(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETR_LOCALBUMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetR_LocalBump() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetR_LocalBump(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETR_LOCALBUMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetR_LocalBump() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetR_CornerBump(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETR_CORNERBUMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetR_CornerBump() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetR_CornerBump(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETR_CORNERBUMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetR_CornerBump() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetFFC_ResetEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETFFC_RESETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetFFC_ResetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetFFC_ResetEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETFFC_RESETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetFFC_ResetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrSetNormalizeAtCenterSpotState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETNORMALIZEATCENTERSPOTSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrSetNormalizeAtCenterSpotState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgLfsrGetNormalizeAtCenterSpotState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETNORMALIZEATCENTERSPOTSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgLfsrGetNormalizeAtCenterSpotState() + +// End Module: lfsr +// Begin Module: mem +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 7; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 256; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write bufferNum to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = bufferNum; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write sizeInBytes to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = sizeInBytes; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCAPTURE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); + inPtr+=sizeInBytes; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemReadCapture() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETCAPTURESIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read bytes from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *bytes = (uint32_t)outVal; + inPtr+=4; + }// end of bytes handling + + // read rows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *rows = (uint16_t)outVal; + inPtr+=2; + }// end of rows handling + + // read columns from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *columns = (uint16_t)outVal; + inPtr+=2; + }// end of columns handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemGetCaptureSize() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = (uint32_t) sizeInBytes + 11; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write location to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_MEM_LOCATION_E inVal = location; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write sizeInBytes to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = sizeInBytes; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte(data,sizeInBytes,(const uint8_t *) outPtr); + outPtr += sizeInBytes; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_WRITEFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgMemWriteFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 11; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 256; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write location to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_MEM_LOCATION_E inVal = location; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write sizeInBytes to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = sizeInBytes; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); + inPtr+=sizeInBytes; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemReadFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write location to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_MEM_LOCATION_E inVal = location; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETFLASHSIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read bytes from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *bytes = (uint32_t)outVal; + inPtr+=4; + }// end of bytes handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemGetFlashSize() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 5; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write location to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_MEM_LOCATION_E inVal = location; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_ERASEFLASH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgMemEraseFlash() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write location to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_MEM_LOCATION_E inVal = location; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write length to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = length; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_ERASEFLASHPARTIAL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgMemEraseFlashPartial() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 6; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 256; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write sizeInBytes to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = sizeInBytes; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCURRENTGAIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); + inPtr+=sizeInBytes; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemReadCurrentGain() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETGAINSIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read bytes from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *bytes = (uint32_t)outVal; + inPtr+=4; + }// end of bytes handling + + // read rows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *rows = (uint16_t)outVal; + inPtr+=2; + }// end of rows handling + + // read columns from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *columns = (uint16_t)outVal; + inPtr+=2; + }// end of columns handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemGetGainSize() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgMemGetCaptureSizeSrc(const FLR_CAPTURE_SRC_E src, uint32_t *bytes, uint16_t *rows, uint16_t *columns) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write src to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_CAPTURE_SRC_E inVal = src; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETCAPTURESIZESRC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read bytes from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *bytes = (uint32_t)outVal; + inPtr+=4; + }// end of bytes handling + + // read rows from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *rows = (uint16_t)outVal; + inPtr+=2; + }// end of rows handling + + // read columns from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *columns = (uint16_t)outVal; + inPtr+=2; + }// end of columns handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemGetCaptureSizeSrc() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 11; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 256; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write src to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_CAPTURE_SRC_E inVal = src; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write bufferNum to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = bufferNum; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write offset to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = offset; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write sizeInBytes to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = sizeInBytes; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCAPTURESRC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); + inPtr+=sizeInBytes; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgMemReadCaptureSrc() + +// End Module: mem +// Begin Module: normalize +// End Module: normalize +// Begin Module: radiometry +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempStableEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSTABLEENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempStableEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempStableEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSTABLEENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempStableEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens0(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERLENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetFNumberLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens0(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERLENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetFNumberLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens1(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERLENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetFNumberLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens1(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERLENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetFNumberLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTauLens0(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAULENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTauLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTauLens0(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAULENS0, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTauLens0() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTauLens1(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAULENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTauLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTauLens1(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAULENS1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTauLens1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainDesired(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalGainDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetDesired(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalOffsetDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainApplied(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalGainApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetApplied(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalOffsetApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTComponentOverrideMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTCOMPONENTOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTComponentOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTComponentOverrideMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTCOMPONENTOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTComponentOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetGlobalGainOverride(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALGAINOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetGlobalGainOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainOverride(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalGainOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetGlobalOffsetOverride(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALOFFSETOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetGlobalOffsetOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetOverride(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalOffsetOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetGlobalParamOverrideMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALPARAMOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetGlobalParamOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGlobalParamOverrideMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALPARAMOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGlobalParamOverrideMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; + FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOHIGHGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetRBFOHighGainDefault() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOHIGHGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_RBFO_PARAMS_T outVal; + byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; + inPtr+=16; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRBFOHighGainDefault() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; + FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOLOWGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetRBFOLowGainDefault() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOLOWGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_RBFO_PARAMS_T outVal; + byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; + inPtr+=16; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRBFOLowGainDefault() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; + FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOHIGHGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetRBFOHighGainFactory() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOHIGHGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_RBFO_PARAMS_T outVal; + byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; + inPtr+=16; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRBFOHighGainFactory() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; + FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOLOWGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetRBFOLowGainFactory() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOLOWGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_RBFO_PARAMS_T outVal; + byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; + inPtr+=16; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRBFOLowGainFactory() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetDampingFactor(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetDampingFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetDampingFactor(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetDampingFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGoMEQ(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMEQ, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGoMEQ() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGoMShutter(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMSHUTTER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGoMShutter() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGoMLens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMLENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGoMLens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGoMLG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMLG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGoMLG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGoMFFC(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMFFC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGoMFFC() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousing(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPLENSHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempLensHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousing(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempShutterHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddle(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERPADDLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempShutterPaddle() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetFNumberShutterHousing(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetFNumberShutterHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetFNumberShutterHousing(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetFNumberShutterHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetEmissivityShutterHousing(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEMISSIVITYSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetEmissivityShutterHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetEmissivityShutterHousing(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEMISSIVITYSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetEmissivityShutterHousing() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Lens(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_DTfpa_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Lens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_DTfpa_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetOffset_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetOffset_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Lens(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Recursive_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Lens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Recursive_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGgFfc(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGGFFC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGgFfc() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetCountsFromTemp(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const float temp, uint16_t *counts) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write rbfoType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_TYPE_E inVal = rbfoType; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write temp to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = temp; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETCOUNTSFROMTEMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read counts from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *counts = (uint16_t)outVal; + inPtr+=2; + }// end of counts handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetCountsFromTemp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempFromCounts(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const uint16_t counts, float *temp) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 6; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write rbfoType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_RBFO_TYPE_E inVal = rbfoType; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write counts to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = counts; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPFROMCOUNTS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read temp from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *temp = (float)outVal; + inPtr+=4; + }// end of temp handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempFromCounts() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempLensHousingOverride(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPLENSHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempLensHousingOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousingOverride(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPLENSHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempLensHousingOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempShutterHousingOverride(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSHUTTERHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempShutterHousingOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousingOverride(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempShutterHousingOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempShutterPaddleOverride(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSHUTTERPADDLEOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempShutterPaddleOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddleOverride(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERPADDLEOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempShutterPaddleOverride() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetSignalFactorLut(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 34; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *inVal = (const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *) &data; + FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 34; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETSIGNALFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetSignalFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetSignalFactorLut(FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 34; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSIGNALFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T outVal; + byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T)outVal; + inPtr+=34; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetSignalFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetNoiseFactorLut(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 34; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *inVal = (const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *) &data; + FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 34; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETNOISEFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetNoiseFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetNoiseFactorLut(FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 34; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETNOISEFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T outVal; + byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T)outVal; + inPtr+=34; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetNoiseFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_tfpaK(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_tfpaK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_tfpaK(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_tfpaK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_tfpaK(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_tfpaK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_tfpaK(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_tfpaK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTAuxParams(const FLR_RADIOMETRY_TAUX_PARAMS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 16; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_RADIOMETRY_TAUX_PARAMS_T *inVal = (const FLR_RADIOMETRY_TAUX_PARAMS_T *) &data; + FLR_RADIOMETRY_TAUX_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 16; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAUXPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTAuxParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTAuxParams(FLR_RADIOMETRY_TAUX_PARAMS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAUXPARAMS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_TAUX_PARAMS_T outVal; + byteToFLR_RADIOMETRY_TAUX_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_TAUX_PARAMS_T)outVal; + inPtr+=16; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTAuxParams() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_tAux(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_TAUX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_tAux() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_tAux(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_TAUX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_tAux() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_tAux(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_TAUX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_tAux() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_tAux(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_TAUX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_tAux() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTsource_FFC(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTSOURCE_FFC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTsource_FFC() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTsource_FFC(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTSOURCE_FFC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTsource_FFC() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_h(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_DTfpa_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_h(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_DTfpa_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_h(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetOffset_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_h(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetOffset_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_h(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Recursive_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_h(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Recursive_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_p(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_DTfpa_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_p(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_DTfpa_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_p(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetOffset_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_p(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetOffset_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_p(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Recursive_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_p(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Recursive_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDTTFPAK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetDtTfpaK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK_Damp(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDTTFPAK_DAMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetDtTfpaK_Damp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTAuxK(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAUXK, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTAuxK() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetExternalFfcUpdateMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEXTERNALFFCUPDATEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetExternalFfcUpdateMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetExternalFfcUpdateMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEXTERNALFFCUPDATEMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetExternalFfcUpdateMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGG_scale(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGG_scale() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempWindow(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempWindow(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTransmissionWindow(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTRANSMISSIONWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTransmissionWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTransmissionWindow(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTRANSMISSIONWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTransmissionWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetReflectivityWindow(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETREFLECTIVITYWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetReflectivityWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetReflectivityWindow(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETREFLECTIVITYWINDOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetReflectivityWindow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempWindowReflection(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPWINDOWREFLECTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempWindowReflection() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempWindowReflection(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPWINDOWREFLECTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempWindowReflection() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTransmissionAtmosphere(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTRANSMISSIONATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTransmissionAtmosphere() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTransmissionAtmosphere(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTRANSMISSIONATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTransmissionAtmosphere() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempAtmosphere(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempAtmosphere() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempAtmosphere(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempAtmosphere() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetEmissivityTarget(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEMISSIVITYTARGET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetEmissivityTarget() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetEmissivityTarget(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEMISSIVITYTARGET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetEmissivityTarget() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTempBackground(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPBACKGROUND, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTempBackground() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTempBackground(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPBACKGROUND, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTempBackground() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRadiometryCapable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRADIOMETRYCAPABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRadiometryCapable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingFactor(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetdeltaTempDampingFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingFactor(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetdeltaTempDampingFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempIntervalTime(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPINTERVALTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetdeltaTempIntervalTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempIntervalTime(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPINTERVALTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetdeltaTempIntervalTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxValue(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetdeltaTempMaxValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxValue(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetdeltaTempMaxValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxIncrement(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPMAXINCREMENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetdeltaTempMaxIncrement() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxIncrement(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPMAXINCREMENT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetdeltaTempMaxIncrement() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingTime(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPDAMPINGTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetdeltaTempDampingTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingTime(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPDAMPINGTIME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetdeltaTempDampingTime() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetResponsivityFpaTemp(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRESPONSIVITYFPATEMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetResponsivityFpaTemp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Lens() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGG_SCALE_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetGG_Scale_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGG_Scale_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGG_SCALE_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetGG_Scale_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGG_Scale_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetRbfoScaledMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOSCALEDMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetRbfoScaledMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetRbfoScaledMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOSCALEDMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetRbfoScaledMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyFactor(FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETUNCERTAINTYFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetUncertaintyFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTRoomMinThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTROOMMINTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTRoomMinThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTRoomMaxThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTROOMMAXTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTRoomMaxThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMinThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTOPERATINGMINTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTOperatingMinThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMaxThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTOPERATINGMAXTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTOperatingMaxThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetStableTempThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSTABLETEMPTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetStableTempThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetSlowDriftThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSLOWDRIFTTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetSlowDriftThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetFfcTempThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFFCTEMPTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetFfcTempThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshLG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMINTHRESHLG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTargetTempMinThreshLG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshLG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMAXTHRESHLG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTargetTempMaxThreshLG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetMFactorThresh(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETMFACTORTHRESH, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetMFactorThresh() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshHG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMINTHRESHHG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTargetTempMinThreshHG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshHG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMAXTHRESHHG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTargetTempMaxThreshHG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyStatusBits(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETUNCERTAINTYSTATUSBITS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetUncertaintyStatusBits() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPERATUREOFFSET_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTemperatureOffset_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPERATUREOFFSET_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTemperatureOffset_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPERATUREOFFSET_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetTemperatureOffset_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPERATUREOFFSET_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetTemperatureOffset_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetOffset_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetOffset_Lens_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetOffset_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetOffset_Lens_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRadiometryGetGG_RoomTemp(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_ROOMTEMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRadiometryGetGG_RoomTemp() + +// End Module: radiometry +// Begin Module: roic +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPATemp(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPATemp() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFrameCount(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFRAMECOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFrameCount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetActiveNormalizationTarget(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETACTIVENORMALIZATIONTARGET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetActiveNormalizationTarget() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFPARampState(const FLR_ENABLE_E state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write state to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = state; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPARAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFPARampState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPARampState(FLR_ENABLE_E *state) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPARAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read state from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *state = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of state handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPARampState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetSensorADC1(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETSENSORADC1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetSensorADC1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetSensorADC2(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETSENSORADC2, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetSensorADC2() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFPATempOffset(const int16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = data; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFPATempOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPATempOffset(int16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *data = (int16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPATempOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ROIC_TEMP_MODE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFPATempMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ROIC_TEMP_MODE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPATempMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 64; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPTABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read table from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ROIC_FPATEMP_TABLE_T outVal; + byteToFLR_ROIC_FPATEMP_TABLE_T( (const uint8_t *) inPtr, &outVal); + *table = (FLR_ROIC_FPATEMP_TABLE_T)outVal; + inPtr+=64; + }// end of table handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPATempTable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFPATempValue(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFPATempValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFPATempValue(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPVALUE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFPATempValue() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetPreambleError(uint32_t *preambleError) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETPREAMBLEERROR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read preambleError from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *preambleError = (uint32_t)outVal; + inPtr+=4; + }// end of preambleError handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetPreambleError() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicInducePreambleError(const uint32_t everyNthFrame) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write everyNthFrame to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = everyNthFrame; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_INDUCEPREAMBLEERROR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicInducePreambleError() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetRoicStarted(FLR_ENABLE_E *roicStarted) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETROICSTARTED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read roicStarted from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *roicStarted = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of roicStarted handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetRoicStarted() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFrameSkip(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFRAMESKIP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFrameSkip() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicGetFrameSkip(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFRAMESKIP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicGetFrameSkip() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgRoicSetFrameOneShot() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFRAMEONESHOT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgRoicSetFrameOneShot() + +// End Module: roic +// Begin Module: scaler +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScalerGetMaxZoom(uint32_t *zoom) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_GETMAXZOOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read zoom from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *zoom = (uint32_t)outVal; + inPtr+=4; + }// end of zoom handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScalerGetMaxZoom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 12; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write zoomParams to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SCALER_ZOOM_PARAMS_T *inVal = (const FLR_SCALER_ZOOM_PARAMS_T *) &zoomParams; + FLR_SCALER_ZOOM_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 12; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETZOOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScalerSetZoom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_GETZOOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read zoomParams from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SCALER_ZOOM_PARAMS_T outVal; + byteToFLR_SCALER_ZOOM_PARAMS_T( (const uint8_t *) inPtr, &outVal); + *zoomParams = (FLR_SCALER_ZOOM_PARAMS_T)outVal; + inPtr+=12; + }// end of zoomParams handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScalerGetZoom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 32; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write zoomNumerator to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomNumerator; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomDenominator to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomDenominator; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomXCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomXCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomYCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomYCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write inChangeEnable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = inChangeEnable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomOutXCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomOutXCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomOutYCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomOutYCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write outChangeEnable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = outChangeEnable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETFRACTIONALZOOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScalerSetFractionalZoom() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 28; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write zoomIndex to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomIndex; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomXCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomXCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomYCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomYCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write inChangeEnable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = inChangeEnable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomOutXCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomOutXCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write zoomOutYCenter to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = zoomOutYCenter; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write outChangeEnable to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = outChangeEnable; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETINDEXZOOM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScalerSetIndexZoom() + +// End Module: scaler +// Begin Module: scnr +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetThColSum(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHCOLSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetThColSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetThColSum(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHCOLSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetThColSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetThPixel(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetThPixel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetThPixel(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetThPixel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetMaxCorr(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetMaxCorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetMaxCorr(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetMaxCorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetThPixelApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXELAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetThPixelApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetMaxCorrApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORRAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetMaxCorrApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetThColSumSafe(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHCOLSUMSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetThColSumSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetThColSumSafe(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHCOLSUMSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetThColSumSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetThPixelSafe(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHPIXELSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetThPixelSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetThPixelSafe(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXELSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetThPixelSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetMaxCorrSafe(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETMAXCORRSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetMaxCorrSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetMaxCorrSafe(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORRSAFE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetMaxCorrSafe() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetCorrectionMethod(const FLR_SCNR_CORR_SELECT_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SCNR_CORR_SELECT_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETCORRECTIONMETHOD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetCorrectionMethod() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetCorrectionMethod(FLR_SCNR_CORR_SELECT_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETCORRECTIONMETHOD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SCNR_CORR_SELECT_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetCorrectionMethod() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetStdThreshold(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSTDTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetStdThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetStdThreshold(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSTDTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetStdThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetNFrames(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETNFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetNFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetNFrames(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETNFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetNFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetResetDesired(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetResetDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetResetDesired(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetResetDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetM_modeOnly(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETM_MODEONLY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetM_modeOnly() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetM_modeOnly(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETM_MODEONLY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetM_modeOnly() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetMode(FLR_SCNR_MODE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SCNR_MODE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetSpecklesEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetSpecklesEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetSpecklesThreshold(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetSpecklesThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesThreshold(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetSpecklesRatio(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESRATIO, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetSpecklesRatio() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesRatio(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESRATIO, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesRatio() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetSpecklesDF(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetSpecklesDF() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesDF(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESDF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesDF() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesDiffsBufferAddr(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESDIFFSBUFFERADDR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesDiffsBufferAddr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesOffsBufferAddr(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESOFFSBUFFERADDR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesOffsBufferAddr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrSetSpecklesResetDesired(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrSetSpecklesResetDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgScnrGetSpecklesResetDesired(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgScnrGetSpecklesResetDesired() + +// End Module: scnr +// Begin Module: sffc +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetScaleFactor(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETSCALEFACTOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetScaleFactor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetDeltaTempLinearCoeff(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetDeltaTempLinearCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcSetDeltaTempLinearCoeff(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcSetDeltaTempLinearCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetDeltaTempOffsetCoeff(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetDeltaTempOffsetCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcSetDeltaTempOffsetCoeff(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcSetDeltaTempOffsetCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetFpaTempLinearCoeff(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETFPATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetFpaTempLinearCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcSetFpaTempLinearCoeff(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETFPATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcSetFpaTempLinearCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetFpaTempOffsetCoeff(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETFPATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetFpaTempOffsetCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcSetFpaTempOffsetCoeff(const float data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = data; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETFPATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcSetFpaTempOffsetCoeff() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPTIMELIMITINSECS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPTIMELIMITINSECS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs() + +// End Module: sffc +// Begin Module: spnr +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetState(FLR_SPNR_STATE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SPNR_STATE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetFrameDelay(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETFRAMEDELAY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetFrameDelay() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetFrameDelay(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETFRAMEDELAY, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetFrameDelay() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetSF(const float sf) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write sf to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = sf; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetSF() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetSF(float *sf) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sf from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *sf = (float)outVal; + inPtr+=4; + }// end of sf handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetSF() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetSFApplied(float *sf) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sf from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *sf = (float)outVal; + inPtr+=4; + }// end of sf handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetSFApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 256; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SPNR_PSD_KERNEL_T *inVal = (const FLR_SPNR_PSD_KERNEL_T *) &data; + FLR_SPNR_PSD_KERNEL_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 256; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETPSDKERNEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetPSDKernel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 256; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETPSDKERNEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SPNR_PSD_KERNEL_T outVal; + byteToFLR_SPNR_PSD_KERNEL_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SPNR_PSD_KERNEL_T)outVal; + inPtr+=256; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetPSDKernel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetSFMin(const float sfmin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write sfmin to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = sfmin; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSFMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetSFMin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetSFMin(float *sfmin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sfmin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *sfmin = (float)outVal; + inPtr+=4; + }// end of sfmin handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetSFMin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetSFMax(const float sfmax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write sfmax to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = sfmax; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSFMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetSFMax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetSFMax(float *sfmax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read sfmax from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *sfmax = (float)outVal; + inPtr+=4; + }// end of sfmax handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetSFMax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetDFMin(const float dfmin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write dfmin to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = dfmin; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetDFMin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetDFMin(float *dfmin) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFMIN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read dfmin from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *dfmin = (float)outVal; + inPtr+=4; + }// end of dfmin handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetDFMin() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetDFMax(const float dfmax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write dfmax to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = dfmax; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetDFMax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetDFMax(float *dfmax) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFMAX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read dfmax from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *dfmax = (float)outVal; + inPtr+=4; + }// end of dfmax handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetDFMax() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetNormTarget(const float normTarget) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write normTarget to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = normTarget; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETNORMTARGET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetNormTarget() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetNormTarget(float *normTarget) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETNORMTARGET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read normTarget from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *normTarget = (float)outVal; + inPtr+=4; + }// end of normTarget handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetNormTarget() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetNormTargetApplied(float *normTargetApplied) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETNORMTARGETAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read normTargetApplied from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *normTargetApplied = (float)outVal; + inPtr+=4; + }// end of normTargetApplied handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetNormTargetApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetThPix(const uint16_t th_pix) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write th_pix to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = th_pix; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETTHPIX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetThPix() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetThPix(uint16_t *th_pix) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETTHPIX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read th_pix from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *th_pix = (uint16_t)outVal; + inPtr+=2; + }// end of th_pix handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetThPix() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetThPixSum(const uint16_t th_pixSum) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write th_pixSum to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = th_pixSum; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETTHPIXSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetThPixSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetThPixSum(uint16_t *th_pixSum) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETTHPIXSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read th_pixSum from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *th_pixSum = (uint16_t)outVal; + inPtr+=2; + }// end of th_pixSum handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetThPixSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetMaxcorr(const uint16_t maxcorr) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write maxcorr to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = maxcorr; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetMaxcorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetMaxcorr(uint16_t *maxcorr) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read maxcorr from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *maxcorr = (uint16_t)outVal; + inPtr+=2; + }// end of maxcorr handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetMaxcorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetAlgorithm(FLR_SPNR_ALGORITHM_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETALGORITHM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SPNR_ALGORITHM_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetAlgorithm() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetAlgorithmDesired(const FLR_SPNR_ALGORITHM_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SPNR_ALGORITHM_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETALGORITHMDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetAlgorithmDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetAlgorithmDesired(FLR_SPNR_ALGORITHM_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETALGORITHMDESIRED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SPNR_ALGORITHM_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetAlgorithmDesired() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetDFFast(const float dffast) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write dffast to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = dffast; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFFAST, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetDFFast() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetDFFast(float *dffast) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFFAST, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read dffast from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *dffast = (float)outVal; + inPtr+=4; + }// end of dffast handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetDFFast() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetDFSlow(const float dfslow) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write dfslow to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = dfslow; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFSLOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetDFSlow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetDFSlow(float *dfslow) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFSLOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read dfslow from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *dfslow = (float)outVal; + inPtr+=4; + }// end of dfslow handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetDFSlow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetSensitivityThreshold(const float threshold) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write threshold to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = threshold; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSENSITIVITYTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetSensitivityThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrGetSensitivityThreshold(float *threshold) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSENSITIVITYTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read threshold from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *threshold = (float)outVal; + inPtr+=4; + }// end of threshold handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrGetSensitivityThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpnrSetReset(const FLR_SPNR_RESET_E resetType) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write resetType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SPNR_RESET_E inVal = resetType; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETRESET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpnrSetReset() + +// End Module: spnr +// Begin Module: spotMeter +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterSetEnable(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterSetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetEnable(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetRoiMaxSize(uint16_t *width, uint16_t *height) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETROIMAXSIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read width from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *width = (uint16_t)outVal; + inPtr+=2; + }// end of width handling + + // read height from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *height = (uint16_t)outVal; + inPtr+=2; + }// end of height handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetRoiMaxSize() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterSetRoi(const FLR_ROI_T roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write roi to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ROI_T *inVal = (const FLR_ROI_T *) &roi; + FLR_ROI_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 8; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterSetRoi() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetRoi(FLR_ROI_T *roi) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 8; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETROI, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read roi from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_ROI_T outVal; + byteToFLR_ROI_T( (const uint8_t *) inPtr, &outVal); + *roi = (FLR_ROI_T)outVal; + inPtr+=8; + }// end of roi handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetRoi() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetSpotStats(uint16_t *mean, uint16_t *deviation, FLR_SPOTMETER_SPOT_PARAM_T *min, FLR_SPOTMETER_SPOT_PARAM_T *max) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 16; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETSPOTSTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mean from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *mean = (uint16_t)outVal; + inPtr+=2; + }// end of mean handling + + // read deviation from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *deviation = (uint16_t)outVal; + inPtr+=2; + }// end of deviation handling + + // read min from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SPOTMETER_SPOT_PARAM_T outVal; + byteToFLR_SPOTMETER_SPOT_PARAM_T( (const uint8_t *) inPtr, &outVal); + *min = (FLR_SPOTMETER_SPOT_PARAM_T)outVal; + inPtr+=6; + }// end of min handling + + // read max from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SPOTMETER_SPOT_PARAM_T outVal; + byteToFLR_SPOTMETER_SPOT_PARAM_T( (const uint8_t *) inPtr, &outVal); + *max = (FLR_SPOTMETER_SPOT_PARAM_T)outVal; + inPtr+=6; + }// end of max handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetSpotStats() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterSetStatsMode(const FLR_SPOTMETER_STATS_TEMP_MODE_E mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write mode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SPOTMETER_STATS_TEMP_MODE_E inVal = mode; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETSTATSMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterSetStatsMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetStatsMode(FLR_SPOTMETER_STATS_TEMP_MODE_E *mode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETSTATSMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mode from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *mode = (FLR_SPOTMETER_STATS_TEMP_MODE_E)outVal; + inPtr+=4; + }// end of mode handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetStatsMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSpotmeterGetTempStats(float *mean, float *deviation, FLR_SPOTMETER_STAT_PARAM_TEMP_T *min, FLR_SPOTMETER_STAT_PARAM_TEMP_T *max) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 24; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETTEMPSTATS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read mean from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *mean = (float)outVal; + inPtr+=4; + }// end of mean handling + + // read deviation from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *deviation = (float)outVal; + inPtr+=4; + }// end of deviation handling + + // read min from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SPOTMETER_STAT_PARAM_TEMP_T outVal; + byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T( (const uint8_t *) inPtr, &outVal); + *min = (FLR_SPOTMETER_STAT_PARAM_TEMP_T)outVal; + inPtr+=8; + }// end of min handling + + // read max from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SPOTMETER_STAT_PARAM_TEMP_T outVal; + byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T( (const uint8_t *) inPtr, &outVal); + *max = (FLR_SPOTMETER_STAT_PARAM_TEMP_T)outVal; + inPtr+=8; + }// end of max handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSpotmeterGetTempStats() + +// End Module: spotMeter +// Begin Module: srnr +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrSetEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrSetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrSetThRowSum(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETTHROWSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrSetThRowSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetThRowSum(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHROWSUM, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetThRowSum() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrSetThPixel(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrSetThPixel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetThPixel(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetThPixel() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrSetMaxCorr(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrSetMaxCorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetMaxCorr(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetMaxCorr() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetThPixelApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHPIXELAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetThPixelApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSrnrGetMaxCorrApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETMAXCORRAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSrnrGetMaxCorrApplied() + +// End Module: srnr +// Begin Module: symbology +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySetEnable(const FLR_ENABLE_E draw_symbols) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write draw_symbols to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = draw_symbols; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 9; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateBitmap() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 131; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write size to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = size; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write text to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SENDDATA, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySendData() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 21; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write start_angle to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = start_angle; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write end_angle to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const float inVal = end_angle; + FLOATToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEARC, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateArc() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 146; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write font to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int8_t inVal = font; + CHARToByte(inVal, (const uint8_t *) outPtr ); + outPtr += 1; + } + + //write size to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = size; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write alignment to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write text to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateText() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 5; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVESPRITE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyMoveSprite() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyAddToGroup(const uint8_t ID, const uint8_t group_ID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write group_ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = group_ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_ADDTOGROUP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyAddToGroup() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write group_ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = group_ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_REMOVEFROMGROUP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyRemoveFromGroup() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyUpdateAndShow(const uint8_t ID, const uint8_t visible) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write visible to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = visible; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEANDSHOW, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyUpdateAndShow() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write group_ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = group_ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write visible to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = visible; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEANDSHOWGROUP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyUpdateAndShowGroup() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyDelete(const uint8_t ID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_DELETE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyDelete() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyDeleteGroup(const uint8_t group_ID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write group_ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = group_ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_DELETEGROUP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyDeleteGroup() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEFILLEDRECTANGLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateFilledRectangle() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEOUTLINEDRECTANGLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateOutlinedRectangle() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 7; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write size to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = size; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMPNG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateBitmapFromPng() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 9; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATECOMPRESSEDBITMAP, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateCompressedBitmap() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 133; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMPNGFILE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateBitmapFromPngFile() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromFile(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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 135; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + //write imageType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_IMAGE_TYPE_E inVal = imageType; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMFILE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateBitmapFromFile() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyResetWritePosition(const uint8_t ID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_RESETWRITEPOSITION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyResetWritePosition() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 5; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write off_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = off_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write off_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = off_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVEBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyMoveByOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 5; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write off_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = off_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write off_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = off_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVEGROUPBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyMoveGroupByOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEFILLEDELLIPSE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateFilledEllipse() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_X2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X2; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y2; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATELINE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateLine() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySetZorder(const uint8_t ID, const uint8_t zorder) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write zorder to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = zorder; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETZORDER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySetZorder() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySaveConfiguration() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SAVECONFIGURATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySaveConfiguration() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyReloadConfiguration() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_RELOADCONFIGURATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyReloadConfiguration() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetEnable(FLR_ENABLE_E *draw_symbols) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read draw_symbols from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *draw_symbols = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of draw_symbols handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write numberOfClones to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = numberOfClones; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETCLONESNUMBER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySetClonesNumber() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 6; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write cloneID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = cloneID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVECLONEBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyMoveCloneByOffset() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 6; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write cloneID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = cloneID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVECLONESPRITE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyMoveCloneSprite() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySetTransformation(const FLR_SYMBOLOGY_TRANSFORMATION_E transformation) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write transformation to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_TRANSFORMATION_E inVal = transformation; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETTRANSFORMATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySetTransformation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyUpdateAllVisible() { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEALLVISIBLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyUpdateAllVisible() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologySetSizeAndScalingMode(const uint8_t ID, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 7; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write scalingMode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_SCALING_MODE_E inVal = scalingMode; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETSIZEANDSCALINGMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologySetSizeAndScalingMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 21; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_X2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X2; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y2; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color1; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write color2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color2; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write dashLen to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = dashLen; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write thickness to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = thickness; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATELINEHVT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateLineHVT() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 151; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write font to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int8_t inVal = font; + CHARToByte(inVal, (const uint8_t *) outPtr ); + outPtr += 1; + } + + //write size to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = size; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write alignment to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color1 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color1; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write color2 to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color2; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write dashLen to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = dashLen; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write text to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXTHVT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateTextHVT() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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[]) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 150; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write font to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int8_t inVal = font; + CHARToByte(inVal, (const uint8_t *) outPtr ); + outPtr += 1; + } + + //write size to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = size; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write alignment to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write color to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = color; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write bgColor to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = bgColor; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write text to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXTBG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateTextBg() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +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[], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 141; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write pos_X to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_X; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write pos_Y to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = pos_Y; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write width to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = width; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write height to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const int16_t inVal = height; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write scalingMode to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_SCALING_MODE_E inVal = scalingMode; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + //write path to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; + UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); + outPtr += 128; + } + + //write imageType to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYMBOLOGY_IMAGE_TYPE_E inVal = imageType; + INT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATESCALEDBITMAPFROMFILE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCreateScaledBitmapFromFile() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetLocation(const uint8_t ID, int16_t *pos_X, int16_t *pos_Y) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read pos_X from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *pos_X = (int16_t)outVal; + inPtr+=2; + }// end of pos_X handling + + // read pos_Y from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *pos_Y = (int16_t)outVal; + inPtr+=2; + }// end of pos_Y handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetLocation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetSize(const uint8_t ID, int16_t *width, int16_t *height) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETSIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read width from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *width = (int16_t)outVal; + inPtr+=2; + }// end of width handling + + // read height from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *height = (int16_t)outVal; + inPtr+=2; + }// end of height handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetSize() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetZorder(const uint8_t ID, uint8_t *zorder) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETZORDER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read zorder from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *zorder = (uint8_t)outVal; + inPtr+=1; + }// end of zorder handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetZorder() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetColor(const uint8_t ID, uint32_t *color) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETCOLOR, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read color from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *color = (uint32_t)outVal; + inPtr+=4; + }// end of color handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetColor() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetType(const uint8_t ID, FLR_SYMBOLOGY_TYPE_E *type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read type from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *type = (FLR_SYMBOLOGY_TYPE_E)outVal; + inPtr+=2; + }// end of type handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyCopySymbol(const uint8_t source, const uint8_t destination) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write source to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = source; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write destination to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = destination; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_COPYSYMBOL, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyCopySymbol() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSymbologyGetTextFontSize(const uint8_t ID, int16_t *size) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write ID to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = ID; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETTEXTFONTSIZE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read size from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int16_t outVal; + byteToINT_16( (const uint8_t *) inPtr, &outVal); + *size = (int16_t)outVal; + inPtr+=2; + }// end of size handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSymbologyGetTextFontSize() + +// End Module: symbology +// Begin Module: sysctrl +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlSetFreezeState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETFREEZESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlSetFreezeState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetFreezeState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETFREEZESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetFreezeState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetCameraFrameRate(uint32_t *frameRate) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETCAMERAFRAMERATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read frameRate from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *frameRate = (uint32_t)outVal; + inPtr+=4; + }// end of frameRate handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetCameraFrameRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetUptimeSecs(uint32_t *uptime) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETUPTIMESECS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read uptime from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *uptime = (uint32_t)outVal; + inPtr+=4; + }// end of uptime handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetUptimeSecs() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlSetUsbVideoIR16Mode(const FLR_SYSCTRL_USBIR16_MODE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSCTRL_USBIR16_MODE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETUSBVIDEOIR16MODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlSetUsbVideoIR16Mode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetUsbVideoIR16Mode(FLR_SYSCTRL_USBIR16_MODE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETUSBVIDEOIR16MODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SYSCTRL_USBIR16_MODE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetUsbVideoIR16Mode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlSetOperatingMode(const FLR_SYSCTRL_OPERATING_MODE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSCTRL_OPERATING_MODE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETOPERATINGMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlSetOperatingMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetOperatingMode(FLR_SYSCTRL_OPERATING_MODE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETOPERATINGMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_SYSCTRL_OPERATING_MODE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetOperatingMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetAvgFpaTempCounts(float *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETAVGFPATEMPCOUNTS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + float outVal; + byteToFLOAT( (const uint8_t *) inPtr, &outVal); + *data = (float)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetAvgFpaTempCounts() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlSetFpaTempFrames(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETFPATEMPFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlSetFpaTempFrames() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysctrlGetFpaTempFrames(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETFPATEMPFRAMES, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysctrlGetFpaTempFrames() + +// End Module: sysctrl +// Begin Module: sysinfo +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetMonitorSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORSOFTWAREREV, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetMonitorSoftwareRev() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetMonitorBuildVariant(FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *monitorBuildVariant) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 50; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORBUILDVARIANT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read monitorBuildVariant from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSINFO_MONITOR_BUILD_VARIANT_T outVal; + byteToFLR_SYSINFO_MONITOR_BUILD_VARIANT_T( (const uint8_t *) inPtr, &outVal); + *monitorBuildVariant = (FLR_SYSINFO_MONITOR_BUILD_VARIANT_T)outVal; + inPtr+=50; + }// end of monitorBuildVariant handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetMonitorBuildVariant() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetProductName(uint8_t *name) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPRODUCTNAME, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read name from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + name[0] = outVal[0]; + name[1] = outVal[1]; + name[2] = outVal[2]; + name[3] = outVal[3]; + name[4] = outVal[4]; + name[5] = outVal[5]; + name[6] = outVal[6]; + name[7] = outVal[7]; + name[8] = outVal[8]; + name[9] = outVal[9]; + name[10] = outVal[10]; + name[11] = outVal[11]; + name[12] = outVal[12]; + name[13] = outVal[13]; + name[14] = outVal[14]; + name[15] = outVal[15]; + name[16] = outVal[16]; + name[17] = outVal[17]; + name[18] = outVal[18]; + name[19] = outVal[19]; + name[20] = outVal[20]; + name[21] = outVal[21]; + name[22] = outVal[22]; + name[23] = outVal[23]; + name[24] = outVal[24]; + name[25] = outVal[25]; + name[26] = outVal[26]; + name[27] = outVal[27]; + name[28] = outVal[28]; + name[29] = outVal[29]; + name[30] = outVal[30]; + name[31] = outVal[31]; + name[32] = outVal[32]; + name[33] = outVal[33]; + name[34] = outVal[34]; + name[35] = outVal[35]; + name[36] = outVal[36]; + name[37] = outVal[37]; + name[38] = outVal[38]; + name[39] = outVal[39]; + name[40] = outVal[40]; + name[41] = outVal[41]; + name[42] = outVal[42]; + name[43] = outVal[43]; + name[44] = outVal[44]; + name[45] = outVal[45]; + name[46] = outVal[46]; + name[47] = outVal[47]; + name[48] = outVal[48]; + name[49] = outVal[49]; + name[50] = outVal[50]; + name[51] = outVal[51]; + name[52] = outVal[52]; + name[53] = outVal[53]; + name[54] = outVal[54]; + name[55] = outVal[55]; + name[56] = outVal[56]; + name[57] = outVal[57]; + name[58] = outVal[58]; + name[59] = outVal[59]; + name[60] = outVal[60]; + name[61] = outVal[61]; + name[62] = outVal[62]; + name[63] = outVal[63]; + name[64] = outVal[64]; + name[65] = outVal[65]; + name[66] = outVal[66]; + name[67] = outVal[67]; + name[68] = outVal[68]; + name[69] = outVal[69]; + name[70] = outVal[70]; + name[71] = outVal[71]; + name[72] = outVal[72]; + name[73] = outVal[73]; + name[74] = outVal[74]; + name[75] = outVal[75]; + name[76] = outVal[76]; + name[77] = outVal[77]; + name[78] = outVal[78]; + name[79] = outVal[79]; + name[80] = outVal[80]; + name[81] = outVal[81]; + name[82] = outVal[82]; + name[83] = outVal[83]; + name[84] = outVal[84]; + name[85] = outVal[85]; + name[86] = outVal[86]; + name[87] = outVal[87]; + name[88] = outVal[88]; + name[89] = outVal[89]; + name[90] = outVal[90]; + name[91] = outVal[91]; + name[92] = outVal[92]; + name[93] = outVal[93]; + name[94] = outVal[94]; + name[95] = outVal[95]; + name[96] = outVal[96]; + name[97] = outVal[97]; + name[98] = outVal[98]; + name[99] = outVal[99]; + name[100] = outVal[100]; + name[101] = outVal[101]; + name[102] = outVal[102]; + name[103] = outVal[103]; + name[104] = outVal[104]; + name[105] = outVal[105]; + name[106] = outVal[106]; + name[107] = outVal[107]; + name[108] = outVal[108]; + name[109] = outVal[109]; + name[110] = outVal[110]; + name[111] = outVal[111]; + name[112] = outVal[112]; + name[113] = outVal[113]; + name[114] = outVal[114]; + name[115] = outVal[115]; + name[116] = outVal[116]; + name[117] = outVal[117]; + name[118] = outVal[118]; + name[119] = outVal[119]; + name[120] = outVal[120]; + name[121] = outVal[121]; + name[122] = outVal[122]; + name[123] = outVal[123]; + name[124] = outVal[124]; + name[125] = outVal[125]; + name[126] = outVal[126]; + name[127] = outVal[127]; + inPtr+=128; + }// end of name handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetProductName() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetCameraSN(uint8_t *number) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETCAMERASN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read number from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + number[0] = outVal[0]; + number[1] = outVal[1]; + number[2] = outVal[2]; + number[3] = outVal[3]; + number[4] = outVal[4]; + number[5] = outVal[5]; + number[6] = outVal[6]; + number[7] = outVal[7]; + number[8] = outVal[8]; + number[9] = outVal[9]; + number[10] = outVal[10]; + number[11] = outVal[11]; + number[12] = outVal[12]; + number[13] = outVal[13]; + number[14] = outVal[14]; + number[15] = outVal[15]; + number[16] = outVal[16]; + number[17] = outVal[17]; + number[18] = outVal[18]; + number[19] = outVal[19]; + number[20] = outVal[20]; + number[21] = outVal[21]; + number[22] = outVal[22]; + number[23] = outVal[23]; + number[24] = outVal[24]; + number[25] = outVal[25]; + number[26] = outVal[26]; + number[27] = outVal[27]; + number[28] = outVal[28]; + number[29] = outVal[29]; + number[30] = outVal[30]; + number[31] = outVal[31]; + number[32] = outVal[32]; + number[33] = outVal[33]; + number[34] = outVal[34]; + number[35] = outVal[35]; + number[36] = outVal[36]; + number[37] = outVal[37]; + number[38] = outVal[38]; + number[39] = outVal[39]; + number[40] = outVal[40]; + number[41] = outVal[41]; + number[42] = outVal[42]; + number[43] = outVal[43]; + number[44] = outVal[44]; + number[45] = outVal[45]; + number[46] = outVal[46]; + number[47] = outVal[47]; + number[48] = outVal[48]; + number[49] = outVal[49]; + number[50] = outVal[50]; + number[51] = outVal[51]; + number[52] = outVal[52]; + number[53] = outVal[53]; + number[54] = outVal[54]; + number[55] = outVal[55]; + number[56] = outVal[56]; + number[57] = outVal[57]; + number[58] = outVal[58]; + number[59] = outVal[59]; + number[60] = outVal[60]; + number[61] = outVal[61]; + number[62] = outVal[62]; + number[63] = outVal[63]; + number[64] = outVal[64]; + number[65] = outVal[65]; + number[66] = outVal[66]; + number[67] = outVal[67]; + number[68] = outVal[68]; + number[69] = outVal[69]; + number[70] = outVal[70]; + number[71] = outVal[71]; + number[72] = outVal[72]; + number[73] = outVal[73]; + number[74] = outVal[74]; + number[75] = outVal[75]; + number[76] = outVal[76]; + number[77] = outVal[77]; + number[78] = outVal[78]; + number[79] = outVal[79]; + number[80] = outVal[80]; + number[81] = outVal[81]; + number[82] = outVal[82]; + number[83] = outVal[83]; + number[84] = outVal[84]; + number[85] = outVal[85]; + number[86] = outVal[86]; + number[87] = outVal[87]; + number[88] = outVal[88]; + number[89] = outVal[89]; + number[90] = outVal[90]; + number[91] = outVal[91]; + number[92] = outVal[92]; + number[93] = outVal[93]; + number[94] = outVal[94]; + number[95] = outVal[95]; + number[96] = outVal[96]; + number[97] = outVal[97]; + number[98] = outVal[98]; + number[99] = outVal[99]; + number[100] = outVal[100]; + number[101] = outVal[101]; + number[102] = outVal[102]; + number[103] = outVal[103]; + number[104] = outVal[104]; + number[105] = outVal[105]; + number[106] = outVal[106]; + number[107] = outVal[107]; + number[108] = outVal[108]; + number[109] = outVal[109]; + number[110] = outVal[110]; + number[111] = outVal[111]; + number[112] = outVal[112]; + number[113] = outVal[113]; + number[114] = outVal[114]; + number[115] = outVal[115]; + number[116] = outVal[116]; + number[117] = outVal[117]; + number[118] = outVal[118]; + number[119] = outVal[119]; + number[120] = outVal[120]; + number[121] = outVal[121]; + number[122] = outVal[122]; + number[123] = outVal[123]; + number[124] = outVal[124]; + number[125] = outVal[125]; + number[126] = outVal[126]; + number[127] = outVal[127]; + inPtr+=128; + }// end of number handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetCameraSN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetBootLocation(uint32_t *bootSwLocation) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETBOOTLOCATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read bootSwLocation from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *bootSwLocation = (uint32_t)outVal; + inPtr+=4; + }// end of bootSwLocation handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetBootLocation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetSwConfigID(FLR_SYSINFO_SW_CONFIG_ID_E *swConfigID) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSWCONFIGID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read swConfigID from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *swConfigID = (FLR_SYSINFO_SW_CONFIG_ID_E)outVal; + inPtr+=4; + }// end of swConfigID handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetSwConfigID() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetSwPermissions(FLR_SYSINFO_SW_PERMISSIONS_E *swPermissions) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSWPERMISSIONS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read swPermissions from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *swPermissions = (FLR_SYSINFO_SW_PERMISSIONS_E)outVal; + inPtr+=4; + }// end of swPermissions handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetSwPermissions() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetIs9HzBuild(uint32_t *is9HzBuild) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETIS9HZBUILD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read is9HzBuild from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *is9HzBuild = (uint32_t)outVal; + inPtr+=4; + }// end of is9HzBuild handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetIs9HzBuild() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetProductVersion(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPRODUCTVERSION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetProductVersion() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetMonitorProductRev(uint32_t *major, uint32_t *minor, uint32_t *patch) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 12; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORPRODUCTREV, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read major from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *major = (uint32_t)outVal; + inPtr+=4; + }// end of major handling + + // read minor from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *minor = (uint32_t)outVal; + inPtr+=4; + }// end of minor handling + + // read patch from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *patch = (uint32_t)outVal; + inPtr+=4; + }// end of patch handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetMonitorProductRev() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetOpticalRevision(uint16_t *revision) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETOPTICALREVISION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read revision from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *revision = (uint16_t)outVal; + inPtr+=2; + }// end of revision handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetOpticalRevision() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetSensorRevision(uint16_t *revision) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSENSORREVISION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read revision from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *revision = (uint16_t)outVal; + inPtr+=2; + }// end of revision handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetSensorRevision() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetProbeTipSN(uint8_t *number) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 128; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPROBETIPSN, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read number from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal[128]; + byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); + number[0] = outVal[0]; + number[1] = outVal[1]; + number[2] = outVal[2]; + number[3] = outVal[3]; + number[4] = outVal[4]; + number[5] = outVal[5]; + number[6] = outVal[6]; + number[7] = outVal[7]; + number[8] = outVal[8]; + number[9] = outVal[9]; + number[10] = outVal[10]; + number[11] = outVal[11]; + number[12] = outVal[12]; + number[13] = outVal[13]; + number[14] = outVal[14]; + number[15] = outVal[15]; + number[16] = outVal[16]; + number[17] = outVal[17]; + number[18] = outVal[18]; + number[19] = outVal[19]; + number[20] = outVal[20]; + number[21] = outVal[21]; + number[22] = outVal[22]; + number[23] = outVal[23]; + number[24] = outVal[24]; + number[25] = outVal[25]; + number[26] = outVal[26]; + number[27] = outVal[27]; + number[28] = outVal[28]; + number[29] = outVal[29]; + number[30] = outVal[30]; + number[31] = outVal[31]; + number[32] = outVal[32]; + number[33] = outVal[33]; + number[34] = outVal[34]; + number[35] = outVal[35]; + number[36] = outVal[36]; + number[37] = outVal[37]; + number[38] = outVal[38]; + number[39] = outVal[39]; + number[40] = outVal[40]; + number[41] = outVal[41]; + number[42] = outVal[42]; + number[43] = outVal[43]; + number[44] = outVal[44]; + number[45] = outVal[45]; + number[46] = outVal[46]; + number[47] = outVal[47]; + number[48] = outVal[48]; + number[49] = outVal[49]; + number[50] = outVal[50]; + number[51] = outVal[51]; + number[52] = outVal[52]; + number[53] = outVal[53]; + number[54] = outVal[54]; + number[55] = outVal[55]; + number[56] = outVal[56]; + number[57] = outVal[57]; + number[58] = outVal[58]; + number[59] = outVal[59]; + number[60] = outVal[60]; + number[61] = outVal[61]; + number[62] = outVal[62]; + number[63] = outVal[63]; + number[64] = outVal[64]; + number[65] = outVal[65]; + number[66] = outVal[66]; + number[67] = outVal[67]; + number[68] = outVal[68]; + number[69] = outVal[69]; + number[70] = outVal[70]; + number[71] = outVal[71]; + number[72] = outVal[72]; + number[73] = outVal[73]; + number[74] = outVal[74]; + number[75] = outVal[75]; + number[76] = outVal[76]; + number[77] = outVal[77]; + number[78] = outVal[78]; + number[79] = outVal[79]; + number[80] = outVal[80]; + number[81] = outVal[81]; + number[82] = outVal[82]; + number[83] = outVal[83]; + number[84] = outVal[84]; + number[85] = outVal[85]; + number[86] = outVal[86]; + number[87] = outVal[87]; + number[88] = outVal[88]; + number[89] = outVal[89]; + number[90] = outVal[90]; + number[91] = outVal[91]; + number[92] = outVal[92]; + number[93] = outVal[93]; + number[94] = outVal[94]; + number[95] = outVal[95]; + number[96] = outVal[96]; + number[97] = outVal[97]; + number[98] = outVal[98]; + number[99] = outVal[99]; + number[100] = outVal[100]; + number[101] = outVal[101]; + number[102] = outVal[102]; + number[103] = outVal[103]; + number[104] = outVal[104]; + number[105] = outVal[105]; + number[106] = outVal[106]; + number[107] = outVal[107]; + number[108] = outVal[108]; + number[109] = outVal[109]; + number[110] = outVal[110]; + number[111] = outVal[111]; + number[112] = outVal[112]; + number[113] = outVal[113]; + number[114] = outVal[114]; + number[115] = outVal[115]; + number[116] = outVal[116]; + number[117] = outVal[117]; + number[118] = outVal[118]; + number[119] = outVal[119]; + number[120] = outVal[120]; + number[121] = outVal[121]; + number[122] = outVal[122]; + number[123] = outVal[123]; + number[124] = outVal[124]; + number[125] = outVal[125]; + number[126] = outVal[126]; + number[127] = outVal[127]; + inPtr+=128; + }// end of number handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetProbeTipSN() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetMechanicalRevision(uint16_t *revision) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMECHANICALREVISION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read revision from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *revision = (uint16_t)outVal; + inPtr+=2; + }// end of revision handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetMechanicalRevision() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSysinfoGetProbeTipType(FLR_SYSINFO_PROBE_TIP_TYPE *type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 5; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPROBETIPTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read type from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSINFO_PROBE_TIP_TYPE outVal; + byteToFLR_SYSINFO_PROBE_TIP_TYPE( (const uint8_t *) inPtr, &outVal); + *type = (FLR_SYSINFO_PROBE_TIP_TYPE)outVal; + inPtr+=5; + }// end of type handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSysinfoGetProbeTipType() + +// End Module: sysinfo +// Begin Module: systemSymbols +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 5; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write symbol to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read id from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *id = (uint8_t)outVal; + inPtr+=1; + }// end of id handling + + // read id_type from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *id_type = (FLR_SYSTEMSYMBOLS_ID_TYPE_E)outVal; + inPtr+=4; + }// end of id_type handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetID() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 9; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write symbol to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write id to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = id; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write id_type to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_ID_TYPE_E inVal = id_type; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETID, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetID() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write symbol to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read enabled from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *enabled = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of enabled handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 8; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write symbol to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + //write enabled to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = enabled; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetEnable() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfig(FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 195; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETSPOTCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOTCONFIG_T outVal; + byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_T( (const uint8_t *) inPtr, &outVal); + *config = (FLR_SYSTEMSYMBOLS_SPOTCONFIG_T)outVal; + inPtr+=195; + }// end of config handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetSpotConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfig(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 195; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write config to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *) &config; + FLR_SYSTEMSYMBOLS_SPOTCONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 195; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETSPOTCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetSpotConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfig(FLR_SYSTEMSYMBOLS_ISOCONFIG_T *config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 30; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETISOCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_ISOCONFIG_T outVal; + byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_T( (const uint8_t *) inPtr, &outVal); + *config = (FLR_SYSTEMSYMBOLS_ISOCONFIG_T)outVal; + inPtr+=30; + }// end of config handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetIsoConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfig(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 30; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write config to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *) &config; + FLR_SYSTEMSYMBOLS_ISOCONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 30; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETISOCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetIsoConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetBarConfig(FLR_SYSTEMSYMBOLS_BARCONFIG_T *lowGainConfig, FLR_SYSTEMSYMBOLS_BARCONFIG_T *highGainConfig, FLR_TEMPERATURE_UNIT_E *unit) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 24; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETBARCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read lowGainConfig from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_BARCONFIG_T outVal; + byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T( (const uint8_t *) inPtr, &outVal); + *lowGainConfig = (FLR_SYSTEMSYMBOLS_BARCONFIG_T)outVal; + inPtr+=10; + }// end of lowGainConfig handling + + // read highGainConfig from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_BARCONFIG_T outVal; + byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T( (const uint8_t *) inPtr, &outVal); + *highGainConfig = (FLR_SYSTEMSYMBOLS_BARCONFIG_T)outVal; + inPtr+=10; + }// end of highGainConfig handling + + // read unit from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *unit = (FLR_TEMPERATURE_UNIT_E)outVal; + inPtr+=4; + }// end of unit handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetBarConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetBarConfig(const FLR_SYSTEMSYMBOLS_BARCONFIG_T lowGainConfig, const FLR_SYSTEMSYMBOLS_BARCONFIG_T highGainConfig, const FLR_TEMPERATURE_UNIT_E unit) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 24; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write lowGainConfig to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_BARCONFIG_T *) &lowGainConfig; + FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 10; + } + + //write highGainConfig to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_BARCONFIG_T *) &highGainConfig; + FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 10; + } + + //write unit to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TEMPERATURE_UNIT_E inVal = unit; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETBARCONFIG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetBarConfig() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfigIds(FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 13; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETSPOTCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T outVal; + byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T( (const uint8_t *) inPtr, &outVal); + *config = (FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T)outVal; + inPtr+=13; + }// end of config handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetSpotConfigIds() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfigIds(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 13; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write config to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *inVal = (const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *) &config; + FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 13; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETSPOTCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetSpotConfigIds() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfigIds(FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETISOCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read config from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T outVal; + byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T( (const uint8_t *) inPtr, &outVal); + *config = (FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T)outVal; + inPtr+=2; + }// end of config handling + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsGetIsoConfigIds() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfigIds(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T config) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write config to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *inVal = (const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *) &config; + FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETISOCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgSystemsymbolsSetIsoConfigIds() + +// End Module: systemSymbols +// Begin Module: telemetry +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetLocation(const FLR_TELEMETRY_LOC_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TELEMETRY_LOC_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetLocation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetLocation(FLR_TELEMETRY_LOC_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TELEMETRY_LOC_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetLocation() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetPacking(const FLR_TELEMETRY_PACKING_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TELEMETRY_PACKING_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETPACKING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetPacking() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetPacking(FLR_TELEMETRY_PACKING_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETPACKING, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TELEMETRY_PACKING_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetPacking() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetOrder(const FLR_TELEMETRY_ORDER_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TELEMETRY_ORDER_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETORDER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetOrder() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetOrder(FLR_TELEMETRY_ORDER_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETORDER, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TELEMETRY_ORDER_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetOrder() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetPackingVC1(const FLR_TELEMETRY_PACKING_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TELEMETRY_PACKING_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETPACKINGVC1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetPackingVC1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetPackingVC1(FLR_TELEMETRY_PACKING_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETPACKINGVC1, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TELEMETRY_PACKING_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetPackingVC1() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetrySetMipiEmbeddedDataTag(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETMIPIEMBEDDEDDATATAG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetrySetMipiEmbeddedDataTag() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTelemetryGetMipiEmbeddedDataTag(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETMIPIEMBEDDEDDATATAG, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTelemetryGetMipiEmbeddedDataTag() + +// End Module: telemetry +// Begin Module: testRamp +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 5; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TESTRAMP_TYPE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TESTRAMP_TYPE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetType() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 7; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TESTRAMP_SETTINGS_T *inVal = (const FLR_TESTRAMP_SETTINGS_T *) &data; + FLR_TESTRAMP_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 6; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 6; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write index to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = index; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_TESTRAMP_SETTINGS_T outVal; + byteToFLR_TESTRAMP_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TESTRAMP_SETTINGS_T)outVal; + inPtr+=6; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetMotionState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETMOTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetMotionState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetMotionState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETMOTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetMotionState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetIndex(const uint8_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 1; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint8_t inVal = data; + UCHARToByte(inVal, (const uint8_t *) outPtr); + outPtr += 1; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETINDEX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetIndex() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetIndex(uint8_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETINDEX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *data = (uint8_t)outVal; + inPtr+=1; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetIndex() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetMaxIndex(uint8_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETMAXINDEX, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint8_t outVal; + byteToUCHAR( (const uint8_t *) inPtr, &outVal); + *data = (uint8_t)outVal; + inPtr+=1; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetMaxIndex() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetPN9ContinuousMode(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETPN9CONTINUOUSMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetPN9ContinuousMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetPN9ContinuousMode(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETPN9CONTINUOUSMODE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetPN9ContinuousMode() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampSetAnimationSettings(const FLR_TESTRAMP_ANIMATION_SETTINGS_T settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write settings to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TESTRAMP_ANIMATION_SETTINGS_T *inVal = (const FLR_TESTRAMP_ANIMATION_SETTINGS_T *) &settings; + FLR_TESTRAMP_ANIMATION_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETANIMATIONSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampSetAnimationSettings() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTestrampGetAnimationSettings(FLR_TESTRAMP_ANIMATION_SETTINGS_T *settings) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETANIMATIONSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read settings from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_TESTRAMP_ANIMATION_SETTINGS_T outVal; + byteToFLR_TESTRAMP_ANIMATION_SETTINGS_T( (const uint8_t *) inPtr, &outVal); + *settings = (FLR_TESTRAMP_ANIMATION_SETTINGS_T)outVal; + inPtr+=4; + }// end of settings handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTestrampGetAnimationSettings() + +// End Module: testRamp +// Begin Module: tf +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetEnableState(const FLR_ENABLE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_ENABLE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetEnableState(FLR_ENABLE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_ENABLE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetEnableState() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetDelta_nf(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETDELTA_NF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetDelta_nf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetDelta_nf(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETDELTA_NF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetDelta_nf() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetTHDeltaMotion(const uint16_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 2; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint16_t inVal = data; + UINT_16ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 2; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETTHDELTAMOTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetTHDeltaMotion() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetTHDeltaMotion(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTHDELTAMOTION, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetTHDeltaMotion() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetWLut(const FLR_TF_WLUT_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 32; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TF_WLUT_T *inVal = (const FLR_TF_WLUT_T *) &data; + FLR_TF_WLUT_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 32; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETWLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetWLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetWLut(FLR_TF_WLUT_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 32; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETWLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_TF_WLUT_T outVal; + byteToFLR_TF_WLUT_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TF_WLUT_T)outVal; + inPtr+=32; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetWLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetMotionCount(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETMOTIONCOUNT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetMotionCount() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetMotionThreshold(const uint32_t data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const uint32_t inVal = data; + UINT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETMOTIONTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetMotionThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetMotionThreshold(uint32_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETMOTIONTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint32_t outVal; + byteToUINT_32( (const uint8_t *) inPtr, &outVal); + *data = (uint32_t)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetMotionThreshold() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetDelta_nfApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETDELTA_NFAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetDelta_nfApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetTHDeltaMotionApplied(uint16_t *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTHDELTAMOTIONAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *data = (uint16_t)outVal; + inPtr+=2; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetTHDeltaMotionApplied() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfSetTempSignalCompFactorLut(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 34; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *inVal = (const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *) &data; + FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); + outPtr += 34; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETTEMPSIGNALCOMPFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgTfSetTempSignalCompFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetTempSignalCompFactorLut(FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 34; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTEMPSIGNALCOMPFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T outVal; + byteToFLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); + *data = (FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T)outVal; + inPtr+=34; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetTempSignalCompFactorLut() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgTfGetRnf(uint16_t *rnf) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 2; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETRNF, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read rnf from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + uint16_t outVal; + byteToUINT_16( (const uint8_t *) inPtr, &outVal); + *rnf = (uint16_t)outVal; + inPtr+=2; + }// end of rnf handling + + return R_SUCCESS; + +}// End of CLIENT_pkgTfGetRnf() + +// End Module: tf +// Begin Module: uart +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgUartSetStartupBaudRate(const FLR_UART_STARTUP_BAUDRATE_E data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 4; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 1; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + //write data to sendData buffer + { //Block to allow reuse of inVal + if(outPtr >= (sendData+sendBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + const FLR_UART_STARTUP_BAUDRATE_E inVal = data; + INT_32ToByte(inVal, (const uint8_t *) outPtr); + outPtr += 4; + } + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, UART_SETSTARTUPBAUDRATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + return R_SUCCESS; + +}// End of CLIENT_pkgUartSetStartupBaudRate() + +// Synchronous (potentially MultiService incompatible) transmit+receive variant +FLR_RESULT CLIENT_pkgUartGetStartupBaudRate(FLR_UART_STARTUP_BAUDRATE_E *data) { + // Allocate buffers with space for marshalled data + uint32_t sendBytes = 0; + const uint8_t sendData[sendBytes]; + uint32_t receiveBytes = 4; + uint8_t receiveData[receiveBytes]; + uint8_t *outPtr = (uint8_t *)sendData; + + FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, UART_GETSTARTUPBAUDRATE, sendData, sendBytes, receiveData, &receiveBytes); + + // Check for any errorcode + if((uint32_t) returncode){ + return returncode; + } + + uint8_t *inPtr = (uint8_t *)receiveData; + + // read data from receiveData buffer + { //Block to allow reuse of outVal + if(inPtr >= (receiveData+receiveBytes)){ + return R_SDK_PKG_BUFFER_OVERFLOW; + } + int32_t outVal; + byteToINT_32( (const uint8_t *) inPtr, &outVal); + *data = (FLR_UART_STARTUP_BAUDRATE_E)outVal; + inPtr+=4; + }// end of data handling + + return R_SUCCESS; + +}// End of CLIENT_pkgUartGetStartupBaudRate() + +// End Module: uart diff --git a/src/drivers/boson/src/FSLP.c b/src/drivers/boson/src/FSLP.c new file mode 100644 index 000000000..47e09fdae --- /dev/null +++ b/src/drivers/boson/src/FSLP.c @@ -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 + +#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; ibuff[chan_ptr->start + 1/* START_FRAME_BYTE */ + FRAME_START_IDX]; + } + + return 0; +} diff --git a/src/drivers/boson/src/I2C_Connector.c b/src/drivers/boson/src/I2C_Connector.c new file mode 100644 index 000000000..b6537dc38 --- /dev/null +++ b/src/drivers/boson/src/I2C_Connector.c @@ -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 +#include +#include + +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; +} diff --git a/src/drivers/boson/src/MultiServiceSupport.c b/src/drivers/boson/src/MultiServiceSupport.c new file mode 100644 index 000000000..c088f09ab --- /dev/null +++ b/src/drivers/boson/src/MultiServiceSupport.c @@ -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; +} diff --git a/src/drivers/boson/src/Serializer_BuiltIn.c b/src/drivers/boson/src/Serializer_BuiltIn.c new file mode 100644 index 000000000..7b453b2c4 --- /dev/null +++ b/src/drivers/boson/src/Serializer_BuiltIn.c @@ -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 + +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>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>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>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>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>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>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 +#include "Serializer_Struct.h" + +void byteToFLR_ROI_T(const uint8_t *inBuff, FLR_ROI_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->rowStart)); + ptr += 2; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->rowStop)); + ptr += 2; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->colStart)); + ptr += 2; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->colStop)); + ptr += 2; + +} //end byteToFLR_ROI_T() +void FLR_ROI_TToByte(const FLR_ROI_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->rowStart),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->rowStop),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->colStart),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->colStop),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_ROI_TToByte() +void byteToFLR_BOSON_PARTNUMBER_T(const uint8_t *inBuff, FLR_BOSON_PARTNUMBER_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *)ptr,(outVal->value),(uint16_t) 20); + ptr += 20; + +} //end byteToFLR_BOSON_PARTNUMBER_T() +void FLR_BOSON_PARTNUMBER_TToByte(const FLR_BOSON_PARTNUMBER_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte((const uint8_t *)(inVal->value), (uint16_t) 20,(const uint8_t *)ptr); + ptr += 20; + +} //end FLR_BOSON_PARTNUMBER_TToByte() +void byteToFLR_BOSON_SENSOR_PARTNUMBER_T(const uint8_t *inBuff, FLR_BOSON_SENSOR_PARTNUMBER_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=32) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *)ptr,(outVal->value),(uint16_t) 32); + ptr += 32; + +} //end byteToFLR_BOSON_SENSOR_PARTNUMBER_T() +void FLR_BOSON_SENSOR_PARTNUMBER_TToByte(const FLR_BOSON_SENSOR_PARTNUMBER_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=32) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte((const uint8_t *)(inVal->value), (uint16_t) 32,(const uint8_t *)ptr); + ptr += 32; + +} //end FLR_BOSON_SENSOR_PARTNUMBER_TToByte() +void byteToFLR_BOSON_GAIN_SWITCH_PARAMS_T(const uint8_t *inBuff, FLR_BOSON_GAIN_SWITCH_PARAMS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->pHighToLowPercent)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->cHighToLowPercent)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->pLowToHighPercent)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->hysteresisPercent)); + ptr += 4; + +} //end byteToFLR_BOSON_GAIN_SWITCH_PARAMS_T() +void FLR_BOSON_GAIN_SWITCH_PARAMS_TToByte(const FLR_BOSON_GAIN_SWITCH_PARAMS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->pHighToLowPercent),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->cHighToLowPercent),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->pLowToHighPercent),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->hysteresisPercent),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_BOSON_GAIN_SWITCH_PARAMS_TToByte() +void byteToFLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T(const uint8_t *inBuff, FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->pHighToLowPercent)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->TempHighToLowDegK)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->pLowToHighPercent)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->TempLowToHighDegK)); + ptr += 4; + +} //end byteToFLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T() +void FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_TToByte(const FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->pHighToLowPercent),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->TempHighToLowDegK),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->pLowToHighPercent),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->TempLowToHighDegK),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_BOSON_GAIN_SWITCH_RADIOMETRIC_PARAMS_TToByte() +void byteToFLR_BOSON_SATURATION_LUT_T(const uint8_t *inBuff, FLR_BOSON_SATURATION_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 17); + ptr += 34; + +} //end byteToFLR_BOSON_SATURATION_LUT_T() +void FLR_BOSON_SATURATION_LUT_TToByte(const FLR_BOSON_SATURATION_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ArrayToByte((const uint16_t *)(inVal->value), (uint16_t) 17,(const uint8_t *)ptr); + ptr += 34; + +} //end FLR_BOSON_SATURATION_LUT_TToByte() +void byteToFLR_BOSON_SATURATION_HEADER_LUT_T(const uint8_t *inBuff, FLR_BOSON_SATURATION_HEADER_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_BOSON_SATURATION_LUT_T((const uint8_t *)ptr,&(outVal->lut)); + ptr += 34; + + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->tableIndex)); + ptr += 2; + +} //end byteToFLR_BOSON_SATURATION_HEADER_LUT_T() +void FLR_BOSON_SATURATION_HEADER_LUT_TToByte(const FLR_BOSON_SATURATION_HEADER_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_BOSON_SATURATION_LUT_TToByte(&(inVal->lut),(const uint8_t *)ptr); + ptr += 34; + + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->tableIndex),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_BOSON_SATURATION_HEADER_LUT_TToByte() +void byteToFLR_CAPTURE_SETTINGS_T(const uint8_t *inBuff, FLR_CAPTURE_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->dataSrc)); + ptr += 4; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->numFrames)); + ptr += 4; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->bufferIndex)); + ptr += 2; + +} //end byteToFLR_CAPTURE_SETTINGS_T() +void FLR_CAPTURE_SETTINGS_TToByte(const FLR_CAPTURE_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->dataSrc), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->numFrames),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->bufferIndex),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_CAPTURE_SETTINGS_TToByte() +void byteToFLR_CAPTURE_FILE_SETTINGS_T(const uint8_t *inBuff, FLR_CAPTURE_FILE_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=132) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->captureFileType)); + ptr += 4; + + if(ptr-inBuff>=132) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *)ptr,(outVal->filePath),(uint16_t) 128); + ptr += 128; + +} //end byteToFLR_CAPTURE_FILE_SETTINGS_T() +void FLR_CAPTURE_FILE_SETTINGS_TToByte(const FLR_CAPTURE_FILE_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=132) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->captureFileType), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=132) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte((const uint8_t *)(inVal->filePath), (uint16_t) 128,(const uint8_t *)ptr); + ptr += 128; + +} //end FLR_CAPTURE_FILE_SETTINGS_TToByte() +void byteToFLR_CAPTURE_STATUS_T(const uint8_t *inBuff, FLR_CAPTURE_STATUS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->state)); + ptr += 4; + + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->result)); + ptr += 4; + + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->capturedFrames)); + ptr += 4; + + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->missedFrames)); + ptr += 4; + + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->savedFrames)); + ptr += 4; + + if(ptr-inBuff>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->unsyncFrames)); + ptr += 4; + +} //end byteToFLR_CAPTURE_STATUS_T() +void FLR_CAPTURE_STATUS_TToByte(const FLR_CAPTURE_STATUS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->state), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->result),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->capturedFrames),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->missedFrames),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->savedFrames),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=24) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->unsyncFrames),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_CAPTURE_STATUS_TToByte() +void byteToFLR_DVO_YCBCR_SETTINGS_T(const uint8_t *inBuff, FLR_DVO_YCBCR_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->ycbcrFormat)); + ptr += 4; + + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->cbcrOrder)); + ptr += 4; + + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->yOrder)); + ptr += 4; + +} //end byteToFLR_DVO_YCBCR_SETTINGS_T() +void FLR_DVO_YCBCR_SETTINGS_TToByte(const FLR_DVO_YCBCR_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->ycbcrFormat), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->cbcrOrder), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->yOrder), (const uint8_t *)ptr); + ptr += 4; + +} //end FLR_DVO_YCBCR_SETTINGS_TToByte() +void byteToFLR_DVO_RGB_SETTINGS_T(const uint8_t *inBuff, FLR_DVO_RGB_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->rgbFormat)); + ptr += 4; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->rgbOrder)); + ptr += 4; + +} //end byteToFLR_DVO_RGB_SETTINGS_T() +void FLR_DVO_RGB_SETTINGS_TToByte(const FLR_DVO_RGB_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->rgbFormat), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->rgbOrder), (const uint8_t *)ptr); + ptr += 4; + +} //end FLR_DVO_RGB_SETTINGS_TToByte() +void byteToFLR_DVO_LCD_CONFIG_T(const uint8_t *inBuff, FLR_DVO_LCD_CONFIG_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->width)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->hPulseWidth)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->hBackP)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->hFrontP)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->height)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->vPulseWidth)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->vBackP)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->vFrontP)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->outputFormat)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->control)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->rotation)); + ptr += 4; + + if(ptr-inBuff>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->pixelClockkHz)); + ptr += 4; + +} //end byteToFLR_DVO_LCD_CONFIG_T() +void FLR_DVO_LCD_CONFIG_TToByte(const FLR_DVO_LCD_CONFIG_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->width),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->hPulseWidth),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->hBackP),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->hFrontP),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->height),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->vPulseWidth),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->vBackP),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->vFrontP),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->outputFormat),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->control),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->rotation),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=48) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->pixelClockkHz),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_DVO_LCD_CONFIG_TToByte() +void byteToFLR_GAO_RNS_COL_CORRECT_T(const uint8_t *inBuff, FLR_GAO_RNS_COL_CORRECT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=40) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 20); + ptr += 40; + +} //end byteToFLR_GAO_RNS_COL_CORRECT_T() +void FLR_GAO_RNS_COL_CORRECT_TToByte(const FLR_GAO_RNS_COL_CORRECT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=40) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ArrayToByte((const int16_t *)(inVal->value), (uint16_t) 20,(const uint8_t *)ptr); + ptr += 40; + +} //end FLR_GAO_RNS_COL_CORRECT_TToByte() +void byteToFLR_ISOTHERM_COLOR_T(const uint8_t *inBuff, FLR_ISOTHERM_COLOR_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->r)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->g)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->b)); + ptr += 2; + +} //end byteToFLR_ISOTHERM_COLOR_T() +void FLR_ISOTHERM_COLOR_TToByte(const FLR_ISOTHERM_COLOR_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->r),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->g),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->b),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_ISOTHERM_COLOR_TToByte() +void byteToFLR_ISOTHERM_COLORS_T(const uint8_t *inBuff, FLR_ISOTHERM_COLORS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLOR_T((const uint8_t *)ptr,&(outVal->range1)); + ptr += 6; + + if(ptr-inBuff>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLOR_T((const uint8_t *)ptr,&(outVal->range2)); + ptr += 6; + + if(ptr-inBuff>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLOR_T((const uint8_t *)ptr,&(outVal->range3)); + ptr += 6; + + if(ptr-inBuff>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->num)); + ptr += 2; + +} //end byteToFLR_ISOTHERM_COLORS_T() +void FLR_ISOTHERM_COLORS_TToByte(const FLR_ISOTHERM_COLORS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLOR_TToByte(&(inVal->range1),(const uint8_t *)ptr); + ptr += 6; + + if((ptr-outBuff)>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLOR_TToByte(&(inVal->range2),(const uint8_t *)ptr); + ptr += 6; + + if((ptr-outBuff)>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLOR_TToByte(&(inVal->range3),(const uint8_t *)ptr); + ptr += 6; + + if((ptr-outBuff)>=20) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->num),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_ISOTHERM_COLORS_TToByte() +void byteToFLR_ISOTHERM_SETTINGS_T(const uint8_t *inBuff, FLR_ISOTHERM_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,&(outVal->thIsoT1)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,&(outVal->thIsoT2)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,&(outVal->thIsoT3)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,&(outVal->thIsoT4)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,&(outVal->thIsoT5)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color0)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color1)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color2)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color3)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color4)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_ISOTHERM_COLORS_T((const uint8_t *)ptr,&(outVal->color5)); + ptr += 20; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region0)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region1)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region2)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region3)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region4)); + ptr += 4; + + if(ptr-inBuff>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->region5)); + ptr += 4; + +} //end byteToFLR_ISOTHERM_SETTINGS_T() +void FLR_ISOTHERM_SETTINGS_TToByte(const FLR_ISOTHERM_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->thIsoT1),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->thIsoT2),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->thIsoT3),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->thIsoT4),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->thIsoT5),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color0),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color1),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color2),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color3),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color4),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_ISOTHERM_COLORS_TToByte(&(inVal->color5),(const uint8_t *)ptr); + ptr += 20; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region0), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region1), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region2), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region3), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region4), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=164) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->region5), (const uint8_t *)ptr); + ptr += 4; + +} //end FLR_ISOTHERM_SETTINGS_TToByte() +void byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 17); + ptr += 34; + +} //end byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T() +void FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ArrayToByte((const uint16_t *)(inVal->value), (uint16_t) 17,(const uint8_t *)ptr); + ptr += 34; + +} //end FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte() +void byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 17); + ptr += 34; + +} //end byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T() +void FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ArrayToByte((const uint16_t *)(inVal->value), (uint16_t) 17,(const uint8_t *)ptr); + ptr += 34; + +} //end FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte() +void byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T((const uint8_t *)ptr,&(outVal->lut)); + ptr += 34; + + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->tableIndex)); + ptr += 2; + +} //end byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T() +void FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_TToByte(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte(&(inVal->lut),(const uint8_t *)ptr); + ptr += 34; + + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->tableIndex),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_HEADER_LUT_TToByte() +void byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T(const uint8_t *inBuff, FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T((const uint8_t *)ptr,&(outVal->lut)); + ptr += 34; + + if(ptr-inBuff>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->tableIndex)); + ptr += 2; + +} //end byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T() +void FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_TToByte(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte(&(inVal->lut),(const uint8_t *)ptr); + ptr += 34; + + if((ptr-outBuff)>=36) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->tableIndex),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_RADIOMETRY_NOISE_COMP_FACTOR_HEADER_LUT_TToByte() +void byteToFLR_RADIOMETRY_RBFO_PARAMS_T(const uint8_t *inBuff, FLR_RADIOMETRY_RBFO_PARAMS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->RBFO_R)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->RBFO_B)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->RBFO_F)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->RBFO_O)); + ptr += 4; + +} //end byteToFLR_RADIOMETRY_RBFO_PARAMS_T() +void FLR_RADIOMETRY_RBFO_PARAMS_TToByte(const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->RBFO_R),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->RBFO_B),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->RBFO_F),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->RBFO_O),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_RADIOMETRY_RBFO_PARAMS_TToByte() +void byteToFLR_RADIOMETRY_TAUX_PARAMS_T(const uint8_t *inBuff, FLR_RADIOMETRY_TAUX_PARAMS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->A3)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->A2)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->A1)); + ptr += 4; + + if(ptr-inBuff>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->A0)); + ptr += 4; + +} //end byteToFLR_RADIOMETRY_TAUX_PARAMS_T() +void FLR_RADIOMETRY_TAUX_PARAMS_TToByte(const FLR_RADIOMETRY_TAUX_PARAMS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->A3),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->A2),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->A1),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=16) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->A0),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_RADIOMETRY_TAUX_PARAMS_TToByte() +void byteToFLR_ROIC_FPATEMP_TABLE_T(const uint8_t *inBuff, FLR_ROIC_FPATEMP_TABLE_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=64) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 32); + ptr += 64; + +} //end byteToFLR_ROIC_FPATEMP_TABLE_T() +void FLR_ROIC_FPATEMP_TABLE_TToByte(const FLR_ROIC_FPATEMP_TABLE_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=64) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ArrayToByte((const int16_t *)(inVal->value), (uint16_t) 32,(const uint8_t *)ptr); + ptr += 64; + +} //end FLR_ROIC_FPATEMP_TABLE_TToByte() +void byteToFLR_SCALER_ZOOM_PARAMS_T(const uint8_t *inBuff, FLR_SCALER_ZOOM_PARAMS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->zoom)); + ptr += 4; + + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->xCenter)); + ptr += 4; + + if(ptr-inBuff>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->yCenter)); + ptr += 4; + +} //end byteToFLR_SCALER_ZOOM_PARAMS_T() +void FLR_SCALER_ZOOM_PARAMS_TToByte(const FLR_SCALER_ZOOM_PARAMS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->zoom),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->xCenter),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=12) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->yCenter),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_SCALER_ZOOM_PARAMS_TToByte() +void byteToFLR_SPNR_PSD_KERNEL_T(const uint8_t *inBuff, FLR_SPNR_PSD_KERNEL_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=256) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOATArray((const uint8_t *)ptr,(outVal->fvalue),(uint16_t) 64); + ptr += 256; + +} //end byteToFLR_SPNR_PSD_KERNEL_T() +void FLR_SPNR_PSD_KERNEL_TToByte(const FLR_SPNR_PSD_KERNEL_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=256) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATArrayToByte((const float *)(inVal->fvalue), (uint16_t) 64,(const uint8_t *)ptr); + ptr += 256; + +} //end FLR_SPNR_PSD_KERNEL_TToByte() +void byteToFLR_SPOTMETER_SPOT_PARAM_T(const uint8_t *inBuff, FLR_SPOTMETER_SPOT_PARAM_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->row)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->column)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->value)); + ptr += 2; + +} //end byteToFLR_SPOTMETER_SPOT_PARAM_T() +void FLR_SPOTMETER_SPOT_PARAM_TToByte(const FLR_SPOTMETER_SPOT_PARAM_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->row),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->column),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->value),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_SPOTMETER_SPOT_PARAM_TToByte() +void byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T(const uint8_t *inBuff, FLR_SPOTMETER_STAT_PARAM_TEMP_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->row)); + ptr += 2; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->column)); + ptr += 2; + + if(ptr-inBuff>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLOAT((const uint8_t *)ptr,&(outVal->value)); + ptr += 4; + +} //end byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T() +void FLR_SPOTMETER_STAT_PARAM_TEMP_TToByte(const FLR_SPOTMETER_STAT_PARAM_TEMP_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->row),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->column),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=8) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLOATToByte((const float) (inVal->value),(const uint8_t *)ptr); + ptr += 4; + +} //end FLR_SPOTMETER_STAT_PARAM_TEMP_TToByte() +void byteToFLR_SYSINFO_MONITOR_BUILD_VARIANT_T(const uint8_t *inBuff, FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=50) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *)ptr,(outVal->value),(uint16_t) 50); + ptr += 50; + +} //end byteToFLR_SYSINFO_MONITOR_BUILD_VARIANT_T() +void FLR_SYSINFO_MONITOR_BUILD_VARIANT_TToByte(const FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=50) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte((const uint8_t *)(inVal->value), (uint16_t) 50,(const uint8_t *)ptr); + ptr += 50; + +} //end FLR_SYSINFO_MONITOR_BUILD_VARIANT_TToByte() +void byteToFLR_SYSINFO_PROBE_TIP_TYPE(const uint8_t *inBuff, FLR_SYSINFO_PROBE_TIP_TYPE *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=5) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_32((const uint8_t *)ptr,(int32_t*)&(outVal->model)); + ptr += 4; + + if(ptr-inBuff>=5) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->hwRevision)); + ptr += 1; + +} //end byteToFLR_SYSINFO_PROBE_TIP_TYPE() +void FLR_SYSINFO_PROBE_TIP_TYPEToByte(const FLR_SYSINFO_PROBE_TIP_TYPE *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=5) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_32ToByte((const int32_t) (inVal->model), (const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=5) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->hwRevision),(const uint8_t *)ptr); + ptr += 1; + +} //end FLR_SYSINFO_PROBE_TIP_TYPEToByte() +void byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->id)); + ptr += 1; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->x)); + ptr += 2; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->y)); + ptr += 2; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->width)); + ptr += 2; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->height)); + ptr += 2; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_32((const uint8_t *)ptr,&(outVal->color)); + ptr += 4; + + if(ptr-inBuff>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->size)); + ptr += 2; + +} //end byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T() +void FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(const FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->id),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->x),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->y),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->width),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->height),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_32ToByte((const uint32_t) (inVal->color),(const uint8_t *)ptr); + ptr += 4; + + if((ptr-outBuff)>=15) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->size),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte() +void byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->symbol)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->area)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->min)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->max)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->mean)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->meanBar)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarOutline)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBar)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarText1)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarText2)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarText3)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarText4)); + ptr += 15; + + if(ptr-inBuff>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->greenBarText5)); + ptr += 15; + +} //end byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_T() +void FLR_SYSTEMSYMBOLS_SPOTCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->symbol),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->area),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->min),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->max),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->mean),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->meanBar),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarOutline),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBar),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarText1),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarText2),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarText3),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarText4),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=195) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->greenBarText5),(const uint8_t *)ptr); + ptr += 15; + +} //end FLR_SYSTEMSYMBOLS_SPOTCONFIG_TToByte() +void byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->symbol)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->area)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->min)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->max)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->mean)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->meanBar)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarOutline)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBar)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarText1)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarText2)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarText3)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarText4)); + ptr += 1; + + if(ptr-inBuff>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->greenBarText5)); + ptr += 1; + +} //end byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T() +void FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_TToByte(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->symbol),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->area),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->min),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->max),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->mean),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->meanBar),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarOutline),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBar),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarText1),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarText2),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarText3),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarText4),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=13) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->greenBarText5),(const uint8_t *)ptr); + ptr += 1; + +} //end FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_TToByte() +void byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_ISOCONFIG_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=30) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->colorBar)); + ptr += 15; + + if(ptr-inBuff>=30) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToFLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_T((const uint8_t *)ptr,&(outVal->colorBarOutline)); + ptr += 15; + +} //end byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_T() +void FLR_SYSTEMSYMBOLS_ISOCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=30) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->colorBar),(const uint8_t *)ptr); + ptr += 15; + + if((ptr-outBuff)>=30) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + FLR_SYSTEMSYMBOLS_SPOT_ISO_ENTRY_TToByte(&(inVal->colorBarOutline),(const uint8_t *)ptr); + ptr += 15; + +} //end FLR_SYSTEMSYMBOLS_ISOCONFIG_TToByte() +void byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=2) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->colorBar)); + ptr += 1; + + if(ptr-inBuff>=2) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHAR((const uint8_t *)ptr,&(outVal->colorBarOutline)); + ptr += 1; + +} //end byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T() +void FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_TToByte(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=2) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->colorBar),(const uint8_t *)ptr); + ptr += 1; + + if((ptr-outBuff)>=2) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARToByte((const uint8_t) (inVal->colorBarOutline),(const uint8_t *)ptr); + ptr += 1; + +} //end FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_TToByte() +void byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T(const uint8_t *inBuff, FLR_SYSTEMSYMBOLS_BARCONFIG_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->val0)); + ptr += 2; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->val1)); + ptr += 2; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->val2)); + ptr += 2; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->val3)); + ptr += 2; + + if(ptr-inBuff>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->val4)); + ptr += 2; + +} //end byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T() +void FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->val0),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->val1),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->val2),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->val3),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=10) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->val4),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte() +void byteToFLR_TESTRAMP_SETTINGS_T(const uint8_t *inBuff, FLR_TESTRAMP_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->start)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->end)); + ptr += 2; + + if(ptr-inBuff>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->increment)); + ptr += 2; + +} //end byteToFLR_TESTRAMP_SETTINGS_T() +void FLR_TESTRAMP_SETTINGS_TToByte(const FLR_TESTRAMP_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->start),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->end),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=6) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->increment),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_TESTRAMP_SETTINGS_TToByte() +void byteToFLR_TESTRAMP_ANIMATION_SETTINGS_T(const uint8_t *inBuff, FLR_TESTRAMP_ANIMATION_SETTINGS_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=4) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToINT_16((const uint8_t *)ptr,&(outVal->moveLines)); + ptr += 2; + + if(ptr-inBuff>=4) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16((const uint8_t *)ptr,&(outVal->moveFrames)); + ptr += 2; + +} //end byteToFLR_TESTRAMP_ANIMATION_SETTINGS_T() +void FLR_TESTRAMP_ANIMATION_SETTINGS_TToByte(const FLR_TESTRAMP_ANIMATION_SETTINGS_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=4) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + INT_16ToByte((const int16_t) (inVal->moveLines),(const uint8_t *)ptr); + ptr += 2; + + if((ptr-outBuff)>=4) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ToByte((const uint16_t) (inVal->moveFrames),(const uint8_t *)ptr); + ptr += 2; + +} //end FLR_TESTRAMP_ANIMATION_SETTINGS_TToByte() +void byteToFLR_TF_WLUT_T(const uint8_t *inBuff, FLR_TF_WLUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=32) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUCHARArray((const uint8_t *)ptr,(outVal->value),(uint16_t) 32); + ptr += 32; + +} //end byteToFLR_TF_WLUT_T() +void FLR_TF_WLUT_TToByte(const FLR_TF_WLUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=32) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UCHARArrayToByte((const uint8_t *)(inVal->value), (uint16_t) 32,(const uint8_t *)ptr); + ptr += 32; + +} //end FLR_TF_WLUT_TToByte() +void byteToFLR_TF_NF_LUT_T(const uint8_t *inBuff, FLR_TF_NF_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 17); + ptr += 34; + +} //end byteToFLR_TF_NF_LUT_T() +void FLR_TF_NF_LUT_TToByte(const FLR_TF_NF_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ArrayToByte((const uint16_t *)(inVal->value), (uint16_t) 17,(const uint8_t *)ptr); + ptr += 34; + +} //end FLR_TF_NF_LUT_TToByte() +void byteToFLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T(const uint8_t *inBuff, FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *outVal) { + + uint8_t *ptr = (uint8_t *)inBuff; + if(ptr-inBuff>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + byteToUINT_16Array((const uint8_t *)ptr,(outVal->value),(uint16_t) 17); + ptr += 34; + +} //end byteToFLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T() +void FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_TToByte(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *inVal, const uint8_t *outBuff) { + + uint8_t *ptr = (uint8_t *)outBuff; + if((ptr-outBuff)>=34) { + return;// R_CAM_PKG_BUFFER_OVERFLOW; + } + UINT_16ArrayToByte((const uint16_t *)(inVal->value), (uint16_t) 17,(const uint8_t *)ptr); + ptr += 34; + +} //end FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_TToByte() diff --git a/src/drivers/boson/src/UART_Connector.c b/src/drivers/boson/src/UART_Connector.c new file mode 100644 index 000000000..d33307ef7 --- /dev/null +++ b/src/drivers/boson/src/UART_Connector.c @@ -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); +} diff --git a/src/drivers/boson/src/UPTClient.c b/src/drivers/boson/src/UPTClient.c new file mode 100644 index 000000000..b684553e8 --- /dev/null +++ b/src/drivers/boson/src/UPTClient.c @@ -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 + +#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; +} diff --git a/src/drivers/boson/src/dataServiceClient.c b/src/drivers/boson/src/dataServiceClient.c new file mode 100644 index 000000000..f0e784388 --- /dev/null +++ b/src/drivers/boson/src/dataServiceClient.c @@ -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 +#include + +#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; +} diff --git a/src/drivers/boson/src/fifo.c b/src/drivers/boson/src/fifo.c new file mode 100644 index 000000000..48c6d38f5 --- /dev/null +++ b/src/drivers/boson/src/fifo.c @@ -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 +#include +#include + +#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; +} diff --git a/src/drivers/boson/src/flirCRC.c b/src/drivers/boson/src/flirCRC.c new file mode 100644 index 000000000..deded8219 --- /dev/null +++ b/src/drivers/boson/src/flirCRC.c @@ -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; +} diff --git a/src/drivers/boson/src/flirChannels.c b/src/drivers/boson/src/flirChannels.c new file mode 100644 index 000000000..b52213bad --- /dev/null +++ b/src/drivers/boson/src/flirChannels.c @@ -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; + } +} diff --git a/src/drivers/boson/src/serialPortAdapter.c b/src/drivers/boson/src/serialPortAdapter.c new file mode 100644 index 000000000..626d673ff --- /dev/null +++ b/src/drivers/boson/src/serialPortAdapter.c @@ -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; +} diff --git a/src/drivers/boson/src/timeoutLogic.c b/src/drivers/boson/src/timeoutLogic.c new file mode 100644 index 000000000..d3f03af9f --- /dev/null +++ b/src/drivers/boson/src/timeoutLogic.c @@ -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; +} diff --git a/src/omv/Makefile b/src/omv/Makefile index 5ee244eae..337651d3a 100644 --- a/src/omv/Makefile +++ b/src/omv/Makefile @@ -39,6 +39,7 @@ SRCS += $(addprefix sensors/, \ ov9650.c \ mt9v0xx.c \ mt9m114.c \ + boson.c \ lepton.c \ hm01b0.c \ hm0360.c \ diff --git a/src/omv/boards/OPENMV_RT1060/omv_boardconfig.h b/src/omv/boards/OPENMV_RT1060/omv_boardconfig.h index fd60c97c7..8d30a376d 100644 --- a/src/omv/boards/OPENMV_RT1060/omv_boardconfig.h +++ b/src/omv/boards/OPENMV_RT1060/omv_boardconfig.h @@ -41,6 +41,7 @@ #define OMV_MT9M114_ENABLE (1) #define OMV_MT9V0XX_ENABLE (1) +#define OMV_BOSON_ENABLE (1) #define OMV_LEPTON_ENABLE (1) #define OMV_GENX320_ENABLE (1) #define OMV_GENX320_EHC_ENABLE (1) diff --git a/src/omv/common/export.mk b/src/omv/common/export.mk index a98c3ac15..763c18fdf 100644 --- a/src/omv/common/export.mk +++ b/src/omv/common/export.mk @@ -73,6 +73,7 @@ export BOOT_DIR export OMV_DIR export CMSIS_DIR export MICROPY_DIR +export BOSON_DIR export LEPTON_DIR export LSM6DS3_DIR export LSM6DSM_DIR diff --git a/src/omv/common/omv_csi.c b/src/omv/common/omv_csi.c index a24df3e39..b7642ba99 100644 --- a/src/omv/common/omv_csi.c +++ b/src/omv/common/omv_csi.c @@ -51,6 +51,7 @@ #include "mt9v0xx.h" #include "mt9m114.h" #include "lepton.h" +#include "boson.h" #include "hm01b0.h" #include "hm0360.h" #include "pag7920.h" @@ -260,6 +261,12 @@ static int omv_csi_detect() { return slv_addr; #endif // (OMV_MT9M114_ENABLE == 1) + #if (OMV_BOSON_ENABLE == 1) + case BOSON_SLV_ADDR: + csi.chip_id = BOSON_ID; + return slv_addr; + #endif // (OMV_BOSON_ENABLE == 1) + #if (OMV_LEPTON_ENABLE == 1) case LEPTON_SLV_ADDR: csi.chip_id = LEPTON_ID; @@ -449,6 +456,15 @@ int omv_csi_probe_init(uint32_t bus_id, uint32_t bus_speed) { break; #endif //(OMV_MT9M114_ENABLE == 1) + #if (OMV_BOSON_ENABLE == 1) + case BOSON_ID: + if (omv_csi_set_clk_frequency(OMV_BOSON_CLK_FREQ) != 0) { + return OMV_CSI_ERROR_TIM_INIT_FAILED; + } + init_ret = boson_init(&csi); + break; + #endif // (OMV_BOSON_ENABLE == 1) + #if (OMV_LEPTON_ENABLE == 1) case LEPTON_ID: if (omv_csi_set_clk_frequency(OMV_LEPTON_CLK_FREQ) != 0) { diff --git a/src/omv/common/omv_csi.h b/src/omv/common/omv_csi.h index bc549d461..89a66c9b3 100644 --- a/src/omv/common/omv_csi.h +++ b/src/omv/common/omv_csi.h @@ -41,6 +41,7 @@ #define OV7725_SLV_ADDR (0x42) #define MT9V0XX_SLV_ADDR (0xB8) #define MT9M114_SLV_ADDR (0x90) +#define BOSON_SLV_ADDR (0xAE) #define LEPTON_SLV_ADDR (0x54) #define HM0XX0_SLV_ADDR (0x48) #define GC2145_SLV_ADDR (0x78) @@ -72,6 +73,9 @@ #define MT9V0X4_ID (0x1324) #define MT9V0X4_C_ID (0x1424) #define MT9M114_ID (0x2481) +#define BOSON_ID (0xAE) +#define BOSON_320_ID (0xAE32) +#define BOSON_640_ID (0xAE64) #define LEPTON_ID (0x54) #define LEPTON_1_5 (0x5415) #define LEPTON_1_6 (0x5416) diff --git a/src/omv/ports/mimxrt/omv_portconfig.mk b/src/omv/ports/mimxrt/omv_portconfig.mk index 14b4baaed..8a761e66b 100644 --- a/src/omv/ports/mimxrt/omv_portconfig.mk +++ b/src/omv/ports/mimxrt/omv_portconfig.mk @@ -122,6 +122,7 @@ OMV_CFLAGS += -I$(TOP_DIR)/$(OMV_DIR)/ports/$(PORT)/ OMV_CFLAGS += -I$(TOP_DIR)/$(OMV_DIR)/ports/$(PORT)/modules/ OMV_CFLAGS += -I$(TOP_DIR)/$(GENX320_DIR)/include/ +OMV_CFLAGS += -I$(TOP_DIR)/$(BOSON_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LEPTON_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LSM6DS3_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LSM6DSOX_DIR)/include/ @@ -138,6 +139,7 @@ CFLAGS += $(HAL_CFLAGS) $(MPY_CFLAGS) $(OMV_CFLAGS) FIRM_OBJ += $(wildcard $(BUILD)/$(CMSIS_DIR)/src/dsp/*/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(HAL_DIR)/drivers/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(GENX320_DIR)/src/*.o) +FIRM_OBJ += $(wildcard $(BUILD)/$(BOSON_DIR)/src/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(LEPTON_DIR)/src/*.o) ifeq ($(MICROPY_PY_IMU), 1) FIRM_OBJ += $(wildcard $(BUILD)/$(LSM6DS3_DIR)/src/*.o) @@ -185,6 +187,7 @@ FIRM_OBJ += $(addprefix $(BUILD)/$(OMV_DIR)/sensors/, \ ov9650.o \ mt9v0xx.o \ mt9m114.o \ + boson.o \ lepton.o \ hm01b0.o \ hm0360.o \ @@ -565,6 +568,7 @@ ifeq ($(MICROPY_PY_ML_TFLM), 1) endif $(MAKE) -C $(MICROPY_DIR)/ports/$(PORT) BUILD=$(BUILD)/$(MICROPY_DIR) $(MICROPY_ARGS) $(MAKE) -C $(GENX320_DIR) BUILD=$(BUILD)/$(GENX320_DIR) CFLAGS="$(CFLAGS) -MMD" + $(MAKE) -C $(BOSON_DIR) BUILD=$(BUILD)/$(BOSON_DIR) CFLAGS="$(CFLAGS) -MMD" $(MAKE) -C $(LEPTON_DIR) BUILD=$(BUILD)/$(LEPTON_DIR) CFLAGS="$(CFLAGS) -MMD" ifeq ($(MICROPY_PY_IMU), 1) $(MAKE) -C $(LSM6DS3_DIR) BUILD=$(BUILD)/$(LSM6DS3_DIR) CFLAGS="$(CFLAGS) -MMD" diff --git a/src/omv/ports/stm32/omv_portconfig.mk b/src/omv/ports/stm32/omv_portconfig.mk index 1197052a6..52946675a 100644 --- a/src/omv/ports/stm32/omv_portconfig.mk +++ b/src/omv/ports/stm32/omv_portconfig.mk @@ -115,6 +115,7 @@ OMV_CFLAGS += -I$(TOP_DIR)/$(OMV_DIR)/ports/$(PORT)/ OMV_CFLAGS += -I$(TOP_DIR)/$(OMV_DIR)/ports/$(PORT)/modules/ OMV_CFLAGS += -I$(TOP_DIR)/$(GENX320_DIR)/include/ +OMV_CFLAGS += -I$(TOP_DIR)/$(BOSON_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LEPTON_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LSM6DS3_DIR)/include/ OMV_CFLAGS += -I$(TOP_DIR)/$(LSM6DSOX_DIR)/include/ @@ -149,6 +150,7 @@ FIRM_OBJ += $(wildcard $(BUILD)/$(CMSIS_DIR)/src/dsp/*/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(HAL_DIR)/src/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(GENX320_DIR)/src/*.o) +FIRM_OBJ += $(wildcard $(BUILD)/$(BOSON_DIR)/src/*.o) FIRM_OBJ += $(wildcard $(BUILD)/$(LEPTON_DIR)/src/*.o) ifeq ($(MICROPY_PY_IMU), 1) FIRM_OBJ += $(wildcard $(BUILD)/$(LSM6DS3_DIR)/src/*.o) @@ -200,6 +202,7 @@ FIRM_OBJ += $(addprefix $(BUILD)/$(OMV_DIR)/sensors/, \ ov9650.o \ mt9v0xx.o \ mt9m114.o \ + boson.o \ lepton.o \ hm01b0.o \ hm0360.o \ @@ -594,6 +597,7 @@ UVC_OBJ += $(addprefix $(BUILD)/$(OMV_DIR)/sensors/, \ ov9650.o \ mt9v0xx.o \ mt9m114.o \ + boson.o \ lepton.o \ hm01b0.o \ hm0360.o \ @@ -630,6 +634,7 @@ UVC_OBJ += $(addprefix $(BUILD)/$(OMV_DIR)/ports/stm32/,\ ) UVC_OBJ += $(wildcard $(BUILD)/$(GENX320_DIR)/src/*.o) +UVC_OBJ += $(wildcard $(BUILD)/$(BOSON_DIR)/src/*.o) UVC_OBJ += $(wildcard $(BUILD)/$(LEPTON_DIR)/src/*.o) ifeq ($(MICROPY_PY_IMU), 1) UVC_OBJ += $(wildcard $(BUILD)/$(LSM6DS3_DIR)/src/*.o) @@ -674,6 +679,7 @@ ifeq ($(MICROPY_PY_ML_TFLM), 1) endif $(MAKE) -C $(MICROPY_DIR)/ports/$(PORT) BUILD=$(BUILD)/$(MICROPY_DIR) $(MICROPY_ARGS) $(MAKE) -C $(GENX320_DIR) BUILD=$(BUILD)/$(GENX320_DIR) CFLAGS="$(CFLAGS) -MMD" + $(MAKE) -C $(BOSON_DIR) BUILD=$(BUILD)/$(BOSON_DIR) CFLAGS="$(CFLAGS) -MMD" $(MAKE) -C $(LEPTON_DIR) BUILD=$(BUILD)/$(LEPTON_DIR) CFLAGS="$(CFLAGS) -MMD" ifeq ($(MICROPY_PY_IMU), 1) $(MAKE) -C $(LSM6DS3_DIR) BUILD=$(BUILD)/$(LSM6DS3_DIR) CFLAGS="$(CFLAGS) -MMD" diff --git a/src/omv/sensors/boson.c b/src/omv/sensors/boson.c new file mode 100644 index 000000000..acad93f24 --- /dev/null +++ b/src/omv/sensors/boson.c @@ -0,0 +1,154 @@ +/* + * 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. + * + * Boson driver. + */ +#include "omv_boardconfig.h" +#if (OMV_BOSON_ENABLE == 1) + +#include +#include +#include + +#include "py/mphal.h" +#include "framebuffer.h" +#include "omv_csi.h" + +#include "Client_API.h" +#include "UART_Connector.h" + +#define FLIR_BOSON_BOOT_TIME_MS (2500) + +static int boson_framesize = 0; + +static int reset(omv_csi_t *csi) { + csi->color_palette = NULL; + + // Give the camera time to boot. + mp_hal_delay_ms(FLIR_BOSON_BOOT_TIME_MS); + + // Turn the com port on. + Initialize(); + + FLR_BOSON_PARTNUMBER_T part; + if (bosonGetCameraPN(&part) != FLR_OK) { + return -1; + } + + if (!strncmp((char *) (part.value + 2), "640", 3)) { + boson_framesize = OMV_CSI_FRAMESIZE_VGA; + } else if (!strncmp((char *) (part.value + 2), "320", 3)) { + boson_framesize = OMV_CSI_FRAMESIZE_QVGA; + } else { + return -1; + } + + if (dvoSetType(FLR_DVO_TYPE_MONO8) != FLR_OK) { + return -1; + } + + if (telemetrySetState(FLR_DISABLE) != FLR_OK) { + return -1; + } + + return 0; +} + +static int set_pixformat(omv_csi_t *csi, pixformat_t pixformat) { + return (pixformat == PIXFORMAT_GRAYSCALE) ? 0 : -1; +} + +static int set_framesize(omv_csi_t *csi, omv_csi_framesize_t framesize) { + return (framesize == boson_framesize) ? 0 : -1; +} + +static int set_colorbar(omv_csi_t *csi, int enable) { + if (gaoSetTestRampState(enable ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + + if (testRampSetType(0, FLR_TESTRAMP_VERT_SHADE) != FLR_OK) { + return -1; + } + + return 0; +} + +static int snapshot(omv_csi_t *csi, image_t *image, uint32_t flags) { + int ret = omv_csi_snapshot(csi, image, flags); + + if (ret < 0) { + return ret; + } + + int num_pixels = resolution[boson_framesize][0] * resolution[boson_framesize][1]; + + if (csi->color_palette && (framebuffer_get_buffer_size() >= (num_pixels * sizeof(uint16_t)))) { + for (int32_t i = num_pixels - 1; i >= 0; i--) { + ((uint16_t *) image->data)[i] = csi->color_palette[image->data[i]]; + } + + image->pixfmt = PIXFORMAT_RGB565; + MAIN_FB()->pixfmt = PIXFORMAT_RGB565; + } + + return ret; +} + +int boson_init(omv_csi_t *csi) { + // Initialize csi structure + csi->reset = reset; + csi->set_pixformat = set_pixformat; + csi->set_framesize = set_framesize; + csi->set_colorbar = set_colorbar; + csi->snapshot = snapshot; + + // Set csi flags + csi->vsync_pol = 0; + csi->hsync_pol = 0; + csi->pixck_pol = 1; + csi->mono_bpp = sizeof(uint8_t); + + // Override standard resolutions + resolution[OMV_CSI_FRAMESIZE_VGA][0] = 640; + resolution[OMV_CSI_FRAMESIZE_VGA][1] = 512; + + resolution[OMV_CSI_FRAMESIZE_QVGA][0] = 320; + resolution[OMV_CSI_FRAMESIZE_QVGA][1] = 256; + + if (reset(csi) != 0) { + return -1; + } + + csi->chip_id = (boson_framesize == OMV_CSI_FRAMESIZE_VGA) ? BOSON_640_ID : BOSON_320_ID; + + return 0; +} +#endif // (OMV_BOSON_ENABLE == 1) diff --git a/src/omv/sensors/boson.h b/src/omv/sensors/boson.h new file mode 100644 index 000000000..09bc42312 --- /dev/null +++ b/src/omv/sensors/boson.h @@ -0,0 +1,37 @@ +/* + * 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. + * + * Boson driver. + */ +#ifndef __BOSON_H__ +#define __BOSON_H__ +#define OMV_BOSON_CLK_FREQ (0) +int boson_init(omv_csi_t *csi); +#endif // __BOSON_H__