Client_Packager.c

//  /////////////////////////////////////////////////////
//  // DO NOT EDIT.  This is a machine generated file. //
//  /////////////////////////////////////////////////////
/******************************************************************************/
/*                                                                            */
/*  Copyright (C) 2016, 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: gao
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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

FLR_RESULT CLIENT_pkgGaoSetRnsState(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_SETRNSSTATE, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (uint8_t *)receiveData;
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoSetRnsState()

FLR_RESULT CLIENT_pkgGaoGetRnsState(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_GETRNSSTATE, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (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_pkgGaoGetRnsState()

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()

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()

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()

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()

FLR_RESULT CLIENT_pkgGaoSetRpmState(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_SETRPMSTATE, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (uint8_t *)receiveData;
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoSetRpmState()

FLR_RESULT CLIENT_pkgGaoGetRpmState(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_GETRPMSTATE, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (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_pkgGaoGetRpmState()

FLR_RESULT CLIENT_pkgGaoGetRpmThreshold(uint16_t *threshold) {
	// 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_GETRPMTHRESHOLD, 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;
		}
		uint16_t outVal;
		byteToUINT_16( (const uint8_t *) inPtr, &outVal);
		*threshold = (uint16_t)outVal;
		inPtr+=2;
	}// end of threshold handling
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoGetRpmThreshold()

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()

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()

FLR_RESULT CLIENT_pkgGaoSetRnsPopThreshold(const uint16_t threshold) {
	// 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 threshold to sendData buffer
	{ //Block to allow reuse of inVal
		if(outPtr >= (sendData+sendBytes)){
			return R_SDK_PKG_BUFFER_OVERFLOW;
		}
		const uint16_t inVal = threshold;
		UINT_16ToByte(inVal, (const uint8_t *) outPtr);
		outPtr += 2;
	}
	
	FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETRNSPOPTHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (uint8_t *)receiveData;
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoSetRnsPopThreshold()

FLR_RESULT CLIENT_pkgGaoGetRnsPopThreshold(uint16_t *threshold) {
	// 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_GETRNSPOPTHRESHOLD, 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;
		}
		uint16_t outVal;
		byteToUINT_16( (const uint8_t *) inPtr, &outVal);
		*threshold = (uint16_t)outVal;
		inPtr+=2;
	}// end of threshold handling
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoGetRnsPopThreshold()

FLR_RESULT CLIENT_pkgGaoSetRnsCloseThreshold(const uint16_t threshold) {
	// 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 threshold to sendData buffer
	{ //Block to allow reuse of inVal
		if(outPtr >= (sendData+sendBytes)){
			return R_SDK_PKG_BUFFER_OVERFLOW;
		}
		const uint16_t inVal = threshold;
		UINT_16ToByte(inVal, (const uint8_t *) outPtr);
		outPtr += 2;
	}
	
	FLR_RESULT returncode = CLIENT_dispatcher(commandCount++, GAO_SETRNSCLOSETHRESHOLD, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (uint8_t *)receiveData;
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoSetRnsCloseThreshold()

FLR_RESULT CLIENT_pkgGaoGetRnsCloseThreshold(uint16_t *threshold) {
	// 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_GETRNSCLOSETHRESHOLD, 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;
		}
		uint16_t outVal;
		byteToUINT_16( (const uint8_t *) inPtr, &outVal);
		*threshold = (uint16_t)outVal;
		inPtr+=2;
	}// end of threshold handling
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoGetRnsCloseThreshold()

FLR_RESULT CLIENT_pkgGaoSetRnsTooFewQuit(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_SETRNSTOOFEWQUIT, sendData, sendBytes, receiveData, &receiveBytes);
	
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	
	uint8_t *inPtr = (uint8_t *)receiveData;
	
	return R_SUCCESS;
	
}// End of CLIENT_pkgGaoSetRnsTooFewQuit()

FLR_RESULT CLIENT_pkgGaoGetRnsTooFewQuit(uint16_t *data) {