PhysicalDevice/Detector/Trixel/DIOS.Dev.FPD.TrixellDR/include/pixrad.h

// Copyright (c) 2006-2017 THALES. All Rights Reserved.
// All the  information contained in this file remain the sole and exclusive
// property of THALES and shall not be disclosed by the recipient to a third
// party without the prior consent of THALES.

/*! \file pixrad.h

    Abstract:

    This module defines the PixRad API.
    It includes :
    - the prototypes of the functions that manages the acquisition, storage and correction
	of images coming from detectors through acquisition boards.

*/

#ifndef PIXRAD_H
#define PIXRAD_H

#include "pixrad-types.h"

#if defined(WIN32)
	#if defined(PIXRAD_EXPORTS)
		#define PIXRAD_API __declspec(dllexport)
	#else
		#define PIXRAD_API __declspec(dllimport)
	#endif
#else
	#define PIXRAD_API __attribute__((visibility("default")))
#endif

#ifdef __cplusplus
extern "C" {
#endif

/*
    Prototypes of PixRad exported fonctions
*/

//! Register the function that will hook the events from PixRad.
/*!
	\param eventCallbackProc : [in] address of the function that will hook events
	\param customData : [in] arbitrary parameter passed when the callback is called

	\return ERR_SUCCESS
*/
PIXRAD_API error_status TED_PixRad_RegisterEventCallback( eventCallback_t eventCallbackProc, void* customData = NULL );

//! Unregister the function that hooks the events from PixRad.
/*!
	\return ERR_SUCCESS
*/
PIXRAD_API error_status TED_PixRad_UnregisterEventCallback( eventCallback_t eventCallbackProc = NULL );

//! Register the function that will hook the output messages from PixRad.
/*!
	\param outputCallbackProc : [in] address of the function that will hook messages
	\param customData : [in] arbitrary parameter passed when the callback is called

	\return ERR_SUCCESS
*/
PIXRAD_API error_status TED_PixRad_RegisterOutputMsgCallback( outputCallback_t outputCallbackProc, void* customData = NULL );

//! Unregister the function that will hook the output messages from PixRad.
/*!
	\return ERR_SUCCESS
*/
PIXRAD_API error_status TED_PixRad_UnregisterOutputMsgCallback( outputCallback_t outputCallbackProc = NULL );

//! Initialise the library, the detectors and boards.//
/*!
	This function must be called before any other PixRad functions except register callback functions.

	\param workingDirectory : [in] working directory path where library search ini files

	\return ERR_SUCCESS if successfull
	\return ERR_UNKNOWN_ERROR
	\return ERR_CONFIG_PARAMETER, ERR_CONFIG_FILE, ERR_CONFIG_FILE_NOT_FOUND
	\return ERR_ACQ_INIT_FAILED, ERR_DETECTOR_INIT_FAILED, ERR_LICENCE
	\return ERR_MEMORY_ALLOC
	\return ERR_ALREADY_OPEN, ERR_CLOSE_PENDING,
	\return ERR_DETECTOR_COMMUNICATION, ERR_DETECTOR_UNREACHABLE
*/
PIXRAD_API error_status TED_PixRad_Open( const char* workingDirectory );

//! Free the driver, the memory and eventually stops acquisition to quit correctly.//
/*!
	\return ERR_SUCCESS if successfull
	\return ERR_ACQ_NOT_CLOSE
*/
PIXRAD_API error_status TED_PixRad_Close();

//! Connects a given detector slot using a specified connection path.//
/*!
	\param detector : [in] Number of detector
	\param connectPath : [in] Connection path

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_Connect( unsigned short detector, const char* connectPath );

//! Disconnects a given detector slot.//
/*!
	\param detector : [in] Number of detector

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_Disconnect( unsigned short detector );

//! For locked detectors, requests a session id to initiate communication and to allow to transmit a new counter value.
/*!
    \see TED_Pixrad_TransmitDetectorLicenseSessionData to change locking counter

    \return ERR_SUCCESS if successfull else error code

    \note : In case of ERR_SUCCESS Session ID is transmited asynchronously with an upcoming event
*/
PIXRAD_API error_status TED_PixRad_RequestDetectorLicenseSession();

//! For locked detectors when a request session id has been initiated (TED_PixRad_RequestDetectorLicenseSession), allows to cancel it (if one notice that detector can't be unlocked)
//! instead of waiting for a timeout
/*!
    \see TED_Pixrad_TransmitDetectorLicenseSessionData to change locking counter

    \return ERR_SUCCESS if successfull else error code

    \note : In case of ERR_SUCCESS Session ID is transmited asynchronously with an upcoming event
*/
PIXRAD_API error_status TED_PixRad_CancelDetectorLicenseSession();

//! For locked detectors, when session id has been retrieved, allows to update locking counter.
/*!
    \see TED_PixRad_RequestDetectorLicenseSession to request session id.

    \param licenseSessionData : [in] User license session data
    \param dataSize : [in] User data size in bytes

    \return ERR_SUCCESS if successfull else error code

    \note : In case of ERR_SUCCESS user should wait for an asynchronous event to know the status of the update :
    - EVT_END_DETECTOR_LICENSE_SESSION_REQUEST if the update is the result of a direct update during an already opened pixrad session
    - EVT_DETECTOR_INIT if the update is the result of a connection with a locked detector
*/
PIXRAD_API error_status TED_PixRad_TransmitDetectorLicenseSessionData( const char* licenseSessionData, const unsigned short dataSize );


//! Scans detectors to check their availability.//
/*!
	Refreshes the list of connected detectors by connecting
	new available detectors and removing detectors not available anymore.

	\param scanType : [in] type of scan to be performed:
				- scan existing detectors
				- scan new detectors
				- scan both

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ScanDetectors( scan_type scanType );

//! Set new value for detector's wifi connection ssid/passwd
/*!
	\param ssid : [in] New connection ssid
	\param passwd : [in] New associated password

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SwitchSSID( const char* ssid, const char* passwd );

//! Set user metadata in image's header
/*!
	\param data : [in] User data
	\param dataSize : [in] User data size in bytes
*/
PIXRAD_API error_status TED_PixRad_SetImageMetadata( const char* data, const unsigned short dataSize );

//! Set parameters for a given application mode.
/*!
	\param applicationMode : [in] application mode
	\param parameters : array containing the parameters to apply
	\param nbParameters : number of parameters in the set

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetApplicationParameters( application_mode applicationMode, const ApplicationParameter* parameters, unsigned int nbParameters );

//! This function starts an image acquisition on a given application mode using the currently defined parameters ( cf. TED_PixRad_SetApplicationParameters ).
/*!
	\param applicationMode : [in] application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ApplicationAcquisition( application_mode applicationMode );

//! This function starts an image acquisition.
/*!
	The type of acquisiton defines the image type (offset, X or DM).
	The correction applied depends on the value corrections.

	\param applicationMode : [in] application mode
	\param image : [in] type of acquisition ( cf. TED_PixRad_StartAcquisition arg )
	\param correction : [in] value of correction applied
	\param data: [in] size of the output image
	\param preview : [in] preview

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_StartAcquisition( application_mode applicationMode, image_type image, correction_type correction, data_type data, bool preview = false );

//! This function starts an image acquisition : the second image in case of Dual Energy.
/*!
	\param gainReferenceId : [in] number of the gain reference

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_StartFrame( unsigned short gainReferenceId = defaultReferenceId );

//! This function resume a sequence acquisition.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ResumeAcquisition();

//! This function stops a sequence acquisition.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_StopAcquisition();

//! This function store an image buffer in fxd file format.
/*!
	The image buffer should contain the image previously acquired.
	Fxd format is a proprietary format easily readable with the ImageJ image viewer.

	\param filePath : [in] The path + name of the file destination
	\param bufStruct : [in] the image structure containing the image to store

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SaveImage( const char* filePath, const AcquisitionImage& bufStruct );

//! This function load an image buffer from an fxd file format.
/*!
	The image buffer is allocated and managed inside the function and freed automatically,
	so no deallocation must be perform by users programs explicitly.
	Fxd format is a proprietary format easily readable with the ImageJ image viewer.

	\param filePath : [in] The path + name of the file source
	\param bufStruct : [in] the image structure containing the image retrieved from the file

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_LoadImage( const char* filePath, AcquisitionImage& bufStruct );

//! This function returns the last image stored in the detector
/*!
	The correction used when the acquisition of the image was requested can be applied to the
	image

	\param applyCorrection : [in] true to correct the image

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_RecoverLastImage( bool applyCorrection );

//! List stored image in detector
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetStoredImageList( );

//! This function returns the given stored image in the detector
/*!
	\param number : [in] the requested stored image number
	\param preview : [in] is preview needed
	\param full : [in] is full image needed
	\param type : [in] needed image format

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetStoredImage( unsigned short number, bool preview, bool full, data_type type );

//! This function removes the given stored image in the detector
/*!
	\param number : [in] the stored image number to remove

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_RemoveStoredImage( unsigned short number );

//! This function transfers all the stored images into a given directory as fxd files
/*!
	\param dirPath : [in] the requested local transfer path
	\param preview : [in] is preview needed
	\param full : [in] is full image needed
	\param type : [in] needed image format

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_TransferStoredImages( const char* dirPath, bool preview, bool full, data_type type );

//! This function removes every image stored in the detector
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_RemoveAllStoredImages();

//! This function changes the WIFI parameters
/*!
	\param scanChannel : [in] true to scan channel
	\param channel : [in] channel number, only used if scan channel is false
	\param FEPower : [in] power of the front end
	\param DSPower : [in] power of the docking station

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetWifiParameters( bool scanChannel, unsigned short channel, unsigned short FEPower, unsigned short DSPower );

//! This function changes the detector pattern
/*!
	\param pattern : [in] the new detector pattern

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetPattern( detector_pattern pattern );

//! Use to get a pointer on the structure that contains information about the software specifications.
/*!
	\param configParams : [out] Pointer on the structure

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetConfigParameters( ConfigParameters& configParams );

//! Get the current state of the detectors.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetHardwareStatus();

//! Get the current state of a given detector.
/*!
	\param detector : [in] Number of detector

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetDetectorHardwareStatus( unsigned short detector );

//! Get the current state of the wifi
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetWifiStatus();

//! Get the current state of the wifi for a given detector
/*!
	\param detector : [in] Number of detector

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetDetectorWifiStatus( unsigned short detector );

//! Control detector status polling
/*!
	\param detector : [in] Number of detector
	\param enable : [in] true to enable function, false to disable it

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_DetectorStatusPolling( unsigned short detector, bool enable );

//! Get the all current voltages of the detectors.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetVoltage();

//! Get the current system status.
/*!
	\param systemStatus : [out] pointer on system status

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetSystemStatus( SystemStatus& systemStatus );

//! Get the current system calibration time status.
/*!
	\param systemCalibrationTimeStatus : [out] pointer on system calibration time status

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetSystemCalibrationTimeStatus( SystemCalibrationTimeStatus& systemCalibrationTimeStatus );

//! Get the current system state.
/*!
	\param systemState : [out] pointer on system state

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetSystemState( system_state& systemState );

//! Set the system in a defined system state.
/*!
	By default, the system state is in QUIET_STATE
	\param systemState : [in] system state

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetSystemState( system_state systemState );

//! Load the gain reference, the offset reference and the defect map in memory.
/*!
	All the references corresponding to systemMode are stored in fxd files located in
	a path specified in the configuration file.
	The fxd file should contains one image, if not, the first image is loaded.

	\param applicationMode : [in] application mode
	\param operatingMode : [in] operating mode
	\param detectorMode : [in] detector mode
	\param gainReferenceId : [in] number of the gain reference
	\param dmReferenceId : [in] number of the dm reference

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_LoadReferences( application_mode applicationMode = APPLICATION_MODE1, operating_mode operatingMode = OM_DEFAULT, unsigned short detectorMode = defaultDetectorMode,
	unsigned short gainReferenceId = defaultReferenceId, unsigned short dmReferenceId = defaultReferenceId );

//! Load the gain reference in memory.
/*!
	The references corresponding to systemMode is stored in a fxd file located in
	a path specified in the configuration file.
	The fxd file should contains one image, if not, the first image is loaded.

	\param applicationMode : [in] application mode
	\param gainReferenceId : [in] number of the gain reference

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_LoadGainReference( application_mode applicationMode = APPLICATION_MODE1, unsigned short gainReferenceId = defaultReferenceId );

//! Unloand all the references in memory.
/*!
	\param applicationMode : [in] application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_UnloadReferences( application_mode applicationMode = APPLICATION_MODE1 );

//! This function sycnhronizes the references between host and detector
/*!
	\param applicationMode : [in] application mode
	\param type : [in] type of synchronisation

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SynchronizeReferences( application_mode applicationMode = APPLICATION_MODE1, synchronization_type type = SYNCHRO_BIDIRECTIONAL );

//! This function remove the references of the detector
/*!
	\param type : [in] type of removal

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ClearSynchroReferences( removal_type type = REMOVE_ALL );

//! Acquire and create image references that DON'T need xRays.
/*!
	Offset Calibration :
	- Acquire a sequence for each offset delay, average and normalise and store it
	in the system-delay Offset reference file.

	Pixels Cluster Defect Detection
	- Calcul the number of pixels cluster defect and their coordinates and then calcul
	and save pixels cluster defect reference in the PixelsClusterDefect reference file.

	The offset reference is saved in the XXX_OffsetRefZZ_DetModeY.fxd file.
	The pixels cluster reference is saved in the XXX_PixelClusterDefectRef_DetModeY.fxd file
		XXX represents the Detector Serial-number
		Y the Detector mode
		ZZ the  value concerned in the temporal grid
		The gain type is in the name : "GainLinRef" or "GainPolyRef"

	Note: The offset standby reference is saved in the XXX_OffsetRefStandby_DetModeY.fxd file

	\param applicationMode : [in] application mode
	\param operatingMode : [in] operating mode
	\param detectorMode : [in] detector mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_DarkCalibration( application_mode applicationMode = APPLICATION_MODE1, operating_mode operatingMode = OM_DEFAULT,
	unsigned short detectorMode = defaultDetectorMode );

//! Acquire and create image references that need xRays.
/*!
	Gain calibration
	- Acquire a sequence, averages and stores it
	in the system gain reference file specified in the configuration file.

	Update Defect Map
	- The defectmap is also saved in the XXX_DefectMapRef_DetModeY_Z.fxd file.
	The gain reference is saved in the XXX_GainLinRef_DetModeY_W.fxd file (for linear gain)
	or XXX_GainPolyRef_DetModeY_W.fxd file (for each gain poly reference file)
		XXX represents the Detector Serial-number
		Y the Detector mode
		Z the Defect map Reference Id
		W the Gain Refrence Id
		The gain type is in the name : "GainLinRef" or "GainPolyRef"

	\param applicationMode : [in] application mode
	\param gainReferenceId : [in] number of the gain reference
	\param dmReferenceId : [in] number of the dm reference

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_XRayCalibration( application_mode applicationMode = APPLICATION_MODE1, unsigned short gainReferenceId = defaultReferenceId,
	unsigned short dmReferenceId = defaultReferenceId );

//! Acquire and create a gain image reference.
/*!

	The gain reference is saved in the XXX_GainLinRef_DetModeY_W.fxd file
	(for linear gain) or XXX_GainPolyRef_DetModeY_W.fxd file (for all the gain poly references)
		XXX represents the Detector Serial-number
		Y the Detector mode
		W the Gain Id Reference
		The gain type is in the name : "GainLinRef" or "GainPolyRef"

	\param applicationMode : [in] application mode
	\param gainReferenceId : [in] number of the gain reference

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GainCalibration( application_mode applicationMode = APPLICATION_MODE1, unsigned short gainReferenceId = defaultReferenceId );

//! refresh and save all the offset refrences.
/*!
	\param applicationMode : [in] application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_RefreshCalibration( application_mode applicationMode = APPLICATION_MODE1 );

//! generate the dark images for acceptance test (for noiseDSP).
/*!
	\param applicationMode : [in] application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_DarkAcceptanceTest( application_mode applicationMode = APPLICATION_MODE1 );

//! generate the images with x-ray for acceptance test (for ECV, sensitivity, dose field flatness).
/*!
	\param applicationMode : [in]application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_XRayAcceptanceTest( application_mode applicationMode = APPLICATION_MODE1 );

//! computes the required acceptance test (for ECV).
/*!
	\param testType			: [in]acceptance test type
	\param applicationMode	: [in]application mode

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ComputeAcceptanceTest( acceptance_test testType, application_mode applicationMode = APPLICATION_MODE1 );

//! Cancel calibration or acceptance test.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_CancelSequence();

//! allows to pursue calibration or acceptance test
/*!
	Customer system needs to pursue calibration on reception of following events:
	EVT_DOSE_PARAM_REQUEST , EVT_OFFSET_VALID_LIMIT , EVT_OFFSET_INVALID, EVT_X_DOSE_LEVEL,EVT_X_OBJECT_CHECKED , EVT_SEQUENCE_FAILURE .

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ResumeSequence();

//! set the detector currently active.
/*!
	\param activeDetector : [in] Number of detector

	\return ERR_SUCCESS if successfull ERR_ERROR
*/
PIXRAD_API error_status TED_PixRad_SetActiveDetector( unsigned short activeDetector );

//! get the detector currently active.
/*!
	\param activeDetector : [out] Number of the currently active detector

	\return ERR_SUCCESS
*/
PIXRAD_API error_status TED_PixRad_GetActiveDetector( unsigned short& activeDetector );

//! save image references after TED_PixRad_StartAcquisition.
/*!
	The references are saved to fxd files in XXXXXX_YYYY-MM-DD_HH-MM-SS located in the
	"reference path" directory (specified in the configuration file).

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetLastAcquisitionData();

//! performs all detector self tests in sequence.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_PerformDetectorSelfTest();

//! reset detector.
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ResetDetector();

//! Set Output Port.
/*!
	\param boardNumber : [in] board number
	\param outputPort : [in] set output port of ACQ card

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetBoardOutputPort( unsigned short boardNumber, unsigned char outputPort );

//! Get Output Port.
/*!
	\param boardNumber : [in] board number
	\param outputPort : [out] get output port of ACQ card

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetBoardOutputPort( unsigned short boardNumber, unsigned char& outputPort );

//! Get Input Port.
/*!
	\param boardNumber : [in] board number
	\param inputPort : [out] get input port of ACQ card

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetBoardInputPort( unsigned short boardNumber, unsigned char& inputPort );

//! Start the battery calibration
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_StartBatteryCalibration();

//! End the battery calibration
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_StopBatteryCalibration();

//! Control a detector function
/*!
	\param detectorControl : [in] the detector function to control
	\param enable : [in] true to enable function, false to disable it

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_DetectorControl( control_type detectorControl, bool enable );

//! Set a detector parameter value
/*!
	\param detectorParameter : [in] the detector parameter to set
	\param value : [in] the parameter value to set

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_SetDetectorParameterValue( parameter_type detectorParameter, unsigned int value );

//! Get a detector parameter value
/*!
	\param detectorParameter : [in] the detector parameter to get

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetDetectorParameterValue( parameter_type detectorParameter );

//! Get detector information
/*!
	\param detectorInformation : [in] the detector information to get

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_GetDetectorInformation( information_type detectorInformation );

//! Set detector configuration
/*!
    \param detectorConfig : [in] the detector configuration to set
    \param parameter : [in] the configuration parameter to set according to the detector config type

    \return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_DetectorConfig( config_type detectorConfig, const void* parameter );

//! Controls specific detector modes
/*!
	\param applicationMode : [in] application mode
	\param type : [in] application control type
	\param enable: [in] true to enable function, false to disable it

	\return true if valid, false otherwise
*/
PIXRAD_API error_status TED_PixRad_ApplicationControl( application_mode applicationMode, application_control_type controlType, bool enable );

//! Control module polling
/*!
	\param enable : [in] true to enable function, false to disable it

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModulePolling( bool enable );

//! Get specific info from the given module
/*!
	\param moduleNumber : [in] module number
	\param infoType : [in] information type (DETECTOR_SERIAL_NUMBER,DETECTOR_SSID,DETECTOR_IP,DETECTOR_HOST_IP)

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleGetInfo( unsigned short moduleNumber, module_info infoType );

//! Use given module to get infrared id
/*!
	\param moduleNumber : [in] module number

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleGetIrId( unsigned short moduleNumber );

//! Use given module to set new infrared id
/*!
	\param moduleNumber : [in] module number
	\param irId : [in] the infrared id

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleSetIrId( unsigned short moduleNumber, unsigned int irId );

//! Use given module to set a new ip configuration
/*!
	\param moduleNumber : [in] module number
	\param detectorIp : [in] new detector ip
	\param hostIp : [in] new host ip

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleSetIpConfig( unsigned short moduleNumber, const char* detectorIp, const char* hostIp );

//! Use given module to set a new ssid/passwd
/*!
	\param moduleNumber : [in] module number
	\param ssid : [in] new ssid
	\param password : [in] associated password

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleSwitchSSID( unsigned short moduleNumber, const char* ssid, const char* password );

//! Use given module to set a new network configuration ( new ip configuration + new ip configuration )
/*!
	\param moduleNumber : [in] module number
	\param ssid : [in] new ssid
	\param password : [in] associated password
	\param detectorIp : [in] new detector ip
	\param hostIp : [in] new host ip

	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_ModuleSetNetworkConfig( unsigned short moduleNumber, const char* ssid, const char* password, const char* detectorIp, const char* hostIp );

//! Check the validity of a given detector/host ip configuration
/*!
	\param detectorIp : [in] detector ip address ( XX.XX.XX.XX )
	\param hostCIDR : [in] host cidr address ( XX.XX.XX.XX/XX )

	\return true if valid, false otherwise
*/
PIXRAD_API bool TED_PixRad_CheckIpConfig( const char* detectorIp, const char* hostCIDR );

//! Open a new remote storage session on the active detector
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_OpenRemoteStorageSession();

//! Close the remote storage session on the active detector
/*!
	\return ERR_SUCCESS if successfull else error code
*/
PIXRAD_API error_status TED_PixRad_CloseRemoteStorageSession();

#ifdef __cplusplus
}
#endif

#endif //PIXRAD_H