openmv/drivers/boson/src/Client_Packager.c
iabdalkader daf2bb30da misc: Restructure repo.
Signed-off-by: iabdalkader <i.abdalkader@gmail.com>
2025-04-13 08:28:34 +02:00

30496 lines
1.0 MiB

// /////////////////////////////////////////////////////
// // 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_Packager.h"
static uint32_t commandCount = 0;
// Begin Module: TLinear
// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT CLIENT_pkgTlinearSetControl(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++, 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 *) &region0;
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 *) &region1;
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 *) &region2;
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 *) &region3;
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 *) &region4;
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 *) &region5;
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