Client_API.c

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcGetROI(FLR_ROI_T *roi){
	FLR_RESULT returncode = CLIENT_pkgAgcGetROI(roi);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetROI()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcGetMaxGainApplied(float *data){
	FLR_RESULT returncode = CLIENT_pkgAgcGetMaxGainApplied(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMaxGainApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcGetSigmaRApplied(float *data){
	FLR_RESULT returncode = CLIENT_pkgAgcGetSigmaRApplied(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSigmaRApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcSetOutlierCutBalance(const float data){
	FLR_RESULT returncode = CLIENT_pkgAgcSetOutlierCutBalance(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetOutlierCutBalance()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcGetOutlierCutBalance(float *data){
	FLR_RESULT returncode = CLIENT_pkgAgcGetOutlierCutBalance(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetOutlierCutBalance()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT agcGetOutlierCutApplied(float *percentHigh, float *percentLow){
	FLR_RESULT returncode = CLIENT_pkgAgcGetOutlierCutApplied(percentHigh, percentLow);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetOutlierCutApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfSetEnableState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgTfSetEnableState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetEnableState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetEnableState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetEnableState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetEnableState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfSetDelta_nf(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgTfSetDelta_nf(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetDelta_nf()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetDelta_nf(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetDelta_nf(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDelta_nf()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfSetTHDeltaMotion(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgTfSetTHDeltaMotion(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetTHDeltaMotion()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetTHDeltaMotion(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetTHDeltaMotion(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTHDeltaMotion()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfSetWLut(const FLR_TF_WLUT_T data){
	FLR_RESULT returncode = CLIENT_pkgTfSetWLut(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetWLut()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetWLut(FLR_TF_WLUT_T *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetWLut(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetWLut()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetMotionCount(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetMotionCount(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMotionCount()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfSetMotionThreshold(const uint32_t data){
	FLR_RESULT returncode = CLIENT_pkgTfSetMotionThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetMotionThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetMotionThreshold(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetMotionThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMotionThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetDelta_nfApplied(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetDelta_nfApplied(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDelta_nfApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT tfGetTHDeltaMotionApplied(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgTfGetTHDeltaMotionApplied(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTHDeltaMotionApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memReadCapture(const uint8_t bufferNum, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgMemReadCapture(bufferNum, offset, sizeInBytes, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ReadCapture()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memGetCaptureSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns){
	FLR_RESULT returncode = CLIENT_pkgMemGetCaptureSize(bytes, rows, columns);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetCaptureSize()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memWriteFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgMemWriteFlash(location, index, offset, sizeInBytes, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of WriteFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memReadFlash(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgMemReadFlash(location, index, offset, sizeInBytes, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ReadFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memGetFlashSize(const FLR_MEM_LOCATION_E location, uint32_t *bytes){
	FLR_RESULT returncode = CLIENT_pkgMemGetFlashSize(location, bytes);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFlashSize()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memEraseFlash(const FLR_MEM_LOCATION_E location, const uint8_t index){
	FLR_RESULT returncode = CLIENT_pkgMemEraseFlash(location, index);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of EraseFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memEraseFlashPartial(const FLR_MEM_LOCATION_E location, const uint8_t index, const uint32_t offset, const uint32_t length){
	FLR_RESULT returncode = CLIENT_pkgMemEraseFlashPartial(location, index, offset, length);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of EraseFlashPartial()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memReadCurrentGain(const uint32_t offset, const uint16_t sizeInBytes, uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgMemReadCurrentGain(offset, sizeInBytes, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ReadCurrentGain()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT memGetGainSize(uint32_t *bytes, uint16_t *rows, uint16_t *columns){
	FLR_RESULT returncode = CLIENT_pkgMemGetGainSize(bytes, rows, columns);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetGainSize()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT colorLutSetControl(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgColorlutSetControl(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetControl()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT colorLutGetControl(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgColorlutGetControl(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetControl()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT colorLutSetId(const FLR_COLORLUT_ID_E data){
	FLR_RESULT returncode = CLIENT_pkgColorlutSetId(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetId()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT colorLutGetId(FLR_COLORLUT_ID_E *data){
	FLR_RESULT returncode = CLIENT_pkgColorlutGetId(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetId()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetEnableState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetEnableState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetEnableState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetEnableState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetEnableState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetEnableState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetState(FLR_SPNR_STATE_E *data){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetFrameDelay(const uint32_t data){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetFrameDelay(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFrameDelay()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetFrameDelay(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetFrameDelay(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFrameDelay()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetSFApplied(float *sf){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetSFApplied(sf);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSFApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetPSDKernel(const FLR_SPNR_PSD_KERNEL_T data){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetPSDKernel(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetPSDKernel()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetPSDKernel(FLR_SPNR_PSD_KERNEL_T *data){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetPSDKernel(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetPSDKernel()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetSFMin(const float sfmin){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetSFMin(sfmin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetSFMin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetSFMin(float *sfmin){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetSFMin(sfmin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSFMin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetSFMax(const float sfmax){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetSFMax(sfmax);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetSFMax()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetSFMax(float *sfmax){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetSFMax(sfmax);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSFMax()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetDFMin(const float dfmin){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetDFMin(dfmin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetDFMin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetDFMin(float *dfmin){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetDFMin(dfmin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDFMin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetDFMax(const float dfmax){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetDFMax(dfmax);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetDFMax()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetDFMax(float *dfmax){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetDFMax(dfmax);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDFMax()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrSetNormTarget(const float normTarget){
	FLR_RESULT returncode = CLIENT_pkgSpnrSetNormTarget(normTarget);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetNormTarget()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetNormTarget(float *normTarget){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetNormTarget(normTarget);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetNormTarget()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT spnrGetNormTargetApplied(float *normTargetApplied){
	FLR_RESULT returncode = CLIENT_pkgSpnrGetNormTargetApplied(normTargetApplied);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetNormTargetApplied()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT scalerGetMaxZoom(uint32_t *zoom){
	FLR_RESULT returncode = CLIENT_pkgScalerGetMaxZoom(zoom);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMaxZoom()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT scalerSetZoom(const FLR_SCALER_ZOOM_PARAMS_T zoomParams){
	FLR_RESULT returncode = CLIENT_pkgScalerSetZoom(zoomParams);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetZoom()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT scalerGetZoom(FLR_SCALER_ZOOM_PARAMS_T *zoomParams){
	FLR_RESULT returncode = CLIENT_pkgScalerGetZoom(zoomParams);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetZoom()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT scalerSetFractionalZoom(const uint32_t zoomNumerator, const uint32_t zoomDenominator, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable){
	FLR_RESULT returncode = CLIENT_pkgScalerSetFractionalZoom(zoomNumerator, zoomDenominator, zoomXCenter, zoomYCenter, inChangeEnable, zoomOutXCenter, zoomOutYCenter, outChangeEnable);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFractionalZoom()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT scalerSetIndexZoom(const uint32_t zoomIndex, const uint32_t zoomXCenter, const uint32_t zoomYCenter, const FLR_ENABLE_E inChangeEnable, const uint32_t zoomOutXCenter, const uint32_t zoomOutYCenter, const FLR_ENABLE_E outChangeEnable){
	FLR_RESULT returncode = CLIENT_pkgScalerSetIndexZoom(zoomIndex, zoomXCenter, zoomYCenter, inChangeEnable, zoomOutXCenter, zoomOutYCenter, outChangeEnable);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetIndexZoom()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT sysctrlSetFreezeState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgSysctrlSetFreezeState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFreezeState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT sysctrlGetFreezeState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgSysctrlGetFreezeState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFreezeState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT sysctrlGetCameraFrameRate(uint32_t *frameRate){
	FLR_RESULT returncode = CLIENT_pkgSysctrlGetCameraFrameRate(frameRate);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetCameraFrameRate()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampSetType(const uint8_t index, const FLR_TESTRAMP_TYPE_E data){
	FLR_RESULT returncode = CLIENT_pkgTestrampSetType(index, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetType()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampGetType(const uint8_t index, FLR_TESTRAMP_TYPE_E *data){
	FLR_RESULT returncode = CLIENT_pkgTestrampGetType(index, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetType()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampSetSettings(const uint8_t index, const FLR_TESTRAMP_SETTINGS_T data){
	FLR_RESULT returncode = CLIENT_pkgTestrampSetSettings(index, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetSettings()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampGetSettings(const uint8_t index, FLR_TESTRAMP_SETTINGS_T *data){
	FLR_RESULT returncode = CLIENT_pkgTestrampGetSettings(index, data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSettings()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampSetMotionState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgTestrampSetMotionState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetMotionState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampGetMotionState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgTestrampGetMotionState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMotionState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampSetIndex(const uint8_t data){
	FLR_RESULT returncode = CLIENT_pkgTestrampSetIndex(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetIndex()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampGetIndex(uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgTestrampGetIndex(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetIndex()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT testRampGetMaxIndex(uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgTestrampGetMaxIndex(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMaxIndex()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologySetEnable(const FLR_ENABLE_E draw_symbols){
	FLR_RESULT returncode = CLIENT_pkgSymbologySetEnable(draw_symbols);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetEnable()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateBitmap(ID, pos_X, pos_Y, width, height);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateBitmap()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologySendData(const uint8_t ID, const int16_t size, const uint8_t text[]){
	FLR_RESULT returncode = CLIENT_pkgSymbologySendData(ID, size, text);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SendData()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateArc(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const float start_angle, const float end_angle, const uint32_t color){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateArc(ID, pos_X, pos_Y, width, height, start_angle, end_angle, color);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateArc()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateText(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const int8_t font, const int16_t size, const FLR_SYMBOLOGY_TEXT_ALIGNMENT_E alignment, const uint32_t color, const uint8_t text[]){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateText(ID, pos_X, pos_Y, width, height, font, size, alignment, color, text);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateText()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyMoveSprite(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y){
	FLR_RESULT returncode = CLIENT_pkgSymbologyMoveSprite(ID, pos_X, pos_Y);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of MoveSprite()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyAddToGroup(const uint8_t ID, const uint8_t group_ID){
	FLR_RESULT returncode = CLIENT_pkgSymbologyAddToGroup(ID, group_ID);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of AddToGroup()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyRemoveFromGroup(const uint8_t ID, const uint8_t group_ID){
	FLR_RESULT returncode = CLIENT_pkgSymbologyRemoveFromGroup(ID, group_ID);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of RemoveFromGroup()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyUpdateAndShow(const uint8_t ID, const uint8_t visible){
	FLR_RESULT returncode = CLIENT_pkgSymbologyUpdateAndShow(ID, visible);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of UpdateAndShow()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyUpdateAndShowGroup(const uint8_t group_ID, const uint8_t visible){
	FLR_RESULT returncode = CLIENT_pkgSymbologyUpdateAndShowGroup(group_ID, visible);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of UpdateAndShowGroup()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyDelete(const uint8_t ID){
	FLR_RESULT returncode = CLIENT_pkgSymbologyDelete(ID);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Delete()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyDeleteGroup(const uint8_t group_ID){
	FLR_RESULT returncode = CLIENT_pkgSymbologyDeleteGroup(group_ID);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of DeleteGroup()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateFilledRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateFilledRectangle(ID, pos_X, pos_Y, width, height, color);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateFilledRectangle()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateOutlinedRectangle(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateOutlinedRectangle(ID, pos_X, pos_Y, width, height, color);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateOutlinedRectangle()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateBitmapFromPng(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t size){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateBitmapFromPng(ID, pos_X, pos_Y, size);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateBitmapFromPng()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateCompressedBitmap(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateCompressedBitmap(ID, pos_X, pos_Y, width, height);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateCompressedBitmap()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateBitmapFromPngFile(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const uint8_t path[]){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateBitmapFromPngFile(ID, pos_X, pos_Y, path);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateBitmapFromPngFile()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyResetWritePosition(const uint8_t ID){
	FLR_RESULT returncode = CLIENT_pkgSymbologyResetWritePosition(ID);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ResetWritePosition()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyMoveByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y){
	FLR_RESULT returncode = CLIENT_pkgSymbologyMoveByOffset(ID, off_X, off_Y);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of MoveByOffset()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyMoveGroupByOffset(const uint8_t ID, const int16_t off_X, const int16_t off_Y){
	FLR_RESULT returncode = CLIENT_pkgSymbologyMoveGroupByOffset(ID, off_X, off_Y);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of MoveGroupByOffset()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateFilledEllipse(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t width, const int16_t height, const uint32_t color){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateFilledEllipse(ID, pos_X, pos_Y, width, height, color);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateFilledEllipse()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyCreateLine(const uint8_t ID, const int16_t pos_X, const int16_t pos_Y, const int16_t pos_X2, const int16_t pos_Y2, const uint32_t color){
	FLR_RESULT returncode = CLIENT_pkgSymbologyCreateLine(ID, pos_X, pos_Y, pos_X2, pos_Y2, color);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of CreateLine()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologySetZorder(const uint8_t ID, const uint8_t zorder){
	FLR_RESULT returncode = CLIENT_pkgSymbologySetZorder(ID, zorder);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetZorder()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologySaveConfiguration(){
	FLR_RESULT returncode = CLIENT_pkgSymbologySaveConfiguration();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SaveConfiguration()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyReloadConfiguration(){
	FLR_RESULT returncode = CLIENT_pkgSymbologyReloadConfiguration();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ReloadConfiguration()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyGetEnable(FLR_ENABLE_E *draw_symbols){
	FLR_RESULT returncode = CLIENT_pkgSymbologyGetEnable(draw_symbols);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetEnable()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologySetClonesNumber(const uint8_t ID, const uint8_t numberOfClones){
	FLR_RESULT returncode = CLIENT_pkgSymbologySetClonesNumber(ID, numberOfClones);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetClonesNumber()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyMoveCloneByOffset(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y){
	FLR_RESULT returncode = CLIENT_pkgSymbologyMoveCloneByOffset(ID, cloneID, pos_X, pos_Y);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of MoveCloneByOffset()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT symbologyMoveCloneSprite(const uint8_t ID, const uint8_t cloneID, const int16_t pos_X, const int16_t pos_Y){
	FLR_RESULT returncode = CLIENT_pkgSymbologyMoveCloneSprite(ID, cloneID, pos_X, pos_Y);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of MoveCloneSprite()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsDir(uint8_t dirent[]){
	FLR_RESULT returncode = CLIENT_pkgFileopsDir(dirent);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Dir()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsCd(const uint8_t path[], uint8_t pwd[]){
	FLR_RESULT returncode = CLIENT_pkgFileopsCd(path, pwd);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Cd()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsMd(const uint8_t path[]){
	FLR_RESULT returncode = CLIENT_pkgFileopsMd(path);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Md()