// ///////////////////////////////////////////////////// // // 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 *) ®ion0; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } //write region1 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion1; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } //write region2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion2; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } //write region3 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion3; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } //write region4 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion4; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } //write region5 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_COLORS_T *inVal = (const FLR_ISOTHERM_COLORS_T *) ®ion5; FLR_ISOTHERM_COLORS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 20; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETISOCOLORVALUES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetIsoColorValues() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetIsoColorValues(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_COLORS_T *region0, FLR_ISOTHERM_COLORS_T *region1, FLR_ISOTHERM_COLORS_T *region2, FLR_ISOTHERM_COLORS_T *region3, FLR_ISOTHERM_COLORS_T *region4, FLR_ISOTHERM_COLORS_T *region5) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 120; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write table to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_GAIN_E inVal = table; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETISOCOLORVALUES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read region0 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region0 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region0 handling // read region1 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region1 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region1 handling // read region2 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region2 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region2 handling // read region3 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region3 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region3 handling // read region4 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region4 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region4 handling // read region5 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_COLORS_T outVal; byteToFLR_ISOTHERM_COLORS_T( (const uint8_t *) inPtr, &outVal); *region5 = (FLR_ISOTHERM_COLORS_T)outVal; inPtr+=20; }// end of region5 handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetIsoColorValues() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermSetRegionMode(const FLR_ISOTHERM_GAIN_E table, const FLR_ISOTHERM_REGION_E region0, const FLR_ISOTHERM_REGION_E region1, const FLR_ISOTHERM_REGION_E region2, const FLR_ISOTHERM_REGION_E region3, const FLR_ISOTHERM_REGION_E region4, const FLR_ISOTHERM_REGION_E region5) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 28; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write table to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_GAIN_E inVal = table; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region0 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region0; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region1 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region1; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region2; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region3 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region3; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region4 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region4; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write region5 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_REGION_E inVal = region5; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETREGIONMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetRegionMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetRegionMode(const FLR_ISOTHERM_GAIN_E table, FLR_ISOTHERM_REGION_E *region0, FLR_ISOTHERM_REGION_E *region1, FLR_ISOTHERM_REGION_E *region2, FLR_ISOTHERM_REGION_E *region3, FLR_ISOTHERM_REGION_E *region4, FLR_ISOTHERM_REGION_E *region5) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 24; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write table to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_GAIN_E inVal = table; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETREGIONMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read region0 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region0 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region0 handling // read region1 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region1 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region1 handling // read region2 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region2 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region2 handling // read region3 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region3 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region3 handling // read region4 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region4 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region4 handling // read region5 from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *region5 = (FLR_ISOTHERM_REGION_E)outVal; inPtr+=4; }// end of region5 handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetRegionMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetUnit(FLR_ISOTHERM_UNIT_E *unit) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETUNIT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read unit from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *unit = (FLR_ISOTHERM_UNIT_E)outVal; inPtr+=4; }// end of unit handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetUnit() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermSetUnit(const FLR_ISOTHERM_UNIT_E unit) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write unit to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_UNIT_E inVal = unit; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETUNIT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetUnit() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetSettingsLowGain(FLR_ISOTHERM_SETTINGS_T *settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 164; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETSETTINGSLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read settings from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_SETTINGS_T outVal; byteToFLR_ISOTHERM_SETTINGS_T( (const uint8_t *) inPtr, &outVal); *settings = (FLR_ISOTHERM_SETTINGS_T)outVal; inPtr+=164; }// end of settings handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetSettingsLowGain() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermSetSettingsLowGain(const FLR_ISOTHERM_SETTINGS_T settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 164; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write settings to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_SETTINGS_T *inVal = (const FLR_ISOTHERM_SETTINGS_T *) &settings; FLR_ISOTHERM_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 164; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETSETTINGSLOWGAIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetSettingsLowGain() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetSettingsHighGain(FLR_ISOTHERM_SETTINGS_T *settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 164; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETSETTINGSHIGHGAIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read settings from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ISOTHERM_SETTINGS_T outVal; byteToFLR_ISOTHERM_SETTINGS_T( (const uint8_t *) inPtr, &outVal); *settings = (FLR_ISOTHERM_SETTINGS_T)outVal; inPtr+=164; }// end of settings handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetSettingsHighGain() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermSetSettingsHighGain(const FLR_ISOTHERM_SETTINGS_T settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 164; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write settings to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ISOTHERM_SETTINGS_T *inVal = (const FLR_ISOTHERM_SETTINGS_T *) &settings; FLR_ISOTHERM_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 164; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETSETTINGSHIGHGAIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetSettingsHighGain() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermSetColorLutId(const FLR_COLORLUT_ID_E colorLutIdLowGain, const FLR_COLORLUT_ID_E colorLutIdHighGain) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 8; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write colorLutIdLowGain to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_COLORLUT_ID_E inVal = colorLutIdLowGain; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write colorLutIdHighGain to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_COLORLUT_ID_E inVal = colorLutIdHighGain; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_SETCOLORLUTID, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgIsothermSetColorLutId() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgIsothermGetColorLutId(FLR_COLORLUT_ID_E *colorLutIdLowGain, FLR_COLORLUT_ID_E *colorLutIdHighGain) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ISOTHERM_GETCOLORLUTID, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read colorLutIdLowGain from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *colorLutIdLowGain = (FLR_COLORLUT_ID_E)outVal; inPtr+=4; }// end of colorLutIdLowGain handling // read colorLutIdHighGain from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *colorLutIdHighGain = (FLR_COLORLUT_ID_E)outVal; inPtr+=4; }// end of colorLutIdHighGain handling return R_SUCCESS; }// End of CLIENT_pkgIsothermGetColorLutId() // End Module: isotherm // Begin Module: jffs2 // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgJffs2Mount() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_MOUNT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgJffs2Mount() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgJffs2Unmount() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_UNMOUNT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgJffs2Unmount() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgJffs2GetState(FLR_JFFS2_STATE_E *state) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, JFFS2_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read state from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *state = (FLR_JFFS2_STATE_E)outVal; inPtr+=4; }// end of state handling return R_SUCCESS; }// End of CLIENT_pkgJffs2GetState() // End Module: jffs2 // Begin Module: lagrange // End Module: lagrange // Begin Module: latencyCtrl // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlSetLowLatencyState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETLOWLATENCYSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlSetLowLatencyState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlGetLowLatencyState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETLOWLATENCYSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlGetLowLatencyState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlSetJitterReduction(const FLR_ENABLE_E enable, const int32_t line) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 8; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write enable to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = enable; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write line to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int32_t inVal = line; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETJITTERREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlSetJitterReduction() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlGetJitterReduction(FLR_ENABLE_E *enable, int32_t *line) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETJITTERREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read enable from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *enable = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of enable handling // read line from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *line = (int32_t)outVal; inPtr+=4; }// end of line handling return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlGetJitterReduction() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlLatencyResetStats() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_LATENCYRESETSTATS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlLatencyResetStats() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlGetJitter(float *jitterMin, float *jitterMax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETJITTER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read jitterMin from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *jitterMin = (float)outVal; inPtr+=4; }// end of jitterMin handling // read jitterMax from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *jitterMax = (float)outVal; inPtr+=4; }// end of jitterMax handling return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlGetJitter() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlGetLatency(float *latencyMin, float *latencyMax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETLATENCY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read latencyMin from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *latencyMin = (float)outVal; inPtr+=4; }// end of latencyMin handling // read latencyMax from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *latencyMax = (float)outVal; inPtr+=4; }// end of latencyMax handling return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlGetLatency() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction(const int32_t line) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write line to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int32_t inVal = line; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_SETUSBVIDEOLATENCYREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlSetUsbVideoLatencyReduction() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction(int32_t *line) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LATENCYCTRL_GETUSBVIDEOLATENCYREDUCTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read line from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *line = (int32_t)outVal; inPtr+=4; }// end of line handling return R_SUCCESS; }// End of CLIENT_pkgLatencyctrlGetUsbVideoLatencyReduction() // End Module: latencyCtrl // Begin Module: lfsr // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetApplyOffsetEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETAPPLYOFFSETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetApplyOffsetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetApplyOffsetEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETAPPLYOFFSETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetApplyOffsetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetMaxIterations(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETMAXITERATIONS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetMaxIterations() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetMaxIterations(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETMAXITERATIONS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetMaxIterations() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetDf(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETDF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetDf() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetDf(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETDF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetDf() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetLambda1(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETLAMBDA1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetLambda1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetLambda1(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETLAMBDA1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetLambda1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetLambda2(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETLAMBDA2, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetLambda2() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetLambda2(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETLAMBDA2, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetLambda2() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetHaltEnable(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETHALTENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetHaltEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetHaltEnable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETHALTENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetHaltEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetRandomMethod(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETRANDOMMETHOD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetRandomMethod() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetRandomMethod(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETRANDOMMETHOD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetRandomMethod() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetSingleStepEnable(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETSINGLESTEPENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetSingleStepEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetSingleStepEnable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETSINGLESTEPENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetSingleStepEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetR_LocalBump(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETR_LOCALBUMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetR_LocalBump() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetR_LocalBump(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETR_LOCALBUMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetR_LocalBump() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetR_CornerBump(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETR_CORNERBUMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetR_CornerBump() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetR_CornerBump(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETR_CORNERBUMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetR_CornerBump() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetFFC_ResetEnable(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETFFC_RESETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetFFC_ResetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetFFC_ResetEnable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETFFC_RESETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetFFC_ResetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrSetNormalizeAtCenterSpotState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_SETNORMALIZEATCENTERSPOTSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgLfsrSetNormalizeAtCenterSpotState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgLfsrGetNormalizeAtCenterSpotState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, LFSR_GETNORMALIZEATCENTERSPOTSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgLfsrGetNormalizeAtCenterSpotState() // End Module: lfsr // Begin Module: mem // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 7; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 256; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write bufferNum to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = bufferNum; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write sizeInBytes to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = sizeInBytes; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCAPTURE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); inPtr+=sizeInBytes; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgMemReadCapture() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETCAPTURESIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read bytes from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *bytes = (uint32_t)outVal; inPtr+=4; }// end of bytes handling // read rows from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *rows = (uint16_t)outVal; inPtr+=2; }// end of rows handling // read columns from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *columns = (uint16_t)outVal; inPtr+=2; }// end of columns handling return R_SUCCESS; }// End of CLIENT_pkgMemGetCaptureSize() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemWriteFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = (uint32_t) sizeInBytes + 11; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write location to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_MEM_LOCATION_E inVal = location; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write sizeInBytes to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = sizeInBytes; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } UCHARArrayToByte(data,sizeInBytes,(const uint8_t *) outPtr); outPtr += sizeInBytes; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_WRITEFLASH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgMemWriteFlash() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemReadFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 11; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 256; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write location to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_MEM_LOCATION_E inVal = location; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write sizeInBytes to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = sizeInBytes; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READFLASH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); inPtr+=sizeInBytes; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgMemReadFlash() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write location to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_MEM_LOCATION_E inVal = location; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETFLASHSIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read bytes from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *bytes = (uint32_t)outVal; inPtr+=4; }// end of bytes handling return R_SUCCESS; }// End of CLIENT_pkgMemGetFlashSize() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 5; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write location to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_MEM_LOCATION_E inVal = location; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_ERASEFLASH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgMemEraseFlash() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write location to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_MEM_LOCATION_E inVal = location; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write length to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = length; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_ERASEFLASHPARTIAL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgMemEraseFlashPartial() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 6; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 256; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write sizeInBytes to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = sizeInBytes; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCURRENTGAIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); inPtr+=sizeInBytes; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgMemReadCurrentGain() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETGAINSIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read bytes from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *bytes = (uint32_t)outVal; inPtr+=4; }// end of bytes handling // read rows from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *rows = (uint16_t)outVal; inPtr+=2; }// end of rows handling // read columns from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *columns = (uint16_t)outVal; inPtr+=2; }// end of columns handling return R_SUCCESS; }// End of CLIENT_pkgMemGetGainSize() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemGetCaptureSizeSrc(const FLR_CAPTURE_SRC_E src, uint32_t *bytes, uint16_t *rows, uint16_t *columns) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write src to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_CAPTURE_SRC_E inVal = src; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_GETCAPTURESIZESRC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read bytes from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *bytes = (uint32_t)outVal; inPtr+=4; }// end of bytes handling // read rows from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *rows = (uint16_t)outVal; inPtr+=2; }// end of rows handling // read columns from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *columns = (uint16_t)outVal; inPtr+=2; }// end of columns handling return R_SUCCESS; }// End of CLIENT_pkgMemGetCaptureSizeSrc() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgMemReadCaptureSrc(const FLR_CAPTURE_SRC_E src, const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 11; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 256; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write src to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_CAPTURE_SRC_E inVal = src; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write bufferNum to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = bufferNum; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write offset to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = offset; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write sizeInBytes to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = sizeInBytes; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, MEM_READCAPTURESRC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } byteToUCHARArray((const uint8_t *) inPtr, data,sizeInBytes); inPtr+=sizeInBytes; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgMemReadCaptureSrc() // End Module: mem // Begin Module: normalize // End Module: normalize // Begin Module: radiometry // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempStableEnable(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSTABLEENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempStableEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempStableEnable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSTABLEENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempStableEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens0(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERLENS0, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetFNumberLens0() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens0(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERLENS0, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetFNumberLens0() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetFNumberLens1(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERLENS1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetFNumberLens1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetFNumberLens1(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERLENS1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetFNumberLens1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTauLens0(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAULENS0, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTauLens0() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTauLens0(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAULENS0, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTauLens0() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTauLens1(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAULENS1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTauLens1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTauLens1(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAULENS1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTauLens1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainDesired(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalGainDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetDesired(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalOffsetDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainApplied(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalGainApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetApplied(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalOffsetApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTComponentOverrideMode(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTCOMPONENTOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTComponentOverrideMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTComponentOverrideMode(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTCOMPONENTOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTComponentOverrideMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetGlobalGainOverride(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALGAINOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetGlobalGainOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalGainOverride(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALGAINOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalGainOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetGlobalOffsetOverride(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALOFFSETOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetGlobalOffsetOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalOffsetOverride(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALOFFSETOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalOffsetOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetGlobalParamOverrideMode(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGLOBALPARAMOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetGlobalParamOverrideMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGlobalParamOverrideMode(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGLOBALPARAMOVERRIDEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGlobalParamOverrideMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 16; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 16; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOHIGHGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetRBFOHighGainDefault() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOHIGHGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_RBFO_PARAMS_T outVal; byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; inPtr+=16; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRBFOHighGainDefault() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainDefault(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 16; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 16; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOLOWGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetRBFOLowGainDefault() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainDefault(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOLOWGAINDEFAULT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_RBFO_PARAMS_T outVal; byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; inPtr+=16; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRBFOLowGainDefault() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetRBFOHighGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 16; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 16; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOHIGHGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetRBFOHighGainFactory() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRBFOHighGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOHIGHGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_RBFO_PARAMS_T outVal; byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; inPtr+=16; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRBFOHighGainFactory() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetRBFOLowGainFactory(const FLR_RADIOMETRY_RBFO_PARAMS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 16; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_PARAMS_T *inVal = (const FLR_RADIOMETRY_RBFO_PARAMS_T *) &data; FLR_RADIOMETRY_RBFO_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 16; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOLOWGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetRBFOLowGainFactory() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRBFOLowGainFactory(FLR_RADIOMETRY_RBFO_PARAMS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOLOWGAINFACTORY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_RBFO_PARAMS_T outVal; byteToFLR_RADIOMETRY_RBFO_PARAMS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_RBFO_PARAMS_T)outVal; inPtr+=16; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRBFOLowGainFactory() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetDampingFactor(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetDampingFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetDampingFactor(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetDampingFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGoMEQ(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMEQ, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGoMEQ() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGoMShutter(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMSHUTTER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGoMShutter() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGoMLens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMLENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGoMLens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGoMLG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMLG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGoMLG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGoMFFC(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGOMFFC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGoMFFC() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousing(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPLENSHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempLensHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousing(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempShutterHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddle(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERPADDLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempShutterPaddle() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetFNumberShutterHousing(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETFNUMBERSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetFNumberShutterHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetFNumberShutterHousing(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFNUMBERSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetFNumberShutterHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetEmissivityShutterHousing(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEMISSIVITYSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetEmissivityShutterHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetEmissivityShutterHousing(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEMISSIVITYSHUTTERHOUSING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetEmissivityShutterHousing() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Lens(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_DTfpa_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Lens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_DTfpa_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetOffset_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetOffset_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Lens(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Recursive_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Lens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Recursive_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGgFfc(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGGFFC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGgFfc() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetCountsFromTemp(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const float temp, uint16_t *counts) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 8; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write rbfoType to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_TYPE_E inVal = rbfoType; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write temp to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = temp; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETCOUNTSFROMTEMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read counts from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *counts = (uint16_t)outVal; inPtr+=2; }// end of counts handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetCountsFromTemp() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempFromCounts(const FLR_RADIOMETRY_RBFO_TYPE_E rbfoType, const uint16_t counts, float *temp) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 6; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write rbfoType to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_RBFO_TYPE_E inVal = rbfoType; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write counts to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = counts; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPFROMCOUNTS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read temp from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *temp = (float)outVal; inPtr+=4; }// end of temp handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempFromCounts() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempLensHousingOverride(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPLENSHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempLensHousingOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempLensHousingOverride(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPLENSHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempLensHousingOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempShutterHousingOverride(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSHUTTERHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempShutterHousingOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempShutterHousingOverride(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERHOUSINGOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempShutterHousingOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempShutterPaddleOverride(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPSHUTTERPADDLEOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempShutterPaddleOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempShutterPaddleOverride(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPSHUTTERPADDLEOVERRIDE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempShutterPaddleOverride() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetSignalFactorLut(const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 34; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *inVal = (const FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *) &data; FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 34; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETSIGNALFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetSignalFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetSignalFactorLut(FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 34; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSIGNALFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T outVal; byteToFLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_SIGNAL_COMP_FACTOR_LUT_T)outVal; inPtr+=34; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetSignalFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetNoiseFactorLut(const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 34; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *inVal = (const FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *) &data; FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 34; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETNOISEFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetNoiseFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetNoiseFactorLut(FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 34; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETNOISEFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T outVal; byteToFLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_NOISE_COMP_FACTOR_LUT_T)outVal; inPtr+=34; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetNoiseFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_tfpaK(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_tfpaK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_tfpaK(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_tfpaK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_tfpaK(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_tfpaK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_tfpaK(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_TFPAK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_tfpaK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTAuxParams(const FLR_RADIOMETRY_TAUX_PARAMS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 16; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_RADIOMETRY_TAUX_PARAMS_T *inVal = (const FLR_RADIOMETRY_TAUX_PARAMS_T *) &data; FLR_RADIOMETRY_TAUX_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 16; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTAUXPARAMS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTAuxParams() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTAuxParams(FLR_RADIOMETRY_TAUX_PARAMS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAUXPARAMS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_RADIOMETRY_TAUX_PARAMS_T outVal; byteToFLR_RADIOMETRY_TAUX_PARAMS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_TAUX_PARAMS_T)outVal; inPtr+=16; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTAuxParams() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_tAux(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_TAUX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_tAux() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_tAux(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_TAUX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_tAux() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_tAux(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_TAUX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_tAux() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_tAux(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_TAUX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_tAux() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTsource_FFC(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTSOURCE_FFC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTsource_FFC() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTsource_FFC(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTSOURCE_FFC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTsource_FFC() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_h(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_DTfpa_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_h(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_DTfpa_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_h(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetOffset_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_h(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetOffset_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_h(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Recursive_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_h(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Recursive_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_DTfpa_Sh_p(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DTFPA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_DTfpa_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_DTfpa_Sh_p(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DTFPA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_DTfpa_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetOffset_Sh_p(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetOffset_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetOffset_Sh_p(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetOffset_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Recursive_Sh_p(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_RECURSIVE_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Recursive_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Recursive_Sh_p(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_RECURSIVE_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Recursive_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDTTFPAK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetDtTfpaK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetDtTfpaK_Damp(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDTTFPAK_DAMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetDtTfpaK_Damp() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTAuxK(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTAUXK, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTAuxK() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetExternalFfcUpdateMode(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEXTERNALFFCUPDATEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetExternalFfcUpdateMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetExternalFfcUpdateMode(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEXTERNALFFCUPDATEMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetExternalFfcUpdateMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGG_scale(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGG_scale() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempWindow(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempWindow(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTransmissionWindow(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTRANSMISSIONWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTransmissionWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTransmissionWindow(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTRANSMISSIONWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTransmissionWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetReflectivityWindow(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETREFLECTIVITYWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetReflectivityWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetReflectivityWindow(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETREFLECTIVITYWINDOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetReflectivityWindow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempWindowReflection(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPWINDOWREFLECTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempWindowReflection() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempWindowReflection(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPWINDOWREFLECTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempWindowReflection() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTransmissionAtmosphere(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTRANSMISSIONATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTransmissionAtmosphere() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTransmissionAtmosphere(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTRANSMISSIONATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTransmissionAtmosphere() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempAtmosphere(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempAtmosphere() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempAtmosphere(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPATMOSPHERE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempAtmosphere() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetEmissivityTarget(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETEMISSIVITYTARGET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetEmissivityTarget() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetEmissivityTarget(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETEMISSIVITYTARGET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetEmissivityTarget() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTempBackground(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPBACKGROUND, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTempBackground() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTempBackground(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPBACKGROUND, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTempBackground() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRadiometryCapable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRADIOMETRYCAPABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRadiometryCapable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingFactor(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetdeltaTempDampingFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingFactor(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPDAMPINGFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetdeltaTempDampingFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempIntervalTime(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPINTERVALTIME, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetdeltaTempIntervalTime() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempIntervalTime(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPINTERVALTIME, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetdeltaTempIntervalTime() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxValue(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetdeltaTempMaxValue() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxValue(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPMAXVALUE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetdeltaTempMaxValue() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempMaxIncrement(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPMAXINCREMENT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetdeltaTempMaxIncrement() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempMaxIncrement(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPMAXINCREMENT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetdeltaTempMaxIncrement() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetdeltaTempDampingTime(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETDELTATEMPDAMPINGTIME, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetdeltaTempDampingTime() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetdeltaTempDampingTime(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETDELTATEMPDAMPINGTIME, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetdeltaTempDampingTime() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetResponsivityFpaTemp(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRESPONSIVITYFPATEMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetResponsivityFpaTemp() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Lens() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGG_SCALE_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetGG_Scale_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGG_Scale_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetGG_Scale_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETGG_SCALE_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetGG_Scale_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGG_Scale_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_SCALE_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGG_Scale_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetRbfoScaledMode(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETRBFOSCALEDMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetRbfoScaledMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetRbfoScaledMode(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETRBFOSCALEDMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetRbfoScaledMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyFactor(FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETUNCERTAINTYFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_RADIOMETRY_UNCERTAINTY_FACTOR_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetUncertaintyFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTRoomMinThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTROOMMINTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTRoomMinThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTRoomMaxThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTROOMMAXTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTRoomMaxThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMinThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTOPERATINGMINTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTOperatingMinThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTOperatingMaxThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTOPERATINGMAXTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTOperatingMaxThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetStableTempThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSTABLETEMPTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetStableTempThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetSlowDriftThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETSLOWDRIFTTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetSlowDriftThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetFfcTempThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETFFCTEMPTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetFfcTempThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshLG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMINTHRESHLG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTargetTempMinThreshLG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshLG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMAXTHRESHLG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTargetTempMaxThreshLG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetMFactorThresh(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETMFACTORTHRESH, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetMFactorThresh() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMinThreshHG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMINTHRESHHG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTargetTempMinThreshHG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTargetTempMaxThreshHG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTARGETTEMPMAXTHRESHHG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTargetTempMaxThreshHG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetUncertaintyStatusBits(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETUNCERTAINTYSTATUSBITS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetUncertaintyStatusBits() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPERATUREOFFSET_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTemperatureOffset_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPERATUREOFFSET_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTemperatureOffset_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetTemperatureOffset_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETTEMPERATUREOFFSET_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetTemperatureOffset_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetTemperatureOffset_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETTEMPERATUREOFFSET_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetTemperatureOffset_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Lens_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Lens_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Lens_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Lens_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetOffset_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetOffset_Lens_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetOffset_Lens_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETOFFSET_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetOffset_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetOffset_Lens_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETOFFSET_LENS_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetOffset_Lens_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_p_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_p_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_p_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_P_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_p_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H_HG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h_HG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETM_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetM_Delta_Sh_h_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETM_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetM_Delta_Sh_h_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_SETB_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRadiometrySetB_Delta_Sh_h_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETB_DELTA_SH_H_LG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetB_Delta_Sh_h_LG() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRadiometryGetGG_RoomTemp(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, RADIOMETRY_GETGG_ROOMTEMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRadiometryGetGG_RoomTemp() // End Module: radiometry // Begin Module: roic // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPATemp(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPATemp() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFrameCount(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFRAMECOUNT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFrameCount() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetActiveNormalizationTarget(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETACTIVENORMALIZATIONTARGET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetActiveNormalizationTarget() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFPARampState(const FLR_ENABLE_E state) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write state to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = state; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPARAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFPARampState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPARampState(FLR_ENABLE_E *state) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPARAMPSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read state from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *state = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of state handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPARampState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetSensorADC1(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETSENSORADC1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetSensorADC1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetSensorADC2(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETSENSORADC2, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetSensorADC2() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFPATempOffset(const int16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = data; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFPATempOffset() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPATempOffset(int16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPOFFSET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *data = (int16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPATempOffset() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ROIC_TEMP_MODE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFPATempMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ROIC_TEMP_MODE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPATempMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 64; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPTABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read table from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ROIC_FPATEMP_TABLE_T outVal; byteToFLR_ROIC_FPATEMP_TABLE_T( (const uint8_t *) inPtr, &outVal); *table = (FLR_ROIC_FPATEMP_TABLE_T)outVal; inPtr+=64; }// end of table handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPATempTable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFPATempValue(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFPATEMPVALUE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFPATempValue() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFPATempValue(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFPATEMPVALUE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFPATempValue() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetPreambleError(uint32_t *preambleError) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETPREAMBLEERROR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read preambleError from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *preambleError = (uint32_t)outVal; inPtr+=4; }// end of preambleError handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetPreambleError() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicInducePreambleError(const uint32_t everyNthFrame) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write everyNthFrame to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = everyNthFrame; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_INDUCEPREAMBLEERROR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicInducePreambleError() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetRoicStarted(FLR_ENABLE_E *roicStarted) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETROICSTARTED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read roicStarted from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *roicStarted = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of roicStarted handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetRoicStarted() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFrameSkip(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFRAMESKIP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFrameSkip() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicGetFrameSkip(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_GETFRAMESKIP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgRoicGetFrameSkip() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgRoicSetFrameOneShot() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, ROIC_SETFRAMEONESHOT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgRoicSetFrameOneShot() // End Module: roic // Begin Module: scaler // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScalerGetMaxZoom(uint32_t *zoom) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_GETMAXZOOM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read zoom from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *zoom = (uint32_t)outVal; inPtr+=4; }// end of zoom handling return R_SUCCESS; }// End of CLIENT_pkgScalerGetMaxZoom() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 12; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write zoomParams to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SCALER_ZOOM_PARAMS_T *inVal = (const FLR_SCALER_ZOOM_PARAMS_T *) &zoomParams; FLR_SCALER_ZOOM_PARAMS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 12; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETZOOM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScalerSetZoom() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 12; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_GETZOOM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read zoomParams from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SCALER_ZOOM_PARAMS_T outVal; byteToFLR_SCALER_ZOOM_PARAMS_T( (const uint8_t *) inPtr, &outVal); *zoomParams = (FLR_SCALER_ZOOM_PARAMS_T)outVal; inPtr+=12; }// end of zoomParams handling return R_SUCCESS; }// End of CLIENT_pkgScalerGetZoom() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScalerSetFractionalZoom(const uint32_t zoomNumerator, const uint32_t zoomDenominator, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 32; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write zoomNumerator to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomNumerator; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomDenominator to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomDenominator; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomXCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomXCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomYCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomYCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write inChangeEnable to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = inChangeEnable; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomOutXCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomOutXCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomOutYCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomOutYCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write outChangeEnable to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = outChangeEnable; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETFRACTIONALZOOM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScalerSetFractionalZoom() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScalerSetIndexZoom(const uint32_t zoomIndex, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 28; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write zoomIndex to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomIndex; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomXCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomXCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomYCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomYCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write inChangeEnable to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = inChangeEnable; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomOutXCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomOutXCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write zoomOutYCenter to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = zoomOutYCenter; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write outChangeEnable to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = outChangeEnable; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCALER_SETINDEXZOOM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScalerSetIndexZoom() // End Module: scaler // Begin Module: scnr // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetThColSum(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHCOLSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetThColSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetThColSum(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHCOLSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetThColSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetThPixel(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetThPixel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetThPixel(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetThPixel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetMaxCorr(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetMaxCorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetMaxCorr(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetMaxCorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetThPixelApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXELAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetThPixelApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetMaxCorrApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORRAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetMaxCorrApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetThColSumSafe(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHCOLSUMSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetThColSumSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetThColSumSafe(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHCOLSUMSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetThColSumSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetThPixelSafe(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETTHPIXELSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetThPixelSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetThPixelSafe(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETTHPIXELSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetThPixelSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetMaxCorrSafe(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETMAXCORRSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetMaxCorrSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetMaxCorrSafe(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMAXCORRSAFE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetMaxCorrSafe() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetCorrectionMethod(const FLR_SCNR_CORR_SELECT_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SCNR_CORR_SELECT_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETCORRECTIONMETHOD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetCorrectionMethod() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetCorrectionMethod(FLR_SCNR_CORR_SELECT_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETCORRECTIONMETHOD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SCNR_CORR_SELECT_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetCorrectionMethod() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetStdThreshold(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSTDTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetStdThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetStdThreshold(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSTDTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetStdThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetNFrames(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETNFRAMES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetNFrames() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetNFrames(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETNFRAMES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetNFrames() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetResetDesired(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetResetDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetResetDesired(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetResetDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetM_modeOnly(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETM_MODEONLY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetM_modeOnly() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetM_modeOnly(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETM_MODEONLY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetM_modeOnly() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetMode(FLR_SCNR_MODE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SCNR_MODE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetSpecklesEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetSpecklesEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetSpecklesThreshold(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetSpecklesThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesThreshold(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetSpecklesRatio(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESRATIO, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetSpecklesRatio() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesRatio(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESRATIO, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesRatio() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetSpecklesDF(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESDF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetSpecklesDF() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesDF(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESDF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesDF() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesDiffsBufferAddr(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESDIFFSBUFFERADDR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesDiffsBufferAddr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesOffsBufferAddr(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESOFFSBUFFERADDR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesOffsBufferAddr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrSetSpecklesResetDesired(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_SETSPECKLESRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgScnrSetSpecklesResetDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgScnrGetSpecklesResetDesired(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SCNR_GETSPECKLESRESETDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgScnrGetSpecklesResetDesired() // End Module: scnr // Begin Module: sffc // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetScaleFactor(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETSCALEFACTOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetScaleFactor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetDeltaTempLinearCoeff(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetDeltaTempLinearCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcSetDeltaTempLinearCoeff(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSffcSetDeltaTempLinearCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetDeltaTempOffsetCoeff(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetDeltaTempOffsetCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcSetDeltaTempOffsetCoeff(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSffcSetDeltaTempOffsetCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetFpaTempLinearCoeff(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETFPATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetFpaTempLinearCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcSetFpaTempLinearCoeff(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETFPATEMPLINEARCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSffcSetFpaTempLinearCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetFpaTempOffsetCoeff(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETFPATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetFpaTempOffsetCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcSetFpaTempOffsetCoeff(const float data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = data; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETFPATEMPOFFSETCOEFF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSffcSetFpaTempOffsetCoeff() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_GETDELTATEMPTIMELIMITINSECS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSffcGetDeltaTempTimeLimitInSecs() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SFFC_SETDELTATEMPTIMELIMITINSECS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSffcSetDeltaTempTimeLimitInSecs() // End Module: sffc // Begin Module: spnr // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetState(FLR_SPNR_STATE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SPNR_STATE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetFrameDelay(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETFRAMEDELAY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetFrameDelay() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetFrameDelay(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETFRAMEDELAY, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetFrameDelay() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetSF(const float sf) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write sf to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = sf; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetSF() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetSF(float *sf) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read sf from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *sf = (float)outVal; inPtr+=4; }// end of sf handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetSF() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetSFApplied(float *sf) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read sf from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *sf = (float)outVal; inPtr+=4; }// end of sf handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetSFApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 256; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SPNR_PSD_KERNEL_T *inVal = (const FLR_SPNR_PSD_KERNEL_T *) &data; FLR_SPNR_PSD_KERNEL_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 256; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETPSDKERNEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetPSDKernel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 256; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETPSDKERNEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SPNR_PSD_KERNEL_T outVal; byteToFLR_SPNR_PSD_KERNEL_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_SPNR_PSD_KERNEL_T)outVal; inPtr+=256; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetPSDKernel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetSFMin(const float sfmin) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write sfmin to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = sfmin; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSFMIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetSFMin() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetSFMin(float *sfmin) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFMIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read sfmin from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *sfmin = (float)outVal; inPtr+=4; }// end of sfmin handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetSFMin() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetSFMax(const float sfmax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write sfmax to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = sfmax; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSFMAX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetSFMax() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetSFMax(float *sfmax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSFMAX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read sfmax from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *sfmax = (float)outVal; inPtr+=4; }// end of sfmax handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetSFMax() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetDFMin(const float dfmin) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write dfmin to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = dfmin; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFMIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetDFMin() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetDFMin(float *dfmin) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFMIN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read dfmin from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *dfmin = (float)outVal; inPtr+=4; }// end of dfmin handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetDFMin() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetDFMax(const float dfmax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write dfmax to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = dfmax; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFMAX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetDFMax() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetDFMax(float *dfmax) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFMAX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read dfmax from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *dfmax = (float)outVal; inPtr+=4; }// end of dfmax handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetDFMax() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetNormTarget(const float normTarget) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write normTarget to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = normTarget; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETNORMTARGET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetNormTarget() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetNormTarget(float *normTarget) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETNORMTARGET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read normTarget from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *normTarget = (float)outVal; inPtr+=4; }// end of normTarget handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetNormTarget() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetNormTargetApplied(float *normTargetApplied) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETNORMTARGETAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read normTargetApplied from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *normTargetApplied = (float)outVal; inPtr+=4; }// end of normTargetApplied handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetNormTargetApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetThPix(const uint16_t th_pix) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write th_pix to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = th_pix; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETTHPIX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetThPix() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetThPix(uint16_t *th_pix) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETTHPIX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read th_pix from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *th_pix = (uint16_t)outVal; inPtr+=2; }// end of th_pix handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetThPix() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetThPixSum(const uint16_t th_pixSum) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write th_pixSum to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = th_pixSum; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETTHPIXSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetThPixSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetThPixSum(uint16_t *th_pixSum) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETTHPIXSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read th_pixSum from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *th_pixSum = (uint16_t)outVal; inPtr+=2; }// end of th_pixSum handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetThPixSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetMaxcorr(const uint16_t maxcorr) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write maxcorr to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = maxcorr; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetMaxcorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetMaxcorr(uint16_t *maxcorr) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read maxcorr from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *maxcorr = (uint16_t)outVal; inPtr+=2; }// end of maxcorr handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetMaxcorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetAlgorithm(FLR_SPNR_ALGORITHM_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETALGORITHM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SPNR_ALGORITHM_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetAlgorithm() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetAlgorithmDesired(const FLR_SPNR_ALGORITHM_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SPNR_ALGORITHM_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETALGORITHMDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetAlgorithmDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetAlgorithmDesired(FLR_SPNR_ALGORITHM_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETALGORITHMDESIRED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SPNR_ALGORITHM_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetAlgorithmDesired() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetDFFast(const float dffast) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write dffast to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = dffast; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFFAST, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetDFFast() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetDFFast(float *dffast) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFFAST, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read dffast from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *dffast = (float)outVal; inPtr+=4; }// end of dffast handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetDFFast() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetDFSlow(const float dfslow) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write dfslow to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = dfslow; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETDFSLOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetDFSlow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetDFSlow(float *dfslow) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETDFSLOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read dfslow from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *dfslow = (float)outVal; inPtr+=4; }// end of dfslow handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetDFSlow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetSensitivityThreshold(const float threshold) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write threshold to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = threshold; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETSENSITIVITYTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetSensitivityThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrGetSensitivityThreshold(float *threshold) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_GETSENSITIVITYTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read threshold from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *threshold = (float)outVal; inPtr+=4; }// end of threshold handling return R_SUCCESS; }// End of CLIENT_pkgSpnrGetSensitivityThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpnrSetReset(const FLR_SPNR_RESET_E resetType) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write resetType to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SPNR_RESET_E inVal = resetType; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPNR_SETRESET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpnrSetReset() // End Module: spnr // Begin Module: spotMeter // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterSetEnable(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpotmeterSetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetEnable(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetRoiMaxSize(uint16_t *width, uint16_t *height) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETROIMAXSIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read width from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *width = (uint16_t)outVal; inPtr+=2; }// end of width handling // read height from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *height = (uint16_t)outVal; inPtr+=2; }// end of height handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetRoiMaxSize() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterSetRoi(const FLR_ROI_T roi) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 8; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write roi to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ROI_T *inVal = (const FLR_ROI_T *) &roi; FLR_ROI_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 8; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETROI, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpotmeterSetRoi() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetRoi(FLR_ROI_T *roi) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 8; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETROI, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read roi from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_ROI_T outVal; byteToFLR_ROI_T( (const uint8_t *) inPtr, &outVal); *roi = (FLR_ROI_T)outVal; inPtr+=8; }// end of roi handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetRoi() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetSpotStats(uint16_t *mean, uint16_t *deviation, FLR_SPOTMETER_SPOT_PARAM_T *min, FLR_SPOTMETER_SPOT_PARAM_T *max) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 16; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETSPOTSTATS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read mean from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *mean = (uint16_t)outVal; inPtr+=2; }// end of mean handling // read deviation from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *deviation = (uint16_t)outVal; inPtr+=2; }// end of deviation handling // read min from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SPOTMETER_SPOT_PARAM_T outVal; byteToFLR_SPOTMETER_SPOT_PARAM_T( (const uint8_t *) inPtr, &outVal); *min = (FLR_SPOTMETER_SPOT_PARAM_T)outVal; inPtr+=6; }// end of min handling // read max from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SPOTMETER_SPOT_PARAM_T outVal; byteToFLR_SPOTMETER_SPOT_PARAM_T( (const uint8_t *) inPtr, &outVal); *max = (FLR_SPOTMETER_SPOT_PARAM_T)outVal; inPtr+=6; }// end of max handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetSpotStats() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterSetStatsMode(const FLR_SPOTMETER_STATS_TEMP_MODE_E mode) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write mode to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SPOTMETER_STATS_TEMP_MODE_E inVal = mode; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_SETSTATSMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSpotmeterSetStatsMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetStatsMode(FLR_SPOTMETER_STATS_TEMP_MODE_E *mode) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETSTATSMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read mode from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *mode = (FLR_SPOTMETER_STATS_TEMP_MODE_E)outVal; inPtr+=4; }// end of mode handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetStatsMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSpotmeterGetTempStats(float *mean, float *deviation, FLR_SPOTMETER_STAT_PARAM_TEMP_T *min, FLR_SPOTMETER_STAT_PARAM_TEMP_T *max) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 24; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SPOTMETER_GETTEMPSTATS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read mean from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *mean = (float)outVal; inPtr+=4; }// end of mean handling // read deviation from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *deviation = (float)outVal; inPtr+=4; }// end of deviation handling // read min from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SPOTMETER_STAT_PARAM_TEMP_T outVal; byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T( (const uint8_t *) inPtr, &outVal); *min = (FLR_SPOTMETER_STAT_PARAM_TEMP_T)outVal; inPtr+=8; }// end of min handling // read max from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SPOTMETER_STAT_PARAM_TEMP_T outVal; byteToFLR_SPOTMETER_STAT_PARAM_TEMP_T( (const uint8_t *) inPtr, &outVal); *max = (FLR_SPOTMETER_STAT_PARAM_TEMP_T)outVal; inPtr+=8; }// end of max handling return R_SUCCESS; }// End of CLIENT_pkgSpotmeterGetTempStats() // End Module: spotMeter // Begin Module: srnr // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrSetEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSrnrSetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrSetThRowSum(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETTHROWSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSrnrSetThRowSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetThRowSum(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHROWSUM, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetThRowSum() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrSetThPixel(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSrnrSetThPixel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetThPixel(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHPIXEL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetThPixel() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrSetMaxCorr(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_SETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSrnrSetMaxCorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetMaxCorr(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETMAXCORR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetMaxCorr() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetThPixelApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETTHPIXELAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetThPixelApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSrnrGetMaxCorrApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SRNR_GETMAXCORRAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSrnrGetMaxCorrApplied() // End Module: srnr // Begin Module: symbology // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySetEnable(const FLR_ENABLE_E draw_symbols) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write draw_symbols to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = draw_symbols; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 9; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateBitmap() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[]) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 131; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write size to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = size; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write text to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SENDDATA, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySendData() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateArc(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const float start_angle, const float end_angle, const uint32_t color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 21; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write start_angle to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = start_angle; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write end_angle to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const float inVal = end_angle; FLOATToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEARC, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateArc() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateText(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint8_t text[]) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 146; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write font to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int8_t inVal = font; CHARToByte(inVal, (const uint8_t *) outPtr ); outPtr += 1; } //write size to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = size; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write alignment to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write text to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateText() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 5; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVESPRITE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyMoveSprite() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyAddToGroup(const uint8_t ID, const uint8_t group_ID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write group_ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = group_ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_ADDTOGROUP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyAddToGroup() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write group_ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = group_ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_REMOVEFROMGROUP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyRemoveFromGroup() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyUpdateAndShow(const uint8_t ID, const uint8_t visible) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write visible to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = visible; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEANDSHOW, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyUpdateAndShow() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write group_ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = group_ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write visible to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = visible; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEANDSHOWGROUP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyUpdateAndShowGroup() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyDelete(const uint8_t ID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_DELETE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyDelete() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyDeleteGroup(const uint8_t group_ID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write group_ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = group_ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_DELETEGROUP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyDeleteGroup() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateFilledRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEFILLEDRECTANGLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateFilledRectangle() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateOutlinedRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEOUTLINEDRECTANGLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateOutlinedRectangle() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 7; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write size to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = size; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMPNG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateBitmapFromPng() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateCompressedBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 9; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATECOMPRESSEDBITMAP, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateCompressedBitmap() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[]) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 133; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write path to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMPNGFILE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateBitmapFromPngFile() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 135; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write path to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } //write imageType to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_IMAGE_TYPE_E inVal = imageType; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEBITMAPFROMFILE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateBitmapFromFile() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyResetWritePosition(const uint8_t ID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_RESETWRITEPOSITION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyResetWritePosition() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 5; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write off_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = off_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write off_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = off_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVEBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyMoveByOffset() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 5; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write off_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = off_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write off_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = off_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVEGROUPBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyMoveGroupByOffset() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateFilledEllipse(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATEFILLEDELLIPSE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateFilledEllipse() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateLine(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_X2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X2; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y2; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATELINE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateLine() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySetZorder(const uint8_t ID, const uint8_t zorder) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write zorder to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = zorder; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETZORDER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySetZorder() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySaveConfiguration() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SAVECONFIGURATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySaveConfiguration() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyReloadConfiguration() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_RELOADCONFIGURATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyReloadConfiguration() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetEnable(FLR_ENABLE_E *draw_symbols) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read draw_symbols from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *draw_symbols = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of draw_symbols handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write numberOfClones to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = numberOfClones; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETCLONESNUMBER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySetClonesNumber() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 6; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write cloneID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = cloneID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVECLONEBYOFFSET, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyMoveCloneByOffset() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 6; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write cloneID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = cloneID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_MOVECLONESPRITE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyMoveCloneSprite() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySetTransformation(const FLR_SYMBOLOGY_TRANSFORMATION_E transformation) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write transformation to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_TRANSFORMATION_E inVal = transformation; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETTRANSFORMATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySetTransformation() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyUpdateAllVisible() { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_UPDATEALLVISIBLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyUpdateAllVisible() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologySetSizeAndScalingMode(const uint8_t ID, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 7; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write scalingMode to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_SCALING_MODE_E inVal = scalingMode; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_SETSIZEANDSCALINGMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologySetSizeAndScalingMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateLineHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color1, const uint32_t color2, const uint16_t dashLen, const uint16_t thickness) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 21; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_X2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X2; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y2; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color1 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color1; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write color2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color2; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write dashLen to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = dashLen; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write thickness to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = thickness; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATELINEHVT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateLineHVT() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateTextHVT(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color1, const uint32_t color2, const uint8_t dashLen, const uint8_t text[]) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 151; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write font to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int8_t inVal = font; CHARToByte(inVal, (const uint8_t *) outPtr ); outPtr += 1; } //write size to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = size; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write alignment to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color1 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color1; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write color2 to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color2; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write dashLen to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = dashLen; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write text to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXTHVT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateTextHVT() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateTextBg(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint32_t bgColor, const uint8_t text[]) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 150; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write font to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int8_t inVal = font; CHARToByte(inVal, (const uint8_t *) outPtr ); outPtr += 1; } //write size to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = size; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write alignment to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E inVal = alignment; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write color to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = color; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write bgColor to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = bgColor; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write text to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {text[0], text[1], text[2], text[3], text[4], text[5], text[6], text[7], text[8], text[9], text[10], text[11], text[12], text[13], text[14], text[15], text[16], text[17], text[18], text[19], text[20], text[21], text[22], text[23], text[24], text[25], text[26], text[27], text[28], text[29], text[30], text[31], text[32], text[33], text[34], text[35], text[36], text[37], text[38], text[39], text[40], text[41], text[42], text[43], text[44], text[45], text[46], text[47], text[48], text[49], text[50], text[51], text[52], text[53], text[54], text[55], text[56], text[57], text[58], text[59], text[60], text[61], text[62], text[63], text[64], text[65], text[66], text[67], text[68], text[69], text[70], text[71], text[72], text[73], text[74], text[75], text[76], text[77], text[78], text[79], text[80], text[81], text[82], text[83], text[84], text[85], text[86], text[87], text[88], text[89], text[90], text[91], text[92], text[93], text[94], text[95], text[96], text[97], text[98], text[99], text[100], text[101], text[102], text[103], text[104], text[105], text[106], text[107], text[108], text[109], text[110], text[111], text[112], text[113], text[114], text[115], text[116], text[117], text[118], text[119], text[120], text[121], text[122], text[123], text[124], text[125], text[126], text[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATETEXTBG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateTextBg() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCreateScaledBitmapFromFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const FLR_SYMBOLOGY_SCALING_MODE_E scalingMode, const uint8_t path[], const FLR_SYMBOLOGY_IMAGE_TYPE_E imageType) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 141; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write pos_X to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_X; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write pos_Y to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = pos_Y; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write width to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = width; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write height to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const int16_t inVal = height; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write scalingMode to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_SCALING_MODE_E inVal = scalingMode; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } //write path to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal[] = {path[0], path[1], path[2], path[3], path[4], path[5], path[6], path[7], path[8], path[9], path[10], path[11], path[12], path[13], path[14], path[15], path[16], path[17], path[18], path[19], path[20], path[21], path[22], path[23], path[24], path[25], path[26], path[27], path[28], path[29], path[30], path[31], path[32], path[33], path[34], path[35], path[36], path[37], path[38], path[39], path[40], path[41], path[42], path[43], path[44], path[45], path[46], path[47], path[48], path[49], path[50], path[51], path[52], path[53], path[54], path[55], path[56], path[57], path[58], path[59], path[60], path[61], path[62], path[63], path[64], path[65], path[66], path[67], path[68], path[69], path[70], path[71], path[72], path[73], path[74], path[75], path[76], path[77], path[78], path[79], path[80], path[81], path[82], path[83], path[84], path[85], path[86], path[87], path[88], path[89], path[90], path[91], path[92], path[93], path[94], path[95], path[96], path[97], path[98], path[99], path[100], path[101], path[102], path[103], path[104], path[105], path[106], path[107], path[108], path[109], path[110], path[111], path[112], path[113], path[114], path[115], path[116], path[117], path[118], path[119], path[120], path[121], path[122], path[123], path[124], path[125], path[126], path[127]}; UCHARArrayToByte(inVal, (uint16_t) 128, (const uint8_t *) outPtr); outPtr += 128; } //write imageType to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYMBOLOGY_IMAGE_TYPE_E inVal = imageType; INT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_CREATESCALEDBITMAPFROMFILE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCreateScaledBitmapFromFile() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetLocation(const uint8_t ID, int16_t *pos_X, int16_t *pos_Y) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read pos_X from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *pos_X = (int16_t)outVal; inPtr+=2; }// end of pos_X handling // read pos_Y from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *pos_Y = (int16_t)outVal; inPtr+=2; }// end of pos_Y handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetLocation() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetSize(const uint8_t ID, int16_t *width, int16_t *height) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETSIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read width from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *width = (int16_t)outVal; inPtr+=2; }// end of width handling // read height from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *height = (int16_t)outVal; inPtr+=2; }// end of height handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetSize() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetZorder(const uint8_t ID, uint8_t *zorder) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETZORDER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read zorder from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal; byteToUCHAR( (const uint8_t *) inPtr, &outVal); *zorder = (uint8_t)outVal; inPtr+=1; }// end of zorder handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetZorder() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetColor(const uint8_t ID, uint32_t *color) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETCOLOR, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read color from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *color = (uint32_t)outVal; inPtr+=4; }// end of color handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetColor() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetType(const uint8_t ID, FLR_SYMBOLOGY_TYPE_E *type) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read type from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *type = (FLR_SYMBOLOGY_TYPE_E)outVal; inPtr+=2; }// end of type handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetType() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyCopySymbol(const uint8_t source, const uint8_t destination) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write source to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = source; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write destination to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = destination; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_COPYSYMBOL, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSymbologyCopySymbol() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSymbologyGetTextFontSize(const uint8_t ID, int16_t *size) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write ID to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = ID; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYMBOLOGY_GETTEXTFONTSIZE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read size from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int16_t outVal; byteToINT_16( (const uint8_t *) inPtr, &outVal); *size = (int16_t)outVal; inPtr+=2; }// end of size handling return R_SUCCESS; }// End of CLIENT_pkgSymbologyGetTextFontSize() // End Module: symbology // Begin Module: sysctrl // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlSetFreezeState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETFREEZESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSysctrlSetFreezeState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetFreezeState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETFREEZESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetFreezeState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetCameraFrameRate(uint32_t *frameRate) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETCAMERAFRAMERATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read frameRate from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *frameRate = (uint32_t)outVal; inPtr+=4; }// end of frameRate handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetCameraFrameRate() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetUptimeSecs(uint32_t *uptime) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETUPTIMESECS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read uptime from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *uptime = (uint32_t)outVal; inPtr+=4; }// end of uptime handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetUptimeSecs() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlSetUsbVideoIR16Mode(const FLR_SYSCTRL_USBIR16_MODE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSCTRL_USBIR16_MODE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETUSBVIDEOIR16MODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSysctrlSetUsbVideoIR16Mode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetUsbVideoIR16Mode(FLR_SYSCTRL_USBIR16_MODE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETUSBVIDEOIR16MODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SYSCTRL_USBIR16_MODE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetUsbVideoIR16Mode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlSetOperatingMode(const FLR_SYSCTRL_OPERATING_MODE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSCTRL_OPERATING_MODE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETOPERATINGMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSysctrlSetOperatingMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetOperatingMode(FLR_SYSCTRL_OPERATING_MODE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETOPERATINGMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_SYSCTRL_OPERATING_MODE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetOperatingMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetAvgFpaTempCounts(float *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETAVGFPATEMPCOUNTS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } float outVal; byteToFLOAT( (const uint8_t *) inPtr, &outVal); *data = (float)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetAvgFpaTempCounts() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlSetFpaTempFrames(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_SETFPATEMPFRAMES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSysctrlSetFpaTempFrames() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysctrlGetFpaTempFrames(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSCTRL_GETFPATEMPFRAMES, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgSysctrlGetFpaTempFrames() // End Module: sysctrl // Begin Module: sysinfo // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetMonitorSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 12; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORSOFTWAREREV, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read major from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *major = (uint32_t)outVal; inPtr+=4; }// end of major handling // read minor from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *minor = (uint32_t)outVal; inPtr+=4; }// end of minor handling // read patch from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *patch = (uint32_t)outVal; inPtr+=4; }// end of patch handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetMonitorSoftwareRev() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetMonitorBuildVariant(FLR_SYSINFO_MONITOR_BUILD_VARIANT_T *monitorBuildVariant) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 50; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORBUILDVARIANT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read monitorBuildVariant from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSINFO_MONITOR_BUILD_VARIANT_T outVal; byteToFLR_SYSINFO_MONITOR_BUILD_VARIANT_T( (const uint8_t *) inPtr, &outVal); *monitorBuildVariant = (FLR_SYSINFO_MONITOR_BUILD_VARIANT_T)outVal; inPtr+=50; }// end of monitorBuildVariant handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetMonitorBuildVariant() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetProductName(uint8_t *name) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 128; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPRODUCTNAME, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read name from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal[128]; byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); name[0] = outVal[0]; name[1] = outVal[1]; name[2] = outVal[2]; name[3] = outVal[3]; name[4] = outVal[4]; name[5] = outVal[5]; name[6] = outVal[6]; name[7] = outVal[7]; name[8] = outVal[8]; name[9] = outVal[9]; name[10] = outVal[10]; name[11] = outVal[11]; name[12] = outVal[12]; name[13] = outVal[13]; name[14] = outVal[14]; name[15] = outVal[15]; name[16] = outVal[16]; name[17] = outVal[17]; name[18] = outVal[18]; name[19] = outVal[19]; name[20] = outVal[20]; name[21] = outVal[21]; name[22] = outVal[22]; name[23] = outVal[23]; name[24] = outVal[24]; name[25] = outVal[25]; name[26] = outVal[26]; name[27] = outVal[27]; name[28] = outVal[28]; name[29] = outVal[29]; name[30] = outVal[30]; name[31] = outVal[31]; name[32] = outVal[32]; name[33] = outVal[33]; name[34] = outVal[34]; name[35] = outVal[35]; name[36] = outVal[36]; name[37] = outVal[37]; name[38] = outVal[38]; name[39] = outVal[39]; name[40] = outVal[40]; name[41] = outVal[41]; name[42] = outVal[42]; name[43] = outVal[43]; name[44] = outVal[44]; name[45] = outVal[45]; name[46] = outVal[46]; name[47] = outVal[47]; name[48] = outVal[48]; name[49] = outVal[49]; name[50] = outVal[50]; name[51] = outVal[51]; name[52] = outVal[52]; name[53] = outVal[53]; name[54] = outVal[54]; name[55] = outVal[55]; name[56] = outVal[56]; name[57] = outVal[57]; name[58] = outVal[58]; name[59] = outVal[59]; name[60] = outVal[60]; name[61] = outVal[61]; name[62] = outVal[62]; name[63] = outVal[63]; name[64] = outVal[64]; name[65] = outVal[65]; name[66] = outVal[66]; name[67] = outVal[67]; name[68] = outVal[68]; name[69] = outVal[69]; name[70] = outVal[70]; name[71] = outVal[71]; name[72] = outVal[72]; name[73] = outVal[73]; name[74] = outVal[74]; name[75] = outVal[75]; name[76] = outVal[76]; name[77] = outVal[77]; name[78] = outVal[78]; name[79] = outVal[79]; name[80] = outVal[80]; name[81] = outVal[81]; name[82] = outVal[82]; name[83] = outVal[83]; name[84] = outVal[84]; name[85] = outVal[85]; name[86] = outVal[86]; name[87] = outVal[87]; name[88] = outVal[88]; name[89] = outVal[89]; name[90] = outVal[90]; name[91] = outVal[91]; name[92] = outVal[92]; name[93] = outVal[93]; name[94] = outVal[94]; name[95] = outVal[95]; name[96] = outVal[96]; name[97] = outVal[97]; name[98] = outVal[98]; name[99] = outVal[99]; name[100] = outVal[100]; name[101] = outVal[101]; name[102] = outVal[102]; name[103] = outVal[103]; name[104] = outVal[104]; name[105] = outVal[105]; name[106] = outVal[106]; name[107] = outVal[107]; name[108] = outVal[108]; name[109] = outVal[109]; name[110] = outVal[110]; name[111] = outVal[111]; name[112] = outVal[112]; name[113] = outVal[113]; name[114] = outVal[114]; name[115] = outVal[115]; name[116] = outVal[116]; name[117] = outVal[117]; name[118] = outVal[118]; name[119] = outVal[119]; name[120] = outVal[120]; name[121] = outVal[121]; name[122] = outVal[122]; name[123] = outVal[123]; name[124] = outVal[124]; name[125] = outVal[125]; name[126] = outVal[126]; name[127] = outVal[127]; inPtr+=128; }// end of name handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetProductName() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetCameraSN(uint8_t *number) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 128; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETCAMERASN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read number from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal[128]; byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); number[0] = outVal[0]; number[1] = outVal[1]; number[2] = outVal[2]; number[3] = outVal[3]; number[4] = outVal[4]; number[5] = outVal[5]; number[6] = outVal[6]; number[7] = outVal[7]; number[8] = outVal[8]; number[9] = outVal[9]; number[10] = outVal[10]; number[11] = outVal[11]; number[12] = outVal[12]; number[13] = outVal[13]; number[14] = outVal[14]; number[15] = outVal[15]; number[16] = outVal[16]; number[17] = outVal[17]; number[18] = outVal[18]; number[19] = outVal[19]; number[20] = outVal[20]; number[21] = outVal[21]; number[22] = outVal[22]; number[23] = outVal[23]; number[24] = outVal[24]; number[25] = outVal[25]; number[26] = outVal[26]; number[27] = outVal[27]; number[28] = outVal[28]; number[29] = outVal[29]; number[30] = outVal[30]; number[31] = outVal[31]; number[32] = outVal[32]; number[33] = outVal[33]; number[34] = outVal[34]; number[35] = outVal[35]; number[36] = outVal[36]; number[37] = outVal[37]; number[38] = outVal[38]; number[39] = outVal[39]; number[40] = outVal[40]; number[41] = outVal[41]; number[42] = outVal[42]; number[43] = outVal[43]; number[44] = outVal[44]; number[45] = outVal[45]; number[46] = outVal[46]; number[47] = outVal[47]; number[48] = outVal[48]; number[49] = outVal[49]; number[50] = outVal[50]; number[51] = outVal[51]; number[52] = outVal[52]; number[53] = outVal[53]; number[54] = outVal[54]; number[55] = outVal[55]; number[56] = outVal[56]; number[57] = outVal[57]; number[58] = outVal[58]; number[59] = outVal[59]; number[60] = outVal[60]; number[61] = outVal[61]; number[62] = outVal[62]; number[63] = outVal[63]; number[64] = outVal[64]; number[65] = outVal[65]; number[66] = outVal[66]; number[67] = outVal[67]; number[68] = outVal[68]; number[69] = outVal[69]; number[70] = outVal[70]; number[71] = outVal[71]; number[72] = outVal[72]; number[73] = outVal[73]; number[74] = outVal[74]; number[75] = outVal[75]; number[76] = outVal[76]; number[77] = outVal[77]; number[78] = outVal[78]; number[79] = outVal[79]; number[80] = outVal[80]; number[81] = outVal[81]; number[82] = outVal[82]; number[83] = outVal[83]; number[84] = outVal[84]; number[85] = outVal[85]; number[86] = outVal[86]; number[87] = outVal[87]; number[88] = outVal[88]; number[89] = outVal[89]; number[90] = outVal[90]; number[91] = outVal[91]; number[92] = outVal[92]; number[93] = outVal[93]; number[94] = outVal[94]; number[95] = outVal[95]; number[96] = outVal[96]; number[97] = outVal[97]; number[98] = outVal[98]; number[99] = outVal[99]; number[100] = outVal[100]; number[101] = outVal[101]; number[102] = outVal[102]; number[103] = outVal[103]; number[104] = outVal[104]; number[105] = outVal[105]; number[106] = outVal[106]; number[107] = outVal[107]; number[108] = outVal[108]; number[109] = outVal[109]; number[110] = outVal[110]; number[111] = outVal[111]; number[112] = outVal[112]; number[113] = outVal[113]; number[114] = outVal[114]; number[115] = outVal[115]; number[116] = outVal[116]; number[117] = outVal[117]; number[118] = outVal[118]; number[119] = outVal[119]; number[120] = outVal[120]; number[121] = outVal[121]; number[122] = outVal[122]; number[123] = outVal[123]; number[124] = outVal[124]; number[125] = outVal[125]; number[126] = outVal[126]; number[127] = outVal[127]; inPtr+=128; }// end of number handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetCameraSN() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetBootLocation(uint32_t *bootSwLocation) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETBOOTLOCATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read bootSwLocation from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *bootSwLocation = (uint32_t)outVal; inPtr+=4; }// end of bootSwLocation handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetBootLocation() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetSwConfigID(FLR_SYSINFO_SW_CONFIG_ID_E *swConfigID) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSWCONFIGID, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read swConfigID from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *swConfigID = (FLR_SYSINFO_SW_CONFIG_ID_E)outVal; inPtr+=4; }// end of swConfigID handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetSwConfigID() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetSwPermissions(FLR_SYSINFO_SW_PERMISSIONS_E *swPermissions) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSWPERMISSIONS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read swPermissions from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *swPermissions = (FLR_SYSINFO_SW_PERMISSIONS_E)outVal; inPtr+=4; }// end of swPermissions handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetSwPermissions() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetIs9HzBuild(uint32_t *is9HzBuild) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETIS9HZBUILD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read is9HzBuild from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *is9HzBuild = (uint32_t)outVal; inPtr+=4; }// end of is9HzBuild handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetIs9HzBuild() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetProductVersion(uint32_t *major, uint32_t *minor, uint32_t *patch) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 12; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPRODUCTVERSION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read major from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *major = (uint32_t)outVal; inPtr+=4; }// end of major handling // read minor from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *minor = (uint32_t)outVal; inPtr+=4; }// end of minor handling // read patch from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *patch = (uint32_t)outVal; inPtr+=4; }// end of patch handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetProductVersion() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetMonitorProductRev(uint32_t *major, uint32_t *minor, uint32_t *patch) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 12; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMONITORPRODUCTREV, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read major from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *major = (uint32_t)outVal; inPtr+=4; }// end of major handling // read minor from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *minor = (uint32_t)outVal; inPtr+=4; }// end of minor handling // read patch from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *patch = (uint32_t)outVal; inPtr+=4; }// end of patch handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetMonitorProductRev() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetOpticalRevision(uint16_t *revision) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETOPTICALREVISION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read revision from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *revision = (uint16_t)outVal; inPtr+=2; }// end of revision handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetOpticalRevision() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetSensorRevision(uint16_t *revision) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETSENSORREVISION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read revision from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *revision = (uint16_t)outVal; inPtr+=2; }// end of revision handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetSensorRevision() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetProbeTipSN(uint8_t *number) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 128; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPROBETIPSN, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read number from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal[128]; byteToUCHARArray( (const uint8_t *) inPtr, outVal, (uint16_t)128); number[0] = outVal[0]; number[1] = outVal[1]; number[2] = outVal[2]; number[3] = outVal[3]; number[4] = outVal[4]; number[5] = outVal[5]; number[6] = outVal[6]; number[7] = outVal[7]; number[8] = outVal[8]; number[9] = outVal[9]; number[10] = outVal[10]; number[11] = outVal[11]; number[12] = outVal[12]; number[13] = outVal[13]; number[14] = outVal[14]; number[15] = outVal[15]; number[16] = outVal[16]; number[17] = outVal[17]; number[18] = outVal[18]; number[19] = outVal[19]; number[20] = outVal[20]; number[21] = outVal[21]; number[22] = outVal[22]; number[23] = outVal[23]; number[24] = outVal[24]; number[25] = outVal[25]; number[26] = outVal[26]; number[27] = outVal[27]; number[28] = outVal[28]; number[29] = outVal[29]; number[30] = outVal[30]; number[31] = outVal[31]; number[32] = outVal[32]; number[33] = outVal[33]; number[34] = outVal[34]; number[35] = outVal[35]; number[36] = outVal[36]; number[37] = outVal[37]; number[38] = outVal[38]; number[39] = outVal[39]; number[40] = outVal[40]; number[41] = outVal[41]; number[42] = outVal[42]; number[43] = outVal[43]; number[44] = outVal[44]; number[45] = outVal[45]; number[46] = outVal[46]; number[47] = outVal[47]; number[48] = outVal[48]; number[49] = outVal[49]; number[50] = outVal[50]; number[51] = outVal[51]; number[52] = outVal[52]; number[53] = outVal[53]; number[54] = outVal[54]; number[55] = outVal[55]; number[56] = outVal[56]; number[57] = outVal[57]; number[58] = outVal[58]; number[59] = outVal[59]; number[60] = outVal[60]; number[61] = outVal[61]; number[62] = outVal[62]; number[63] = outVal[63]; number[64] = outVal[64]; number[65] = outVal[65]; number[66] = outVal[66]; number[67] = outVal[67]; number[68] = outVal[68]; number[69] = outVal[69]; number[70] = outVal[70]; number[71] = outVal[71]; number[72] = outVal[72]; number[73] = outVal[73]; number[74] = outVal[74]; number[75] = outVal[75]; number[76] = outVal[76]; number[77] = outVal[77]; number[78] = outVal[78]; number[79] = outVal[79]; number[80] = outVal[80]; number[81] = outVal[81]; number[82] = outVal[82]; number[83] = outVal[83]; number[84] = outVal[84]; number[85] = outVal[85]; number[86] = outVal[86]; number[87] = outVal[87]; number[88] = outVal[88]; number[89] = outVal[89]; number[90] = outVal[90]; number[91] = outVal[91]; number[92] = outVal[92]; number[93] = outVal[93]; number[94] = outVal[94]; number[95] = outVal[95]; number[96] = outVal[96]; number[97] = outVal[97]; number[98] = outVal[98]; number[99] = outVal[99]; number[100] = outVal[100]; number[101] = outVal[101]; number[102] = outVal[102]; number[103] = outVal[103]; number[104] = outVal[104]; number[105] = outVal[105]; number[106] = outVal[106]; number[107] = outVal[107]; number[108] = outVal[108]; number[109] = outVal[109]; number[110] = outVal[110]; number[111] = outVal[111]; number[112] = outVal[112]; number[113] = outVal[113]; number[114] = outVal[114]; number[115] = outVal[115]; number[116] = outVal[116]; number[117] = outVal[117]; number[118] = outVal[118]; number[119] = outVal[119]; number[120] = outVal[120]; number[121] = outVal[121]; number[122] = outVal[122]; number[123] = outVal[123]; number[124] = outVal[124]; number[125] = outVal[125]; number[126] = outVal[126]; number[127] = outVal[127]; inPtr+=128; }// end of number handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetProbeTipSN() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetMechanicalRevision(uint16_t *revision) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETMECHANICALREVISION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read revision from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *revision = (uint16_t)outVal; inPtr+=2; }// end of revision handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetMechanicalRevision() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSysinfoGetProbeTipType(FLR_SYSINFO_PROBE_TIP_TYPE *type) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 5; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSINFO_GETPROBETIPTYPE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read type from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSINFO_PROBE_TIP_TYPE outVal; byteToFLR_SYSINFO_PROBE_TIP_TYPE( (const uint8_t *) inPtr, &outVal); *type = (FLR_SYSINFO_PROBE_TIP_TYPE)outVal; inPtr+=5; }// end of type handling return R_SUCCESS; }// End of CLIENT_pkgSysinfoGetProbeTipType() // End Module: sysinfo // Begin Module: systemSymbols // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 5; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write symbol to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETID, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read id from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal; byteToUCHAR( (const uint8_t *) inPtr, &outVal); *id = (uint8_t)outVal; inPtr+=1; }// end of id handling // read id_type from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *id_type = (FLR_SYSTEMSYMBOLS_ID_TYPE_E)outVal; inPtr+=4; }// end of id_type handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetID() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 9; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write symbol to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write id to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = id; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write id_type to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_ID_TYPE_E inVal = id_type; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETID, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetID() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write symbol to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read enabled from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *enabled = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of enabled handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 8; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write symbol to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SYMBOL_E inVal = symbol; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } //write enabled to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = enabled; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETENABLE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetEnable() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfig(FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 195; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETSPOTCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read config from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_SPOTCONFIG_T outVal; byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_T( (const uint8_t *) inPtr, &outVal); *config = (FLR_SYSTEMSYMBOLS_SPOTCONFIG_T)outVal; inPtr+=195; }// end of config handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetSpotConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfig(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 195; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write config to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_SPOTCONFIG_T *) &config; FLR_SYSTEMSYMBOLS_SPOTCONFIG_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 195; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETSPOTCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetSpotConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfig(FLR_SYSTEMSYMBOLS_ISOCONFIG_T *config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 30; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETISOCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read config from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_ISOCONFIG_T outVal; byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_T( (const uint8_t *) inPtr, &outVal); *config = (FLR_SYSTEMSYMBOLS_ISOCONFIG_T)outVal; inPtr+=30; }// end of config handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetIsoConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfig(const FLR_SYSTEMSYMBOLS_ISOCONFIG_T config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 30; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write config to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_ISOCONFIG_T *) &config; FLR_SYSTEMSYMBOLS_ISOCONFIG_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 30; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETISOCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetIsoConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetBarConfig(FLR_SYSTEMSYMBOLS_BARCONFIG_T *lowGainConfig, FLR_SYSTEMSYMBOLS_BARCONFIG_T *highGainConfig, FLR_TEMPERATURE_UNIT_E *unit) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 24; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETBARCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read lowGainConfig from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_BARCONFIG_T outVal; byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T( (const uint8_t *) inPtr, &outVal); *lowGainConfig = (FLR_SYSTEMSYMBOLS_BARCONFIG_T)outVal; inPtr+=10; }// end of lowGainConfig handling // read highGainConfig from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_BARCONFIG_T outVal; byteToFLR_SYSTEMSYMBOLS_BARCONFIG_T( (const uint8_t *) inPtr, &outVal); *highGainConfig = (FLR_SYSTEMSYMBOLS_BARCONFIG_T)outVal; inPtr+=10; }// end of highGainConfig handling // read unit from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *unit = (FLR_TEMPERATURE_UNIT_E)outVal; inPtr+=4; }// end of unit handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetBarConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetBarConfig(const FLR_SYSTEMSYMBOLS_BARCONFIG_T lowGainConfig, const FLR_SYSTEMSYMBOLS_BARCONFIG_T highGainConfig, const FLR_TEMPERATURE_UNIT_E unit) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 24; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write lowGainConfig to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_BARCONFIG_T *) &lowGainConfig; FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 10; } //write highGainConfig to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_BARCONFIG_T *inVal = (const FLR_SYSTEMSYMBOLS_BARCONFIG_T *) &highGainConfig; FLR_SYSTEMSYMBOLS_BARCONFIG_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 10; } //write unit to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TEMPERATURE_UNIT_E inVal = unit; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETBARCONFIG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetBarConfig() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetSpotConfigIds(FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 13; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETSPOTCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read config from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T outVal; byteToFLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T( (const uint8_t *) inPtr, &outVal); *config = (FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T)outVal; inPtr+=13; }// end of config handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetSpotConfigIds() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetSpotConfigIds(const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 13; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write config to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *inVal = (const FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_T *) &config; FLR_SYSTEMSYMBOLS_SPOTCONFIG_ID_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 13; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETSPOTCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetSpotConfigIds() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsGetIsoConfigIds(FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_GETISOCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read config from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T outVal; byteToFLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T( (const uint8_t *) inPtr, &outVal); *config = (FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T)outVal; inPtr+=2; }// end of config handling return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsGetIsoConfigIds() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgSystemsymbolsSetIsoConfigIds(const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T config) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write config to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *inVal = (const FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_T *) &config; FLR_SYSTEMSYMBOLS_ISOCONFIG_ID_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, SYSTEMSYMBOLS_SETISOCONFIGIDS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgSystemsymbolsSetIsoConfigIds() // End Module: systemSymbols // Begin Module: telemetry // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetLocation(const FLR_TELEMETRY_LOC_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TELEMETRY_LOC_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetLocation() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetLocation(FLR_TELEMETRY_LOC_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETLOCATION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_TELEMETRY_LOC_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetLocation() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetPacking(const FLR_TELEMETRY_PACKING_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TELEMETRY_PACKING_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETPACKING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetPacking() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetPacking(FLR_TELEMETRY_PACKING_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETPACKING, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_TELEMETRY_PACKING_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetPacking() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetOrder(const FLR_TELEMETRY_ORDER_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TELEMETRY_ORDER_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETORDER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetOrder() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetOrder(FLR_TELEMETRY_ORDER_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETORDER, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_TELEMETRY_ORDER_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetOrder() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetPackingVC1(const FLR_TELEMETRY_PACKING_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TELEMETRY_PACKING_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETPACKINGVC1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetPackingVC1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetPackingVC1(FLR_TELEMETRY_PACKING_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETPACKINGVC1, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_TELEMETRY_PACKING_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetPackingVC1() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetrySetMipiEmbeddedDataTag(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_SETMIPIEMBEDDEDDATATAG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTelemetrySetMipiEmbeddedDataTag() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTelemetryGetMipiEmbeddedDataTag(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TELEMETRY_GETMIPIEMBEDDEDDATATAG, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTelemetryGetMipiEmbeddedDataTag() // End Module: telemetry // Begin Module: testRamp // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 5; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TESTRAMP_TYPE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETTYPE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetType() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETTYPE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_TESTRAMP_TYPE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetType() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 7; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TESTRAMP_SETTINGS_T *inVal = (const FLR_TESTRAMP_SETTINGS_T *) &data; FLR_TESTRAMP_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 6; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetSettings() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 6; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write index to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = index; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_TESTRAMP_SETTINGS_T outVal; byteToFLR_TESTRAMP_SETTINGS_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_TESTRAMP_SETTINGS_T)outVal; inPtr+=6; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetSettings() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetMotionState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETMOTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetMotionState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetMotionState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETMOTIONSTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetMotionState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetIndex(const uint8_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 1; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint8_t inVal = data; UCHARToByte(inVal, (const uint8_t *) outPtr); outPtr += 1; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETINDEX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetIndex() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetIndex(uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETINDEX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal; byteToUCHAR( (const uint8_t *) inPtr, &outVal); *data = (uint8_t)outVal; inPtr+=1; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetIndex() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetMaxIndex(uint8_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETMAXINDEX, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint8_t outVal; byteToUCHAR( (const uint8_t *) inPtr, &outVal); *data = (uint8_t)outVal; inPtr+=1; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetMaxIndex() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetPN9ContinuousMode(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETPN9CONTINUOUSMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetPN9ContinuousMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetPN9ContinuousMode(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETPN9CONTINUOUSMODE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetPN9ContinuousMode() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampSetAnimationSettings(const FLR_TESTRAMP_ANIMATION_SETTINGS_T settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write settings to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TESTRAMP_ANIMATION_SETTINGS_T *inVal = (const FLR_TESTRAMP_ANIMATION_SETTINGS_T *) &settings; FLR_TESTRAMP_ANIMATION_SETTINGS_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_SETANIMATIONSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTestrampSetAnimationSettings() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTestrampGetAnimationSettings(FLR_TESTRAMP_ANIMATION_SETTINGS_T *settings) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TESTRAMP_GETANIMATIONSETTINGS, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read settings from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_TESTRAMP_ANIMATION_SETTINGS_T outVal; byteToFLR_TESTRAMP_ANIMATION_SETTINGS_T( (const uint8_t *) inPtr, &outVal); *settings = (FLR_TESTRAMP_ANIMATION_SETTINGS_T)outVal; inPtr+=4; }// end of settings handling return R_SUCCESS; }// End of CLIENT_pkgTestrampGetAnimationSettings() // End Module: testRamp // Begin Module: tf // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetEnableState(const FLR_ENABLE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_ENABLE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetEnableState(FLR_ENABLE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETENABLESTATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_ENABLE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetEnableState() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetDelta_nf(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETDELTA_NF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetDelta_nf() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetDelta_nf(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETDELTA_NF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetDelta_nf() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetTHDeltaMotion(const uint16_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 2; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint16_t inVal = data; UINT_16ToByte(inVal, (const uint8_t *) outPtr); outPtr += 2; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETTHDELTAMOTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetTHDeltaMotion() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetTHDeltaMotion(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTHDELTAMOTION, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetTHDeltaMotion() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetWLut(const FLR_TF_WLUT_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 32; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TF_WLUT_T *inVal = (const FLR_TF_WLUT_T *) &data; FLR_TF_WLUT_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 32; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETWLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetWLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetWLut(FLR_TF_WLUT_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 32; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETWLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_TF_WLUT_T outVal; byteToFLR_TF_WLUT_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_TF_WLUT_T)outVal; inPtr+=32; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetWLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetMotionCount(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETMOTIONCOUNT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetMotionCount() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetMotionThreshold(const uint32_t data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const uint32_t inVal = data; UINT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETMOTIONTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetMotionThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetMotionThreshold(uint32_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETMOTIONTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint32_t outVal; byteToUINT_32( (const uint8_t *) inPtr, &outVal); *data = (uint32_t)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetMotionThreshold() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetDelta_nfApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETDELTA_NFAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetDelta_nfApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetTHDeltaMotionApplied(uint16_t *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTHDELTAMOTIONAPPLIED, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *data = (uint16_t)outVal; inPtr+=2; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetTHDeltaMotionApplied() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfSetTempSignalCompFactorLut(const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 34; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *inVal = (const FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *) &data; FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_TToByte(inVal, (const uint8_t *) outPtr); outPtr += 34; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_SETTEMPSIGNALCOMPFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgTfSetTempSignalCompFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetTempSignalCompFactorLut(FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 34; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETTEMPSIGNALCOMPFACTORLUT, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T outVal; byteToFLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T( (const uint8_t *) inPtr, &outVal); *data = (FLR_TF_TEMP_SIGNAL_COMP_FACTOR_LUT_T)outVal; inPtr+=34; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgTfGetTempSignalCompFactorLut() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgTfGetRnf(uint16_t *rnf) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 2; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, TF_GETRNF, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read rnf from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } uint16_t outVal; byteToUINT_16( (const uint8_t *) inPtr, &outVal); *rnf = (uint16_t)outVal; inPtr+=2; }// end of rnf handling return R_SUCCESS; }// End of CLIENT_pkgTfGetRnf() // End Module: tf // Begin Module: uart // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgUartSetStartupBaudRate(const FLR_UART_STARTUP_BAUDRATE_E data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 4; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 1; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; //write data to sendData buffer { //Block to allow reuse of inVal if(outPtr >= (sendData+sendBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } const FLR_UART_STARTUP_BAUDRATE_E inVal = data; INT_32ToByte(inVal, (const uint8_t *) outPtr); outPtr += 4; } FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, UART_SETSTARTUPBAUDRATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; return R_SUCCESS; }// End of CLIENT_pkgUartSetStartupBaudRate() // Synchronous (potentially MultiService incompatible) transmit+receive variant FLR_RESULT CLIENT_pkgUartGetStartupBaudRate(FLR_UART_STARTUP_BAUDRATE_E *data) { // Allocate buffers with space for marshalled data uint32_t sendBytes = 0; const uint8_t sendData[sendBytes]; uint32_t receiveBytes = 4; uint8_t receiveData[receiveBytes]; uint8_t *outPtr = (uint8_t *)sendData; FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, UART_GETSTARTUPBAUDRATE, sendData, sendBytes, receiveData, &receiveBytes); // Check for any errorcode if((uint32_t) returncode){ return returncode; } uint8_t *inPtr = (uint8_t *)receiveData; // read data from receiveData buffer { //Block to allow reuse of outVal if(inPtr >= (receiveData+receiveBytes)){ return R_SDK_PKG_BUFFER_OVERFLOW; } int32_t outVal; byteToINT_32( (const uint8_t *) inPtr, &outVal); *data = (FLR_UART_STARTUP_BAUDRATE_E)outVal; inPtr+=4; }// end of data handling return R_SUCCESS; }// End of CLIENT_pkgUartGetStartupBaudRate() // End Module: uart