Client_API.c

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFopen(const uint8_t path[], const uint8_t mode[], uint32_t *id){
	FLR_RESULT returncode = CLIENT_pkgFileopsFopen(path, mode, id);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Fopen()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFclose(const uint32_t id){
	FLR_RESULT returncode = CLIENT_pkgFileopsFclose(id);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Fclose()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFread(const uint32_t id, const uint32_t length, uint8_t buf[], uint32_t *ret){
	FLR_RESULT returncode = CLIENT_pkgFileopsFread(id, length, buf, ret);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Fread()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFwrite(const uint32_t id, const uint32_t length, const uint8_t buf[], uint32_t *ret){
	FLR_RESULT returncode = CLIENT_pkgFileopsFwrite(id, length, buf, ret);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Fwrite()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFtell(const uint32_t id, uint32_t *offset){
	FLR_RESULT returncode = CLIENT_pkgFileopsFtell(id, offset);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Ftell()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFseek(const uint32_t id, const uint32_t offset, const uint32_t origin){
	FLR_RESULT returncode = CLIENT_pkgFileopsFseek(id, offset, origin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Fseek()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsFtruncate(const uint32_t id, const uint32_t length){
	FLR_RESULT returncode = CLIENT_pkgFileopsFtruncate(id, length);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Ftruncate()

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

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

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsRename(const uint8_t oldpath[], const uint8_t newpath[]){
	FLR_RESULT returncode = CLIENT_pkgFileopsRename(oldpath, newpath);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Rename()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT fileOpsGetFileSize(const uint8_t path[], uint32_t *fileLength){
	FLR_RESULT returncode = CLIENT_pkgFileopsGetFileSize(path, fileLength);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFileSize()

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

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

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT jffs2GetState(FLR_JFFS2_STATE_E *state){
	FLR_RESULT returncode = CLIENT_pkgJffs2GetState(state);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenSetDuration(const uint32_t screen_num, const uint32_t periodMs){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenSetDuration(screen_num, periodMs);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetDuration()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenSetDataType(const uint32_t screen_num, const FLR_SPLASHSCREEN_FILETYPE_E filetype){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenSetDataType(screen_num, filetype);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetDataType()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenSetBackground(const uint32_t screen_num, const uint32_t backgroundColor){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenSetBackground(screen_num, backgroundColor);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetBackground()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenGetDuration(const uint32_t screen_num, uint32_t *periodMs){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenGetDuration(screen_num, periodMs);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDuration()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenGetDataType(const uint32_t screen_num, FLR_SPLASHSCREEN_FILETYPE_E *filetype){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenGetDataType(screen_num, filetype);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetDataType()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT splashScreenGetBackground(const uint32_t screen_num, uint32_t *backgroundColor){
	FLR_RESULT returncode = CLIENT_pkgSplashscreenGetBackground(screen_num, backgroundColor);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetBackground()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT systemSymbolsGetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, uint8_t *id, FLR_SYSTEMSYMBOLS_ID_TYPE_E *id_type){
	FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetID(symbol, id, id_type);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetID()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT systemSymbolsSetID(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const uint8_t id, const FLR_SYSTEMSYMBOLS_ID_TYPE_E id_type){
	FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetID(symbol, id, id_type);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetID()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT systemSymbolsGetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, FLR_ENABLE_E *enabled){
	FLR_RESULT returncode = CLIENT_pkgSystemsymbolsGetEnable(symbol, enabled);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetEnable()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT systemSymbolsSetEnable(const FLR_SYSTEMSYMBOLS_SYMBOL_E symbol, const FLR_ENABLE_E enabled){
	FLR_RESULT returncode = CLIENT_pkgSystemsymbolsSetEnable(symbol, enabled);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetEnable()

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

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

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

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

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

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

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

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

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

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

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

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetTotalHistPixelsInROI(uint32_t *totalPixelsInROI){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetTotalHistPixelsInROI(totalPixelsInROI);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTotalHistPixelsInROI()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetPopBelowLowToHighThresh(uint32_t *popBelowLowToHighThresh){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopBelowLowToHighThresh(popBelowLowToHighThresh);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetPopBelowLowToHighThresh()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetPopAboveHighToLowThresh(uint32_t *popAboveHighToLowThresh){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetPopAboveHighToLowThresh(popAboveHighToLowThresh);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetPopAboveHighToLowThresh()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsSetROI(const FLR_ROI_T roi){
	FLR_RESULT returncode = CLIENT_pkgImagestatsSetROI(roi);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetROI()

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

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetFirstBin(uint16_t *firstBin){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetFirstBin(firstBin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFirstBin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetLastBin(uint16_t *lastBin){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetLastBin(lastBin);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetLastBin()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetMean(uint16_t *mean){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetMean(mean);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMean()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetFirstBinInROI(uint16_t *firstBinInROI){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetFirstBinInROI(firstBinInROI);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFirstBinInROI()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetLastBinInROI(uint16_t *lastBinInROI){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetLastBinInROI(lastBinInROI);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetLastBinInROI()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT imageStatsGetMeanInROI(uint16_t *meanInROI){
	FLR_RESULT returncode = CLIENT_pkgImagestatsGetMeanInROI(meanInROI);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetMeanInROI()

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

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

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

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

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

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

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

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

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

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

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