/*
 * etb20.h
 *
 * Copyright (c) 1997-2008 ETEL SA. All Rights Reserved.
 *
 * This software is the confidential and proprietary informatione of ETEL SA
 * ("Confidential Information"). You shall not disclose such Confidential
 * Information and shall use it only in accordance with the terms of the
 * license agreement you entered into with ETEL.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. ETEL AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL ETEL OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF ETEL HAS BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * This software is not designed or intended for use in on-line control of
 * aircraft, air traffic, aircraft navigation or aircraft communications; or in
 * the design, construction, operation or maintenance of any nuclear
 * facility. Licensee represents and warrants that it will not use or
 * redistribute the Software for such purposes.
 *
 */

/**
 * This header file contains public declaration for etel-bus library.\n
 * This library contains all drivers to access to the hardware.\n
 * This library is responsible of the communication protocol.\n
 * This library is conformed to POSIX 1003.1c
 * @file etb20.h
 */


#ifndef _ETB20_H
#define _ETB20_H

#ifdef __WIN32__		/* defined by Borland C++ Builder */
	#ifndef WIN32
		#define WIN32
	#endif
#endif

#ifdef __cplusplus
	#ifdef ETEL_OO_API		/* defined by the user when he need the Object Oriented interface */
		#define ETB_OO_API
	#endif
#endif

 /**
 * @defgroup ETBAll ETB All functions
 */
/*@{*/
/*@}*/

/**
 * @defgroup ETBBus ETB Bus access functions
 */
/*@{*/
/*@}*/

/**
 * @defgroup ETBDownloadUpload ETB Download/Upload functions
 */
/*@{*/
/*@}*/

/**
 * @defgroup ETBErrorsAndWarnings ETB Errors and warnings
 */
/*@{*/
/*@}*/

/**
 * @defgroup ETBPort ETB Port access functions
 */
/*@{*/
/*@}*/

/**
 * @defgroup ETBUtils ETB Utility functions
 */
/*@{*/
/*@}*/

/*----------------------------------------------------------------------------------*/
/* BYTE ORDER */
/*----------------------------------------------------------------------------------*/

#ifndef __BYTE_ORDER

	/*------------------------------*/
	/* Windows Byte order			*/
	#if defined WIN32
		#define __LITTLE_ENDIAN 1234
		#define __BIG_ENDIAN 4321
		#define __BYTE_ORDER __LITTLE_ENDIAN			/* define byte order for INTEL processor */
	#endif /*WIN32*/

	/*------------------------------*/
	/* QNX4 Byte order				*/
	#if defined WIN32 || defined QNX4
		#define __LITTLE_ENDIAN 1234
		#define __BIG_ENDIAN 4321
		#define __BYTE_ORDER __LITTLE_ENDIAN			/* define byte order for INTEL processor */
	#endif /*QNX4*/

	/*------------------------------*/
	/* POSIX SOLARIS Byte order		*/
	#if defined POSIX && defined SOLARIS
		#define __LITTLE_ENDIAN 1234
		#define __BIG_ENDIAN 4321
		#ifdef _BIG_ENDIAN
			#define __BYTE_ORDER __BIG_ENDIAN			/* define byte order for SPARC processor */
		#else
			#define __BYTE_ORDER __LITTLE_ENDIAN        /* define byte order for SPARC processor */
		#endif
	#endif /*SOLARIS*/

	/*------------------------------*/
	/* POSIX LINUX Byte order		*/
	#if defined POSIX && defined LINUX
		#include <endian.h>
	#endif /*LINUX*/

	/*------------------------------*/
	/* POSIX XENOMAI Byte order		*/
	#if defined POSIX && defined XENOMAI
		#include <endian.h>
	#endif /*XENOMAI*/

	/*------------------------------*/
	/* POSIX QNX6 Byte order		*/
	#if defined POSIX && defined QNX6
		#define __LITTLE_ENDIAN 1234
		#define __BIG_ENDIAN 4321
		#ifdef __BIGENDIAN__
			#define __BYTE_ORDER __BIG_ENDIAN			/* define byte order for SPARC processor */
		#else
			#define __BYTE_ORDER __LITTLE_ENDIAN        /* define byte order for SPARC processor */
		#endif
	#endif /*QNX6*/

	/*------------------------------*/
	/* VXWORKS Byte order			*/
	#ifdef VXWORKS
		#define __LITTLE_ENDIAN _LITTLE_ENDIAN
		#define __BIG_ENDIAN _BIG_ENDIAN
		#define __BYTE_ORDER _BYTE_ORDER
	#endif /*VXWORKS*/

#endif /*BYTE_ORDER*/


/**********************************************************************************************************/
/*- LIBRARIES */
/**********************************************************************************************************/

#if defined ETB_OO_API && defined _DSA30_H
	#error dsa30.h must be included AFTER etb20.h
#endif

#ifdef __cplusplus
	extern "C" {
#endif


/*----------------------*/
/* common libraries		*/
#include <time.h>
#include <string.h>
#include <stdarg.h>



/**********************************************************************************************************/
/*- LITTERALS */
/**********************************************************************************************************/

#define ETB_DRIVES                       32           /* the maximum number of drives in an old bus type like */
													  /* EBL2, DSMAX1, DSMAX2, DSMAX3, DSTEB1, DSTEB3 */
													  /* The records passing on these kinds of bus are ETB_REC */
#define ETB_ETCOM_DRIVES                 64           /* the maximum number of drives in an new bus type like */
													  /* UltimET, USB for AccurET */
													  /* The records passing on these kinds of bus are ETB_ETCOM */
#define ETB_SERVERS                      4            /* the maximum number of servers in the path */


/*------------------------------------------------------------------------------
 * error codes - c
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
#define ETB_ERTVREADSYNCRO               -294        /**< RTV read synchronisation error */
#define ETB_EBADDRIVER                   -293        /**< wrong version of the installed device driver */
#define ETB_EBAUDRATE                    -292        /**< matching baudrate not found */
#define ETB_EFPGAFILENOTFOUND            -291        /**< FPGA file is not found in path */
#define ETB_EUNAVAILABLE                 -290        /**< function not available for the driver */
#define ETB_EGPIODEV                     -286        /**< cannot open the gpio device */
#define ETB_EFLASHNOTLOCKED              -285        /**< flash not locked */
#define ETB_EFLASHPROTECTED              -284        /**< flash protected */
#define ETB_EFLASHWRITE                  -283        /**< unable to write flash */
#define ETB_EFLASHREAD                   -282        /**< unable to read flash */
#define ETB_EFLASHINFO                   -281        /**< unable to read flash information */
#define ETB_EFLASHDEV                    -280        /**< unable to open flash device */
#define ETB_EBADOS                       -270        /**< function unavilable on actual OS */
#define ETB_EBOOTPROG                    -263        /**< bad block programming */
#define ETB_EBOOTHEADER                  -262        /**< bad header in boot protocol */
#define ETB_EBOOTENTER                   -261        /**< cannot enter in boot mode */
#define ETB_EBOOTPASSWD                  -260        /**< bad password when enter in boot mode */
#define ETB_EBADHOST                     -253        /**< the specified host address cannot be translated */
#define ETB_ENETWORK                     -252        /**< network problem */
#define ETB_ESOCKRESET                   -251        /**< the socket connection has been broken by peer */
#define ETB_EOPENSOCK                    -250        /**< the specified socket connection cannot be opened */
#define ETB_ECHECKSUM                    -249        /**< checksum error with serial communication */
#define ETB_EOPENCOM                     -240        /**< the specified communication port cannot be opened */
#define ETB_ECRC                         -230        /**< a CRC error has occured */
#define ETB_EBOOTFAILED                  -229        /**< a problem has occured while communicating with the boot */
#define ETB_EBADMODE                     -225        /**< the drive is in a bad mode */
#define ETB_EBADSERVER                   -224        /**< a bad/incompatible server was found */
#define ETB_ESERVER                      -223        /**< the server has incorrect behavior */
#define ETB_EBADSTATE                    -222        /**< this operation is not allowed in this state */
#define ETB_EBUSRESET                    -221        /**< the underlaying etel-bus in performing a reset operation */
#define ETB_EBUSERROR                    -220        /**< the underlaying etel-bus is in error state */
#define ETB_EBADMSG                      -219        /**< a bad message is given */
#define ETB_EBADDRVVER                   -218        /**< a drive with a version < 3.00 has been detected */
#define ETB_EBADLIBRARY                  -217        /**< function of external library not found */
#define ETB_ENOLIBRARY                   -216        /**< external library not found */
#define ETB_EBADPARAM                    -215        /**< one of the parameter is not valid */
#define ETB_ENODRIVE                     -214        /**< the specified drive does not respond */
#define ETB_EMASTER                      -213        /**< cannot enter or quit master mode */
#define ETB_EINTERNAL                    -212        /**< some internal error in the etel software */
#define ETB_ESYSTEM                      -211        /**< some system resource return an error */
#define ETB_ETIMEOUT                     -210        /**< a timeout has occured */
#define ETB_ETOOSMALL                    -203        /**< the size of the record table is too small */
#define ETB_EOBSOLETE                    -202        /**< function is obsolete */
#define ETB_ERECTOSMALL                  -201        /**< size of received record too small */
#define ETB_EBADFIRMWARE                 -200        /**< file is not a firmware file */

#endif

/*------------------------------------------------------------------------------
 * timeout special values
 *-----------------------------------------------------------------------------*/
#ifndef INFINITE
	#define INFINITE                         0xFFFFFFFF  /* infinite timeout */
#endif
#ifndef ETB_OO_API
	#define ETB_DEF_TIMEOUT                  (-2L)       /* use the default timeout appropriate for this communication */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * open/reset/close flags
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_FLAG_BOOT_RUN                0x00000001  /* assumes that the drive is in run mode */
	#define ETB_FLAG_BOOT_DIRECT             0x00000002  /* assumes that the drive is in boot mode */
	#define ETB_FLAG_BOOT_BRIDGE             0x00000004  /* assumes that the drive is in boot bridge mode */

	#define ETB_FLAG_MASTER_BRIDGE           0x00000010  /* enter master if an axis 0 is connected */
	#define ETB_FLAG_MASTER_EXIT             0x00000020  /* return to slave mode if the axis 0 is in master mode */
	#define ETB_FLAG_MASTER_NORMAL           0x00000040  /* enter master mas.0=1 if an axis 0 is connected */
	#define ETB_FLAG_MASTER_SPY              0x00000080  /* enter master mas.!=255 */

	#define ETB_FLAG_TIMEOUT_GUARDED         0x00000100  /* check for continous connection in both pc and drive side */
	#define ETB_FLAG_TIMEOUT_DEBUG           0x00000200  /* allows disconnection of the communication - try to recover */
	#define ETB_FLAG_TIMEOUT_DISABLE         0x00000400  /* disable all timeouts on the drive side - try to recover */

	#define ETB_FLAG_STATUS_POLL             0x00001000  /* continuously send status drive status requests */
	#define ETB_FLAG_STATUS_OFF              0x00002000  /* don't send drive status requests */
	#define ETB_FLAG_STATUS_IRQ              0x00004000  /* use drive interrupt to poll status */
	#define ETB_FLAG_DETECT_OFF              0x00008000  /* don't send any traffics wihtout requests */

	#define ETB_FLAG_CAN_STANDARD            0x00100000  /* use CAN standard 11 bit identifiers */
	#define ETB_FLAG_CAN_EXTENDED            0x00200000  /* use CAN extended 29 bit identifiers */

	/* These flags are for ETEL advanced users only */
	#define ETB_FLAG_SYNCHRO_OFF             0x01000000  /* communication detection and bus synchronization offline */
	#define ETB_FLAG_ALL_REQUEST_OFF         0x02000000  /* don't send any request */
	#define ETB_FLAG_INFO_DRIVE_OFF          0x04000000  /* don't ask drivers informations */
	#define ETB_FLAG_INFO_EXTENSION_OFF      0x08000000  /* don't ask extensions informations */

	#define ETB_FLAG_SPECIAL_SL              0x10000000  /* use speed loop drive - special mode for download only */

	#define ETB_FLAG_RESET_MASTER            0x20000000  /* reset the master (used only with DSMAX) */
	#define ETB_FLAG_RESET_SLAVES            0x40000000  /* reset all slaves (used only with DSC) */

	#define ETB_FLAG_DEBUG_MODE              0x80000000  /* the communication is in a special mode for debug */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * boot modes
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_BOOT_MODE_RUN                0           /* drive run mode - normal operation */
	#define ETB_BOOT_MODE_DIRECT             1           /* direct communication to the connected drive boot */
	#define ETB_BOOT_MODE_BRIDGE             2           /* allows access to etel bus slave boot */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * special axis number
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_AXIS_AND                     (-2)        /* and value of the status bits of all drives presents */
	#define ETB_AXIS_OR                      (-1)        /* or value of the status bits of all drives presents */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * server (record 00h) command numbers
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_R_SVR_NUMBER                 0x11        /* get the number of remote servers in the chain */
	#define ETB_R_SVR_INFO_0                 0x12        /* get the product number and soft version of server */
	#define ETB_R_SVR_INFO_1                 0x13        /* get the serial number and boot version */
	#define ETB_R_SVR_INFO_2                 0x14        /* get the name (8 first bytes )*/
	#define ETB_R_SVR_TIMEOUTS_0             0x15        /* get the bus default timeouts of a remote server */
	#define ETB_R_SVR_INFO_3                 0x16        /* get the name (8 last bytes )*/
	#define ETB_R_SVR_STATUS_0               0x21        /* get the bus status of a remote server */
	#define ETB_R_SVR_STATUS_IRQ_0           0x22        /* the bus status interrupt of a remote server */
	#define ETB_R_SVR_COUNTERS_0             0x25        /* get the bus counters of a remote server */
	#define ETB_R_SVR_COUNTERS_IRQ_0         0x26        /* the bus counters interrupt of a remote server */
	#define ETB_R_SVR_KIND	                 0x27        /* the kind of the server */
	#define ETB_R_CHANGE_BOOT_MODE           0x31        /* change the boot mode of the remote drive */
	#define ETB_R_START_DOWNLOAD             0x32        /* start download of the remote drive */
	#define ETB_R_DOWNLOAD_SEGMENT           0x33        /* download a data segment in the remote drive */
	#define ETB_R_START_UPLOAD               0x34        /* start upload of the remote drive */
	#define ETB_R_UPLOAD_SEGMENT             0x35        /* upload a data segment in the remote drive */
	#define ETB_R_AUTO_NUMBER                0x36        /* renumber the remote drives. Obsolete */
	#define ETB_R_START_DOWNLOAD_FILE        0x37        /* start download of a complete file to the remote drive */
	#define ETB_R_ACTIVATE_DOWNLOAD          0x38        /* activate the new downloaded firmware (dsgat2 only) */
	#define ETB_R_START_UPLOAD_FILE          0x39        /* start upload of a complete file from the remote drive */
	#define ETB_R_OPEN                       0x41        /* open a new connection - first message */
	#define ETB_R_RESET                      0x42        /* reset the current connection to the server */
	#define ETB_R_CLOSE                      0x43        /* close the current connection - last message */
	#define ETB_R_KEEP_ALIVE                 0x44        /* keep connection with the server alive */
	#define ETB_R_START_IRQ                  0x45        /* ask server to start sendnig irqs when required */
	#define ETB_R_PURGE_STOP                 0x46        /* purge queues and stop sending data / interrupts */
	#define ETB_R_MULTI_SEND                 0x50        /* send multiple records */
	#define ETB_R_ALIVE_RATE                 0x60        /* message to define timeout of connection break */
	#define ETB_R_DOWNLOAD_DATA			     0xF1        /* start download of a set of data */
	#define ETB_R_UPLOAD_DATA			     0xF3        /* start upload of a set of data */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * magic commands for record 04/12/14
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_MAGIC_WAITING_REC_14         0x80        /* denotes a waiting request (record 14) */
	#define ETB_MAGIC_PRESENT                0x90        /* denotes a drive present request (record 14) */
	#define ETB_MAGIC_WAITING_REC_12         0x80        /* denotes a waiting request (record 12) */
	#define ETB_MAGIC_STATUS_DRV_0           0x90        /* denotes a drive status request (record 12) */
	#define ETB_MAGIC_STATUS_DRV_IRQ_0       0xA0        /* denotes a drive status interrupt (record 12) */
	#define ETB_MAGIC_INFO_DRV_0             0xB0        /* denotes the first drive information request (record 12) */
	#define ETB_MAGIC_INFO_DRV_1             0xC0        /* denotes the second drive information request (record 12) */
	#define ETB_MAGIC_INFO_DRV_2             0xC1        /* denotes the third drive information request (record 12) */
	#define ETB_MAGIC_INFO_DRV_3             0xC2        /* denotes the fourth drive information request (record 12) */
	#define ETB_MAGIC_INFO_DRV_4             0xC3        /* denotes the fourth drive information request (record 12) */
	#define ETB_MAGIC_INFO_EXT_0             0xD0        /* denotes the first extension card information request (record 12) */
	#define ETB_MAGIC_INFO_EXT_1             0xE0        /* denotes the second extension card information request (record 12) */
	#define ETB_MAGIC_STATUS_DRV_PRESENT     0xF0        /* denotes a drive present request on umaster (record 12) */
	#define ETB_MAGIC_INFO_MASTER_0			 0x10        /* denotes a master specific information request (record 12) */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * real-time modes
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_RT_ACTIVE                    1           /* real-time is running */
	#define ETB_RT_IDLE                      0           /* real-time is idle */
	#define ETB_RT_ERROR                     -1          /* real-time is in error */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * etb special axis number
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_ALL_AXIS                     0x40        /* special axis value meaning all axis */
	#define ETB_MSK_AXIS                     0x20        /* special axis value meaning masked axis */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * etel bus events
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_BEV_ERROR_SET                0x00000001  /* the error bit has been set */
	#define ETB_BEV_ERROR_CLR                0x00000002  /* the error bit has been cleared */
	#define ETB_BEV_ERROR                    0x00000003  /* the error bit has changed */
	#define ETB_BEV_WARNING_SET              0x00000004  /* the warning bit has been set */
	#define ETB_BEV_WARNING_CLR              0x00000008  /* the warning bit has been cleared */
	#define ETB_BEV_WARNING                  0x0000000C  /* the warning bit has changed */
	#define ETB_BEV_RESET_SET                0x00000010  /* the driver has entered reset mode */
	#define ETB_BEV_RESET_CLR                0x00000020  /* the driver has exited reset mode */
	#define ETB_BEV_RESET                    0x00000030  /* the reset bit has changed */
	#define ETB_BEV_OPEN_SET                 0x00000040  /* the driver is open */
	#define ETB_BEV_OPEN_CLR                 0x00000080  /* the driver is closed */
	#define ETB_BEV_OPEN                     0x000000C0  /* the open bit has changed */
	#define ETB_BEV_WATCHDOG_SET             0x00000100  /* the watchdog bit has been set */
	#define ETB_BEV_WATCHDOG_CLR             0x00000200  /* the watchdog bit has been cleared */
	#define ETB_BEV_WATCHDOG                 0x00000300  /* the watchdog bit has changed */
	#define ETB_BEV_STATUS                   0x00001000  /* the bus status has changed */
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * etel bus drive events
 *-----------------------------------------------------------------------------*/
#ifndef ETB_OO_API
	#define ETB_DEV_ERROR_SET                0x00000001  /* one of the error bit has been set */
	#define ETB_DEV_ERROR_CLR                0x00000002  /* one of the error bit has been cleared */
	#define ETB_DEV_ERROR                    0x00000003  /* one of the error bit has changed */
	#define ETB_DEV_WARNING_SET              0x00000004  /* one of the warning bit has been set */
	#define ETB_DEV_WARNING_CLR              0x00000008  /* one of the warning bit has been cleared */
	#define ETB_DEV_WARNING                  0x0000000C  /* one of the warning bit has changed */
	#define ETB_DEV_PRESENT_SET              0x00000010  /* a new drive is present */
	#define ETB_DEV_PRESENT_CLR              0x00000020  /* a drive has disappeared */
	#define ETB_DEV_PRESENT                  0x00000030  /* the present bit has changed */
	#define ETB_DEV_STATUS_1                 0x00000100  /* the first status word has changed */
	#define ETB_DEV_STATUS_2                 0x00000200  /* the second status word has changed */
	#define ETB_DEV_STATUS                   0x00000300  /* one of the status word has changed */
	#define ETB_DEV_USER                     0x00001000  /* the user field has changed */
#endif /* ETB_OO_API */


/**********************************************************************************************************/
/*- MACROS */
/**********************************************************************************************************/

/*-------------------------------------------------------------------------------------------------*/
/* Diagnostic call for old type bus (EBL2, DSMAX1, DSMAX2, DSMAX3, DSTEB1, DSTEB3) */
#define ETB_DIAG(err, etb, mask)						{etb_diag(__FILE__, __LINE__, err, etb, mask);}
#define ETB_SDIAG(str, err, etb, mask)					{etb_sdiag(str, __FILE__, __LINE__, err, etb, mask);}
#define ETB_FDIAG(output_file_name, err, etb, mask)		{etb_fdiag(output_file_name, __FILE__, __LINE__, err, etb, mask);}

/*-------------------------------------------------------------------------------------------------*/
/* Diagnostic call for new type bus (UltimET, AccurET)*/
#define ETB_ETCOM_DIAG(err, etb, mask)						{etb_etcom_diag(__FILE__, __LINE__, err, etb, mask);}
#define ETB_ETCOM_SDIAG(str, err, etb, mask)				{etb_etcom_sdiag(str, __FILE__, __LINE__, err, etb, mask);}
#define ETB_ETCOM_FDIAG(output_file_name, err, etb, mask)	{etb_etcom_fdiag(output_file_name, __FILE__, __LINE__, err, etb, mask);}

#define ETB_CONST_REC                        const

/**********************************************************************************************************/
/*- TYPES */
/**********************************************************************************************************/

/*------------------------------------------------------------------------------
 * type modifiers
 *-----------------------------------------------------------------------------*/
/*------------------------------*/
/* WINDOWS type modifiers		*/
#ifdef WIN32
	#define _ETB_EXPORT __cdecl                          /* function exported by static library */
	#define ETB_CALLBACK __cdecl                         /* client callback function called by library */
#endif /* WIN32 */

/*------------------------------*/
/* QNX4 type modifiers			*/
#ifdef QNX4
	#define _ETB_EXPORT   __cdecl                        /* function exported by library */
	#define ETB_CALLBACK  __cdecl                        /* client callback function called by library */
#endif /* QNX4 */

/*------------------------------*/
/* POSIX type modifiers			*/
#ifdef POSIX
	#define _ETB_EXPORT                           /* function exported by library */
	#define ETB_CALLBACK                          /* client callback function called by library */
#endif /*POSIX*/

/*------------------------------*/
/* VXWORKS type modifiers		*/
#ifdef VXWORKS
	#define _ETB_EXPORT                           /* function exported by library */
	#define ETB_CALLBACK                          /* client callback function called by library */
#endif /*VXWORKS*/

/*------------------------------------------------------------------------------
 * hidden structures for library clients
 *-----------------------------------------------------------------------------*/
#ifndef ETB
	#define ETB void
#endif
#ifndef ETB_PORT
	#define ETB_PORT void
#endif

/*------------------------------------------------------------------------------
 * extended types
 *-----------------------------------------------------------------------------*/
/*--------------------------*/
/* byte type				*/
#ifndef __BYTE
	#define __BYTE
	typedef unsigned char byte;
#endif

/*--------------------------*/
/* word type				*/
#ifndef __WORD
	#define __WORD
	typedef unsigned short word;
#endif

/*--------------------------*/
/* dword type				*/
#ifndef __DWORD
	#define __DWORD
	typedef unsigned int dword;
#endif

/*--------------------------*/
/* char_p type				*/
#ifndef __CHAR_P
	#define __CHAR_P
	typedef char *char_p;
#endif

/*--------------------------*/
/* char_cp type				*/
#ifndef __CHAR_CP
	#define __CHAR_CP
	typedef const char *char_cp;
	#ifndef __cplusplus
		#ifndef __BOOL
			#define __BOOL
			typedef byte bool;
		#endif /*BOOL */
	#endif /*__cplusplus */
#endif /*CHAR_CP */

/*--------------------------*/
/* 64 bits integer			*/
#ifndef __INT64
	#define __INT64
	#if __BYTE_ORDER == __LITTLE_ENDIAN
		typedef struct INT64_DWORD_MODE {
			dword low_dword;
			dword high_dword;
		} INT64_DWORD_MODE;
	#else /*__BYTE_ORDER*/
		typedef struct INT64_DWORD_MODE {
			dword high_dword;
			dword low_dword;
		} INT64_DWORD_MODE;
	#endif /*__BYTE_ORDER*/

	#if __BYTE_ORDER == __LITTLE_ENDIAN
		typedef struct INT64_BYTE_MODE {
			byte byte0;
			byte byte1;
			byte byte2;
			byte byte3;
			byte byte4;
			byte byte5;
			byte byte6;
			byte byte7;
		} INT64_BYTE_MODE;
	#else /*__BYTE_ORDER*/
		typedef struct INT64_BYTE_MODE {
			byte byte7;
			byte byte6;
			byte byte5;
			byte byte4;
			byte byte3;
			byte byte2;
			byte byte1;
			byte byte0;
		} INT64_BYTE_MODE;
	#endif /*__BYTE_ORDER*/

	/*------------------------------*/
	/* WINDOWS 64 bits integer		*/
	#if defined WIN32
		#ifdef _MSC_VER
			//Microsoft Compiler <= 6
			#if _MSC_VER <= 1200
				#define eint64 _int64
			#else
				#define eint64 long long
			#endif
		#else
				#define eint64 long long
		#endif
	/*------------------------------*/
	/* POSIX 64 bits integer		*/
	#elif defined POSIX
		#define eint64 long long
	/*--------------------------------------*/
	/* QNX4 and VXWORKS 64 bits integer		*/
	/* On these systems,64 bits integer are not standard */
	#elif (defined QNX4 || defined VXWORKS)
		typedef union eint64 {
			INT64_DWORD_MODE dwords;
			INT64_BYTE_MODE bytes;
			byte raw[8];
		} eint64;
	#endif
#endif

/*------------------------------------------------------------------------------
 * EtbSW1BitMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbSW1BitMode
 * Allow access to drive status 1 (M60) with bit members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbSW1BitMode {
	#ifndef ETB_OO_API
	unsigned power_on:1;				/**< The power is applied to the motor */
	unsigned init_done:1;				/**< The initialisation procedure has been done */
	unsigned homing_done:1;				/**< The homing procedure has been done */
	unsigned present:1;					/**< The drive is present */
	unsigned moving:1;					/**< The motor is moving */
	unsigned in_window:1;				/**< The motor is the target windows */
	unsigned master:1;                  /**< The drive is in master mode */
	unsigned busy:1;                    /**< The drive is busy */
	unsigned exec_seq:1;                /**< A sequence is running */
	unsigned edit_mode:1;               /**< The sequence can be edited */
	unsigned fatal:1;                   /**< Fatal error */
	unsigned trace_busy:1;              /**< The aquisition of the trace is not finished */
	unsigned bridge:1;                  /**< The drive is in bridge mode */
	unsigned homing:1;                  /**< The motor is homing */
	unsigned ebl_to_eb:1;               /**< The EBL is routed transparentrly to EB (download) */
	unsigned spy:1;                     /**< A slave is used as a spy: master of labView channel */
	unsigned warning:8;                 /**< Warning mask */
	unsigned error:8;                   /**< Error mask */
	#else /* ETB_OO_API */
	unsigned powerOn:1;                 /**< The power is applied to the motor */
	unsigned initDone:1;                /**< The initialisation procedure has been done */
	unsigned homingDone:1;              /**< The homing procedure has been done */
	unsigned present:1;                 /**< The drive is present */
	unsigned moving:1;                  /**< The motor is moving */
	unsigned inWindow:1;                /**< The motor is the target windows */
	unsigned master:1;                  /**< The drive is in master mode */
	unsigned busy:1;                    /**< The drive is busy */
	unsigned execSeq:1;                 /**< A sequence is running */
	unsigned editMode:1;                /**< The sequence can be edited */
	unsigned fatal:1;                   /**< Fatal error */
	unsigned traceBusy:1;               /**< The aquisition of the trace is not finished */
	unsigned bridge:1;                  /**< The drive is in bridge mode */
	unsigned homing:1;                  /**< The motor is homing */
	unsigned eblToEb:1;                 /**< The EBL is routed transparentrly to EB (download) */
	unsigned spy:1;                     /**< A slave is used as a spy: master of labView channel */
	unsigned warning:8;                 /**< Warning mask */
	unsigned error:8;                   /**< Error mask */
	#endif /* ETB_OO_API */
} EtbSW1BitMode;
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct EtbSW1BitMode {
	#ifndef ETB_OO_API
	unsigned error:8;                   /**< Error mask */
	unsigned warning:8;                 /**< Warning mask */
	unsigned spy:1;                     /**< A slave is used as a spy: master of labView channel */
	unsigned ebl_to_eb:1;               /**< The EBL is routed transparentrly to EB (download) */
	unsigned homing:1;                  /**< The motor is homing */
	unsigned bridge:1;                  /**< The drive is in bridge mode */
	unsigned trace_busy:1;              /**< The aquisition of the trace is not finished */
	unsigned fatal:1;                   /**< Fatal error */
	unsigned edit_mode:1;               /**< The sequence can be edited */
	unsigned exec_seq:1;                /**< A sequence is running */
	unsigned busy:1;                    /**< The drive is busy */
	unsigned master:1;                  /**< The drive is in master mode */
	unsigned in_window:1;               /**< The motor is the target windows */
	unsigned moving:1;                  /**< The motor is moving */
	unsigned present:1;                 /**< The drive is present */
	unsigned homing_done:1;             /**< The homing procedure has been done */
	unsigned init_done:1;               /**< The initialisation procedure has been done */
	unsigned power_on:1;                /**< The power is applied to the motor */
	#else /* ETB_OO_API */
	unsigned error:8;                   /**< Error mask */
	unsigned warning:8;                 /**< Warning mask */
	unsigned spy:1;                     /**< A slave is used as a spy: master of labView channel */
	unsigned eblToEb:1;                 /**< The EBL is routed transparentrly to EB (download) */
	unsigned homing:1;                  /**< The motor is homing */
	unsigned bridge:1;                  /**< The drive is in bridge mode */
	unsigned traceBusy:1;               /**< The aquisition of the trace is not finished */
	unsigned fatal:1;                   /**< Fatal error */
	unsigned editMode:1;                /**< A sequence is running */
	unsigned execSeq:1;                 /**< A sequence is running */
	unsigned busy:1;                    /**< The drive is busy */
	unsigned master:1;                  /**< The drive is in master mode */
	unsigned inWindow:1;                /**< The motor is the target windows */
	unsigned moving:1;                  /**< The motor is moving */
	unsigned present:1;                 /**< The drive is present */
	unsigned homingDone:1;              /**< The homing procedure has been done */
	unsigned initDone:1;                /**< The initialisation procedure has been done */
	unsigned powerOn:1;                 /**< The power is applied to the motor */
	#endif /* ETB_OO_API */
} EtbSW1BitMode;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * ETB_SW1 type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_SW1
 * Contains status 1 of devices (M60)
 */
typedef union ETB_SW1 {
	dword l;							/**< Status 1 for acces in double word format */
	EtbSW1BitMode s;					/**< Status 1 for access in bit format */
} ETB_SW1;


/*------------------------------------------------------------------------------
 *  EtbSW2BitMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbSW2BitMode
 * Allow access to drive status 2 (M61) with bit members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbSW2BitMode {
	#ifndef ETB_OO_API
	unsigned seq_error:1;               /**< Error label has been executed */
	unsigned seq_warning:1;             /**< Warning label has been executed */
	unsigned :6;
	unsigned user:8;                    /**< User status */
	unsigned :12;
	unsigned dll:4;                     /**< Used internally by dlls */
	#else /* ETB_OO_API */
	unsigned seqError:1;                /**< Error label has been executed */
	unsigned seqWarning:1;              /**< Warning label has been executed */
	unsigned :6;
	unsigned user:8;                    /**< User status */
	unsigned :12;
	unsigned dll:4;                     /**< Used internally by dlls */
	#endif /* ETB_OO_API */
} EtbSW2BitMode;

#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct EtbSW2BitMode {
	#ifndef ETB_OO_API
	unsigned dll:4;                     /**< Used internally by dlls */
	unsigned :12;
	unsigned user:8;                    /**< User status */
	unsigned :6;
	unsigned seq_warning:1;             /**< Warning label has been executed */
	unsigned seq_error:1;               /**< Error label has been executed */
	#else /* ETB_OO_API */
	unsigned dll:4;                     /**< Used internally by dlls */
	unsigned :12;
	unsigned user:8;                    /**< User status */
	unsigned :6;
	unsigned seqWarning:1;              /**< Warning label has been executed */
	unsigned seqError:1;                /**< Error label has been executed */
	#endif /* ETB_OO_API */
} EtbSW2BitMode;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 *  ETB_SW2 type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_SW2
 * Contains status 2 of devices (M61)
 */
typedef union ETB_SW2 {
	dword l;							/**< Status 2 for acces in double word format */
	EtbSW2BitMode s;					/**< Status 2 for access in bit format */
} ETB_SW2;


/*------------------------------------------------------------------------------
 *  ETB_DRV_STATUS type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_DRV_STATUS
 * Etel bus drive status
 */
typedef struct ETB_DRV_STATUS {
    size_t size;							/**< The size of the structure */
    ETB_SW1 sw1;								/**< Status 1 (M60)*/
    ETB_SW2 sw2;								/**< Status 2 (M61)*/
} ETB_DRV_STATUS;

#define EtbDrvStatus ETB_DRV_STATUS


/*------------------------------------------------------------------------------
 *  EtbRecParamBitMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecParamBitMode
 * Allow acces to Etel bus message parameter with bit members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecParamBitMode {
    unsigned idx:16;                        /**< Index in specified address space */
    unsigned sidx:8;                        /**< Sub-index in specified address space */
    unsigned axis:7;                        /**< Axis or bit number */
    unsigned bit:1;                         /**< Bit flag (bit field, rec 0x14) */
} EtbRecParamBitMode;

#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct EtbRecParamBitMode {
    unsigned bit:1;                         /**< Bit flag (bit field, rec 0x14) */
    unsigned axis:7;                        /**< Axis or bit number */
    unsigned sidx:8;                        /**< Sub-index in specified address space */
    unsigned idx:16;                        /**< Index in specified address space */
} EtbRecParamBitMode;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 *   ETB_REC_PARAM type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_REC_PARAM
 * Etel bus message parameter
 */
typedef union ETB_REC_PARAM {
    long l;									/**< Parameter for access in long format*/
	EtbRecParamBitMode v;					/**< Parameter for access in bit format*/
} ETB_REC_PARAM;

#define EtbRecParam ETB_REC_PARAM


/*------------------------------------------------------------------------------
 * EtbRecRawMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRawMode
 * Allows access to Etb record with raw members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRawMode {
	byte raw0;						/**< Byte 0 of record */
	byte raw1;						/**< Byte 1 of record */
	byte raw2;						/**< Byte 2 of record */
	byte raw3;						/**< Byte 3 of record */
	byte raw4;						/**< Byte 4 of record */
	byte raw5;						/**< Byte 5 of record */
	byte raw6;						/**< Byte 6 of record */
	byte raw7;						/**< Byte 7 of record */
	byte raw8;						/**< Byte 8 of record */
	byte raw9;						/**< Byte 9 of record */
	byte raw10;						/**< Byte 10 of record */
	byte raw11;						/**< Byte 11 of record */
} EtbRecRawMode;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRawMode {
	byte raw3;						/**< Byte 3 of record */
	byte raw2;						/**< Byte 2 of record */
	byte raw1;						/**< Byte 1 of record */
	byte raw0;						/**< Byte 0 of record */
	byte raw7;						/**< Byte 7 of record */
	byte raw6;						/**< Byte 6 of record */
	byte raw5;						/**< Byte 5 of record */
	byte raw4;						/**< Byte 4 of record */
	byte raw11;						/**< Byte 11 of record */
	byte raw10;						/**< Byte 10 of record */
	byte raw9;						/**< Byte 9 of record */
	byte raw8;						/**< Byte 8 of record */
} EtbRecRawMode;
#endif

/*------------------------------------------------------------------------------
 * EtbRecDataByteMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecDataByteMode
 * Allows access to Etb record's datas in byte mode
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecDataByteMode {
	byte d0;						/**< Byte 0 of record's data*/
	byte d1;						/**< Byte 1 of record's data*/
	byte d2;						/**< Byte 2 of record's data*/
	byte d3;						/**< Byte 3 of record's data*/
	byte d4;						/**< Byte 4 of record's data*/
	byte d5;						/**< Byte 5 of record's data*/
	byte d6;						/**< Byte 6 of record's data*/
	byte d7;						/**< Byte 7 of record's data*/
} EtbRecDataByteMode;
#else /*_BYTE_ORDER*/
typedef struct EtbRecDataByteMode {
	byte d3;						/**< Byte 3 of record's data*/
	byte d2;						/**< Byte 2 of record's data*/
	byte d1;						/**< Byte 1 of record's data*/
	byte d0;						/**< Byte 0 of record's data*/
	byte d7;						/**< Byte 7 of record's data*/
	byte d6;						/**< Byte 6 of record's data*/
	byte d5;						/**< Byte 5 of record's data*/
	byte d4;						/**< Byte 4 of record's data*/
} EtbRecDataByteMode;
#endif

/*------------------------------------------------------------------------------
 * EtbRecData type
 *-----------------------------------------------------------------------------*/
/**
 * @union EtbRecData
 * Etel bus message datas
 */
typedef union EtbRecData {
	byte d[8];						/**< Datas for access in table of bytes */
	EtbRecDataByteMode ds;			/**< Datas for access in bytes */
} EtbRecData;

/*------------------------------------------------------------------------------
 * EtbRecAll type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecAll
 * Allows access to Etel bus general message
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecAll {
    unsigned rec:6;                 /**< Record number */
    unsigned irq:1;                 /**< Interrupt request flag */
    unsigned error:1;               /**< Error bit */
    unsigned axis:7;                /**< Axis number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned extra:16;              /**< Extra header information */
	EtbRecData data;				/**< Message's datas */
} EtbRecAll;
#else /*__BYTE_ORDER*/
typedef struct EtbRecAll {
    unsigned extra:16;              /**< Extra header information */
    unsigned ack:1;                 /**< Ack bit */
    unsigned axis:7;                /**< Axis number */
    unsigned error:1;               /**< Error bit */
    unsigned irq:1;                 /**< Interrupt request flag */
    unsigned rec:6;                 /**< Record number */
	EtbRecData data;				/**< Message's datas */
} EtbRecAll;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx12Par type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx12Par
 * Allows access to Parameters of Etel bus send message Type 0x12
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx12Par {
	unsigned idx:16;                /**< Index in specified address space */
    unsigned sidx:8;                /**< Sub-index in specified address space */
    unsigned axis:7;                /**< Record number */
    unsigned :1;
} EtbRecTx12Par;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx12Par {
    unsigned :1;
    unsigned axis:7;                /**< Record number */
    unsigned sidx:8;                /**< Sub-index in specified address space */
	unsigned idx:16;                /**< Index in specified address space */
} EtbRecTx12Par;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx12Par type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx12 {
 * Allows access to Etel bus send message Type 0x12
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx12 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned :8;
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	EtbRecTx12Par par1;             /**< First parameter value */
    EtbRecTx12Par par2;             /**< Second parameter value */
} EtbRecTx12;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx12 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned :8;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	EtbRecTx12Par par1;		        /**< First parameter value */
    EtbRecTx12Par par2;			    /**< Second parameter value */
} EtbRecTx12;
#endif/*__BYTE_ORDER*/


/*------------------------------------------------------------------------------
 * EtbRecTx14Par type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx14Par
 * Allows access to Parameters of Etel bus send message Type 0x14
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx14Par {
	unsigned idx:16;                /**< Index in specified address space */
    unsigned sidx:8;                /**< Sub-index in specified address space */
    unsigned bit:5;	                /**< Bit number */
    unsigned :3;
} EtbRecTx14Par;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx14Par {
    unsigned :3;
    unsigned bit:5;		            /**< Bit number */
    unsigned sidx:8;                /**< Sub-index in specified address space */
	unsigned idx:16;                /**< Index in specified address space */
} EtbRecTx14Par;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx14 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx14
 * Allows access to Etel bus send message Type 0x14
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx14 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned :1;
    unsigned :7;
    unsigned :1;
    unsigned :8;
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	EtbRecTx14Par par1;             /**< First parameter value */
    EtbRecTx14Par par2;             /**< Second parameter value */
} EtbRecTx14;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx14 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned :8;
    unsigned :1;
    unsigned :7;
    unsigned :1;
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	EtbRecTx14Par par1;		        /**< First parameter value */
    EtbRecTx14Par par2;			    /**< Second parameter value */
} EtbRecTx14;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx18 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx18
 * Allows access to Etel bus send message Type 0x18
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx18 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned cmd:8;                 /**< Command number */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	ETB_REC_PARAM par1;             /**< First parameter value */
    ETB_REC_PARAM par2;             /**< Second parameter value */
} EtbRecTx18;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx18 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned cmd:8;                 /**< Command number */
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecTx18;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx20 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx20
 * Allows access to Etel bus send message Type 0x20
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx20 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned cmd:8;                 /**< Command number */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	ETB_REC_PARAM par1;             /**< First parameter value */
    ETB_REC_PARAM par2;             /**< Second parameter value */
} EtbRecTx20;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx20 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned cmd:8;                 /**< Command number */
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecTx20;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx30 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx30
 * Allows access to Etel bus send message Type 0x30
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx30 {
    unsigned rec:6;                 /**< Record number */
    unsigned :26;
} EtbRecTx30;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx30 {
    unsigned :26;
    unsigned rec:6;                 /**< Record number */
} EtbRecTx30;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecTx34 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecTx34
 * Allows access to Etel bus send message Type 0x34
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecTx34 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned : 16;
} EtbRecTx34;
#else /*__BYTE_ORDER*/
typedef struct EtbRecTx34 {
    unsigned : 16;
    unsigned :1;
    unsigned axis:7;                /**< Axis number */
    unsigned :1;
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
} EtbRecTx34;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecRx12 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx12
 * Allows access to Etel bus receive message Type 0x12
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx12 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned axis:7;                /**< Axis number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned :8;
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	long val1;						/**< First parameter value */
    long val2;						/**< Second parameter value */
} EtbRecRx12;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx12 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned :8;
    unsigned ack:1;                 /**< Ack bit */
    unsigned axis:7;                /**< Axis number */
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	long val1;				        /**< First parameter value */
    long val2;						/**< Second parameter value */
} EtbRecRx12;
#endif/*__BYTE_ORDER*/


/*------------------------------------------------------------------------------
 * EtbRecRx14 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx14
 * Allows access to Etel bus receive message Type 0x14
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx14 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned :7;
    unsigned ack:1;                 /**< Ack bit */
    unsigned :8;
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	long mask1;						/**< First parameter value */
    long mask2;						/**< Second parameter value */
} EtbRecRx14;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx14 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned :8;
    unsigned ack:1;                 /**< Ack bit */
    unsigned :7;
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	long mask1;				        /**< First parameter value */
    long mask2;						/**< Second parameter value */
} EtbRecRx14;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * EtbRecRx18 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx18
 * Allows access to Etel bus receive message Type 0x18
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx18 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned axis:7;                /**< Axis number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned cmd:8;                 /**< Command number */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecRx18;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx18 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned cmd:8;                 /**< Command number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned axis:7;                /**< Axis number */
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecRx18;
#endif/*__BYTE_ORDER*/


/*------------------------------------------------------------------------------
 * EtbRecRx20 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx20
 * Allows access to Etel bus receive message Type 0x20
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx20 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned axis:7;                /**< Axis number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned cmd:8;                 /**< Command number */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned typ2:4;                /**< Type of parameter 2 */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecRx20;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx20 {
    unsigned typ2:4;                /**< Type of parameter 2 */
    unsigned typ1:4;                /**< Type of parameter 1 */
    unsigned cmd:8;                 /**< Command number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned axis:7;                /**< Axis number */
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
	ETB_REC_PARAM par1;		        /**< First parameter value */
    ETB_REC_PARAM par2;			    /**< Second parameter value */
} EtbRecRx20;
#endif/*__BYTE_ORDER*/


/*------------------------------------------------------------------------------
 * EtbRecRx30 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx30
 * Allows access to Etel bus receive message Type 0x30
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx30 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned :7;
    unsigned ack:1;                 /**< ack bit */
    unsigned slaves:16;             /**< number of slaves on the bus */
    dword busy;                     /**< bit array for busy flags */
    dword exception;                /**< bit array which indicates that */
                                    /**< an error or warning has occured on the drive */
} EtbRecRx30;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx30 {
    unsigned slaves:16;             /**< number of slaves on the bus */
    unsigned ack:1;                 /**< Ack bit */
    unsigned :7;
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
    dword busy;                     /**< bit array for busy flags */
    dword exception;                /**< bit array which indicates that */
                                    /**< an error or warning has occured on the drive */
} EtbRecRx30;
#endif/*__BYTE_ORDER*/


/*------------------------------------------------------------------------------
 * EtbRecRx34 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbRecRx34
 * Allows access to Etel bus receive message Type 0x34
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbRecRx34 {
    unsigned rec:6;                 /**< Record number */
    unsigned :1;
    unsigned error:1;               /**< Error bit */
    unsigned axis:7;                /**< Axis number */
    unsigned ack:1;                 /**< Ack bit */
    unsigned :16;
    ETB_SW1 sw1;                     /**< Status word 1 of the drive */
    ETB_SW2 sw2;                     /**< Status word 2 of the drive */
} EtbRecRx34;
#else /*__BYTE_ORDER*/
typedef struct EtbRecRx34 {
    unsigned :16;
    unsigned ack:1;                 /**< Ack bit */
    unsigned axis:7;                /**< Axis number */
    unsigned error:1;               /**< Error bit */
    unsigned :1;
    unsigned rec:6;                 /**< Record number */
    ETB_SW1 sw1;                     /**< Status word 1 of the drive */
    ETB_SW2 sw2;                     /**< Status word 2 of the drive */
} EtbRecRx34;
#endif/*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * ETB_REC type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_REC
 * Etel bus message structure
 */
typedef union ETB_REC {
	byte raw[12];               /**< Etb record for access of table of bytes */
	EtbRecRawMode raws;			/**< Etb record for access of raws (little/big endian compatible)*/
    dword part[3];              /**< Etb record for access of table of double word */
	EtbRecAll all;				/**< Etb Record for access of general mode */
	EtbRecTx12 tx12;			/**< Etb Record for access of send record 0x12 */
	EtbRecTx14 tx14;			/**< Etb Record for access of send record 0x14 */
	EtbRecTx18 tx18;			/**< Etb Record for access of send record 0x18 */
	EtbRecTx20 tx20;			/**< Etb Record for access of send record 0x20 */
	EtbRecTx30 tx30;			/**< Etb Record for access of send record 0x30 */
	EtbRecTx34 tx34;			/**< Etb Record for access of send record 0x34 */
	EtbRecRx12 rx12;			/**< Etb Record for access of received record 0x12 */
	EtbRecRx14 rx14;			/**< Etb Record for access of received record 0x14 */
	EtbRecRx18 rx18;			/**< Etb Record for access of received record 0x18 */
	EtbRecRx20 rx20;			/**< Etb Record for access of received record 0x20 */
	EtbRecRx30 rx30;			/**< Etb Record for access of received record 0x30 */
	EtbRecRx34 rx34;			/**< Etb Record for access of received record 0x34 */
} ETB_REC;

#define EtbRec ETB_REC


/*------------------------------------------------------------------------------
 * ETB_ETCOM_PARAM_BIT_MODE type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM_PARAM_BIT_MODE
 * Allow acces to Etel Variable length record parameters with bits members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct ETB_ETCOM_PARAM_BIT_MODE {
    unsigned idx:16;                        /**< Index in specified address space */
    unsigned sidx:8;                        /**< Sub-index in specified address space */
    unsigned axis:7;                        /**< Axis or bit number */
    unsigned reserved1:1;                   /**< Reserved 1 */
} ETB_ETCOM_PARAM_BIT_MODE;

#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct ETB_ETCOM_PARAM_BIT_MODE {
    unsigned reserved1:1;                   /**< Reserved 1 */
    unsigned axis:7;                        /**< Axis or bit number */
    unsigned sidx:8;                        /**< Sub-index in specified address space */
    unsigned idx:16;                        /**< Index in specified address space */
} ETB_ETCOM_PARAM_BIT_MODE;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * ETB_ETCOM_PARAM_BYTE_MODE type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM_PARAM_BYTE_MODE
 * Allow acces to Etel Variable length record 32 bits parameter with raw members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct ETB_ETCOM_PARAM_BYTE_MODE {
	byte byte0;						/**< Byte 0 of parameter */
	byte byte1;						/**< Byte 1 of parameter */
	byte byte2;						/**< Byte 2 of parameter */
	byte byte3;						/**< Byte 3 of parameter */
} ETB_ETCOM_PARAM_BYTE_MODE;
#else /*__BYTE_ORDER*/
typedef struct ETB_ETCOM_PARAM_BYTE_MODE {
	byte byte3;						/**< Byte 3 of parameter */
	byte byte2;						/**< Byte 2 of parameter */
	byte byte1;						/**< Byte 1 of parameter */
	byte byte0;						/**< Byte 0 of parameter */
} ETB_ETCOM_PARAM_BYTE_MODE;
#endif


/*------------------------------------------------------------------------------
 * ETB_ETCOM_VALUE type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_ETCOM_VALUE
 * Etel variable parameter value
 */
typedef union ETB_ETCOM_VALUE {
	int i32;
	eint64 i64;
	float f32;
	double f64;
	ETB_ETCOM_PARAM_BIT_MODE bits;
	ETB_ETCOM_PARAM_BYTE_MODE bytes;
} ETB_ETCOM_VALUE;
#define EtbEtcomValue ETB_ETCOM_VALUE

/*------------------------------------------------------------------------------
 * ETB_ETCOM_PARAM type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_ETCOM_PARAM
 * Etel variable length record parameter
 */
typedef struct ETB_ETCOM_PARAM {
    int typ;								/**< type of parameter (See DMD_TYP...)*/
	ETB_ETCOM_VALUE value;					/**< value of parameter*/
} ETB_ETCOM_PARAM;


/*------------------------------------------------------------------------------
 * ETB_ETCOM_HEADER_BIT_MODE type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM_HEADER_BIT_MODE
 * Allow acces to Etel Variable length record header with bits members
 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct ETB_ETCOM_HEADER {
	unsigned nb_param	:8;					/**< number of parameters */
	unsigned gate   	:3;					/**< gate */
	unsigned reserved1	:3;					/**< reserved */
	unsigned err	    :1;					/**< acknowledge of command */
	unsigned ack	    :1;					/**< acknowledge of command */
    unsigned cmd	    :8;					/**< Command number */
	unsigned rec	    :8;					/**< record number */
} ETB_ETCOM_HEADER;
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct ETB_ETCOM_HEADER {
	unsigned rec	    :8;					/**< record number */
    unsigned cmd	    :8;					/**< Command number */
	unsigned ack	    :1;					/**< acknowledge of command */
	unsigned err	    :1;					/**< acknowledge of command */
	unsigned reserved1	:3;					/**< reserved */
	unsigned gate   	:3;					/**< gate */
	unsigned nb_param	:8;					/**< number of parameters */
} ETB_ETCOM_HEADER;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * ETB_ETCOM type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM
 * Etel variable length record structure with 2 parameters
 */
typedef struct ETB_ETCOM {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[2];					/**< default 2 parameters*/
} ETB_ETCOM;

#define EtbEtcom ETB_ETCOM

/*------------------------------------------------------------------------------
 * ETB_ETCOM0 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM0
 * Etel variable length record structure with 0 int32 value-parameter
 */
typedef struct ETB_ETCOM0 {
	ETB_ETCOM_HEADER header;	    			/**< header */
} ETB_ETCOM0;
#define EtbEtcom0 ETB_ETCOM0

/*------------------------------------------------------------------------------
 * ETB_ETCOM1 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM1
 * Etel variable length record structure with 1 parameter
 */
typedef struct ETB_ETCOM1 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[1];					/**< 1 parameter*/
} ETB_ETCOM1;
#define EtbEtcom1 ETB_ETCOM1

/*------------------------------------------------------------------------------
 * ETB_ETCOM2 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM2
 * Etel variable length record structure with 2 parameters
 */
#define ETB_ETCOM2 ETB_ETCOM
#define EtbEtcom2 ETB_ETCOM2

/*------------------------------------------------------------------------------
 * ETB_ETCOM3 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM3
 * Etel variable length record structure with 3 parameters
 */
typedef struct ETB_ETCOM3 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[3];					/**< 3 parameters*/
} ETB_ETCOM3;
#define EtbEtcom3 ETB_ETCOM3

/*------------------------------------------------------------------------------
 * ETB_ETCOM4 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM4
 * Etel variable length record structure with 4 parameters
 */
typedef struct ETB_ETCOM4 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[4];					/**< 4 parameters*/
} ETB_ETCOM4;
#define EtbEtcom4 ETB_ETCOM4

/*------------------------------------------------------------------------------
 * ETB_ETCOM5 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM5
 * Etel variable length record structure with 5 parameters
 */
typedef struct ETB_ETCOM5 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[5];					/**< 5 parameters*/
} ETB_ETCOM5;
#define EtbEtcom5 ETB_ETCOM5

/*------------------------------------------------------------------------------
 * ETB_ETCOM6 type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_ETCOM6
 * Etel variable length record structure with 6 parameters
 */
typedef struct ETB_ETCOM6 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[6];					/**< 6 parameters)*/
} ETB_ETCOM6;
#define EtbEtcom6 ETB_ETCOM6

/*------------------------------------------------------------------------------
 * ETB_ETCOM65 type
 *-----------------------------------------------------------------------------*/
#define ETB_ETCOM_DEF_PARAM 65
/**
 * @struct ETB_ETCOM65 
 * Etel variable length record structure with 65 parameters
 * (used to set all depthes of a registers => max depth 64 + 1 parameter register address)
 */
typedef struct ETB_ETCOM65 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[ETB_ETCOM_DEF_PARAM];					/**< 65 value-parameters)*/
} ETB_ETCOM65;
#define EtbEtcom65 ETB_ETCOM65

#define ETB_ETCOMDEF ETB_ETCOM65
#define EtbEtcomDef ETB_ETCOMDEF


/*------------------------------------------------------------------------------
 * ETB_ETCOM203 type
 *-----------------------------------------------------------------------------*/
#define ETB_ETCOM_MAX_PARAM 203
/**
 * @struct ETB_ETCOM203
 * Etel variable length record structure with 203 parameters (Maximum of 32-bits parameters)
 */
typedef struct ETB_ETCOM203 {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[ETB_ETCOM_MAX_PARAM];					/**< 203 parameters)*/
} ETB_ETCOM203;
#define ETB_ETCOMMAX ETB_ETCOM203
#define EtbEtcom203 ETB_ETCOM203
#define EtbEtcomMax ETB_ETCOMMAX

/*------------------------------------------------------------------------------
 * ETB_ETCOM2E type
 *-----------------------------------------------------------------------------*/
#define ETB_ETCOM_2E_PARAM 253
/**
 * @struct ETB_ETCOM2E
 * Etel record structure with 253 parameters (Maximum of 32-bits parameters) Used for download
 */
typedef struct ETB_ETCOM2E {
	ETB_ETCOM_HEADER header;	    			/**< header */
	ETB_ETCOM_PARAM pars[ETB_ETCOM_2E_PARAM];					/**< 253 parameters)*/
} ETB_ETCOM2E;
#define EtbEtcom2E ETB_ETCOM2E


/*------------------------------------------------------------------------------
 * EtbSWBitMode type
 *-----------------------------------------------------------------------------*/
/**
 * @struct EtbSWBitMode
 * Allows acces to Etel bus status double word in bit mode
 */

#if __BYTE_ORDER == __LITTLE_ENDIAN
typedef struct EtbSWBitMode {
	#ifndef ETB_OO_API
	unsigned open:1;				/**< The driver is open */
	unsigned reset:1;               /**< The driver currently perforn a reset */
	unsigned b_direct:1;            /**< The drive(s) are in direct boot mode */
	unsigned b_bridge:1;            /**< The drive(s) are in bridge boot mode */
	unsigned warning:1;             /**< There is a communication warning */
	unsigned error:1;               /**< There is a communication error */
	unsigned busy:1;                /**< The drive cannot communicate now */
	unsigned watchdog:1;			/**< There is a watchdog error on communication. DSTEB3 only*/
	unsigned :4;
	unsigned :16;
	unsigned dll:4;                 /**< Reserved for dll use */
	#else /* ETB_OO_API */
	unsigned open:1;                /**< The driver is open */
	unsigned reset:1;               /**< The driver currently perforn a reset */
	unsigned bDirect:1;             /**< The drive(s) are in direct boot mode */
	unsigned bBridge:1;             /**< The drive(s) are in bridge boot mode */
	unsigned warning:1;             /**< There is a communication warning */
	unsigned error:1;               /**< There is a communication error */
	unsigned busy:1;                /**< The drive cannot communicate now */
	unsigned watchdog:1;			/**< There is a watchdog error on communication. DSTEB3 only*/
	unsigned :4;
	unsigned :16;
	unsigned dll:4;                 /**< Reserved for dll use */
	#endif /* ETB_OO_API */
} EtbSWBitMode;
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
typedef struct EtbSWBitMode {
	#ifndef ETB_OO_API
	unsigned dll:4;                 /**< Reserved for dll use */
	unsigned :16;
	unsigned :4;
	unsigned watchdog:1;			/**< There is a watchdog error on communication. DSTEB3 only*/
	unsigned busy:1;                /**< The drive cannot communicate now */
	unsigned error:1;               /**< There is a communication error */
	unsigned warning:1;             /**< There is a communication warning */
	unsigned b_bridge:1;            /**< The drive(s) are in bridge boot mode */
	unsigned b_direct:1;            /**< The drive(s) are in direct boot mode */
	unsigned reset:1;               /**< The driver currently perforn a reset */
	unsigned open:1;				/**< The driver is open */
	#else /* ETB_OO_API */
	unsigned dll:4;                 /**< Reserved for dll use */
	unsigned :16;
	unsigned :4;
	unsigned watchdog:1;			/**< There is a watchdog error on communication. DSTEB3 only*/
	unsigned busy:1;                /**< The drive cannot communicate now */
	unsigned error:1;               /**< There is a communication error */
	unsigned warning:1;             /**< There is a communication warning */
	unsigned bBidge:1;	            /**< The drive(s) are in bridge boot mode */
	unsigned bDrect:1;		        /**< The drive(s) are in direct boot mode */
	unsigned reset:1;               /**< The driver currently perforn a reset */
	unsigned open:1;				/**< The driver is open */
	#endif /* ETB_OO_API */
} EtbSWBitMode;
#endif /*__BYTE_ORDER*/

/*------------------------------------------------------------------------------
 * ETB_SW type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_SW
 * Etel bus status double word
 */
typedef union ETB_SW {
	dword l;						/**< Status double word for access in double word */
	EtbSWBitMode s;					/**< Status double word for accexss in bit mode */
} ETB_SW;

#define EtbSW ETB_SW

/*------------------------------------------------------------------------------
 * ETB_BUS_STATUS type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_BUS_STATUS
 * Etel bus status structure
 */
typedef struct ETB_BUS_STATUS {
    size_t size;                    /**< The size of this structure */
	ETB_SW sw;                      /**< The status */
    int e_code;                     /**< The error code */
} ETB_BUS_STATUS;

#define EtbBusStatus ETB_BUS_STATUS

/*------------------------------------------------------------------------------
 * ETB_DRV_INFO type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_DRV_INFO
 * Etel bus drive information
 */
typedef struct ETB_DRV_INFO {
    size_t size;                    /**< The size of this structure */
	#ifndef ETB_OO_API
    int product_number;             /**< The drive product number */
    int boot_revision;              /**< The boot revision of drive */
    long serial_number;             /**< The serial number of drive */
    dword soft_version;             /**< The version of drive software */
    dword product_string[4];
    bool true_gantry;				/**< The gantry is a true gantry */
	#else /* ETB_OO_API */
    int productNumber;              /**< The drive product number */
    int bootRevision;               /**< The boot revision of drive */
    long serialNumber;              /**< The serial number of drive */
    dword softVersion;              /**< The version of drive software */
    dword productString[4];
    bool true_gantry;				/**< The gantry is a true gantry */
	#endif /* ETB_OO_API */
} ETB_DRV_INFO;

#define EtbDrvInfo ETB_DRV_INFO

/*------------------------------------------------------------------------------
 * ETB_MASTER_INFO type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_MASTER_INFO
 * Etel bus master information
 */
typedef struct ETB_MASTER_INFO {
    size_t size;                    /**< The size of this structure */
	#ifndef ETB_OO_API
	int stream_max_data_size;		/**< The maximal number of long of a record used for stream */
	#else /* ETB_OO_API */
	int streamMaxDataSize;			/**< The maximal number of long of a record used for stream */
	#endif /* ETB_OO_API */
} ETB_MASTER_INFO;

#define EtbMasterInfo ETB_MASTER_INFO

/*------------------------------------------------------------------------------
 * ETB_EXT_INFO type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_EXT_INFO
 * Etel bus extension card information
 */
typedef struct ETB_EXT_INFO {
    size_t size;                    /**< The size of this structure */
	#ifndef ETB_OO_API
    int product_number;             /**< The extension card product number */
    int boot_revision;              /**< The boot revision of extension card */
    long serial_number;             /**< The serial number of extension card */
    dword soft_version;             /**< The version of extension card software */
	#else /* ETB_OO_API */
    int productNumber;              /**< The extension card product number */
    int bootRevision;               /**< The boot revision of extension card */
    long serialNumber;              /**< The serial number of extension card */
    dword softVersion;              /**< The version of extension card software */
	#endif /* ETB_OO_API */
} ETB_EXT_INFO;

#define EtbExtInfo ETB_EXT_INFO


/*------------------------------------------------------------------------------
 * ETB_SVR_INFO type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_SVR_INFO
 * Etel bus server information
 */
typedef struct ETB_SVR_INFO {
    size_t size;                    /**< The size of this structure */
	#ifndef ETB_OO_API
    int product_number;             /**< The server product number */
    dword soft_version;             /**< The version of server software */
    int boot_revision;
    long serial_number;
    dword product_string[4];        /**< Product string */
	#else /* ETB_OO_API */
    int productNumber;              /**< The server product number */
    dword softVersion;              /**< The version of server software */
    int bootRevision;
    long serialNumber;
    dword productString[4];        /**< Product string */
	#endif /* ETB_OO_API */
} ETB_SVR_INFO;

#define EtbSvrInfo ETB_SVR_INFO


/*------------------------------------------------------------------------------
 * ETB_TIMEOUTS type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_TIMEOUTS
 * Etel bus preferred timeouts information
 */
typedef struct ETB_TIMEOUTS {
    size_t size;                    /**< The size of this structure */
    int base;                       /**< The base value of preferred timeouts */
    int fast;                       /**< The factor for preferred fast timeouts */
    int slow;                       /**< The factor for preferred slow timeouts */
} ETB_TIMEOUTS;

#define EtbTimeouts ETB_TIMEOUTS

/*------------------------------------------------------------------------------
 * ETB_RTV_HANDLER type
 *-----------------------------------------------------------------------------*/
/*Type of rtv function called at each interrupt*/
/*For AccurET connected through UltimET only */
typedef void (ETB_CALLBACK *ETB_RTV_HANDLER)(ETB *etb, int nr, void *user);

/*------------------------------------------------------------------------------
 * ETB_RTM_VAL type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_RTM_VAL
 * Realtime values
 */
typedef struct ETB_RTM_VAL {
	long val0;						/**< The first realtime value on channel*/
	long val1;						/**< The second realtime value on channel */
} ETB_RTM_VAL;

#define ETB_MAX_RTM 16     /**< Maximal number of drives by using realtime monitoring */

/*------------------------------------------------------------------------------
 * ETB_RTM_TABLE type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_RTM_TABLE
 * Contains realtime monitoring in a table
 */
typedef struct ETB_RTM_TABLE {
	size_t size;							/**< The size of this structure */
	ETB_RTM_VAL mon[ETB_MAX_RTM];			/**< The monitoring table */
} ETB_RTM_TABLE;

/*------------------------------------------------------------------------------
 * ETB_RTM_STRUCT type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_RTM_STRUCT
 * Contains realtime monitoring in structure
 */
typedef struct ETB_RTM_STRUCT {
	size_t size;					/**< The size of this structure */
	long axis0_m0;				/**< The first realtime monitoring value of 1st axis */
	long axis0_m1;				/**< The second realtime monitoring value of 1st axis */
	long axis1_m0;				/**< The first realtime monitoring value of 2nd axis */
	long axis1_m1;				/**< The second realtime monitoring value of 2nd axis */
	long axis2_m0;				/**< The first realtime monitoring value of 3rd axis */
	long axis2_m1;				/**< The second realtime monitoring value of 3rd axis */
	long axis3_m0;				/**< The first realtime monitoring value of 4th axis */
	long axis3_m1;				/**< The second realtime monitoring value of 4th axis */
	long axis4_m0;				/**< The first realtime monitoring value of 5th axis */
	long axis4_m1;				/**< The second realtime monitoring value of 5th axis */
	long axis5_m0;				/**< The first realtime monitoring value of 6th axis */
	long axis5_m1;				/**< The second realtime monitoring value of 6th axis */
	long axis6_m0;				/**< The first realtime monitoring value of 7th axis */
	long axis6_m1;				/**< The second realtime monitoring value of 7th axis */
	long axis7_m0;				/**< The first realtime monitoring value of 8th axis */
	long axis7_m1;				/**< The second realtime monitoring value of 8th axis */
	long axis8_m0;				/**< The first realtime monitoring value of 9th axis */
	long axis8_m1;				/**< The second realtime monitoring value of 9th axis */
	long axis9_m0;				/**< The first realtime monitoring value of 10th axis */
	long axis9_m1;				/**< The second realtime monitoring value of 10th axis */
	long axis10_m0;				/**< The first realtime monitoring value of 11th axis */
	long axis10_m1;				/**< The second realtime monitoring value of 11th axis */
	long axis11_m0;				/**< The first realtime monitoring value of 12th axis */
	long axis11_m1;				/**< The second realtime monitoring value of 12th axis */
	long axis12_m0;				/**< The first realtime monitoring value of 13th axis */
	long axis12_m1;				/**< The second realtime monitoring value of 13th axis */
	long axis13_m0;				/**< The first realtime monitoring value of 14th axis */
	long axis13_m1;				/**< The second realtime monitoring value of 14th axis */
	long axis14_m0;				/**< The first realtime monitoring value of 15th axis */
	long axis14_m1;				/**< The second realtime monitoring value of 15th axis */
	long axis15_m0;				/**< The first realtime monitoring value of 16th axis */
	long axis15_m1;				/**< The second realtime monitoring value of 16th axis */
} ETB_RTM_STRUCT;


/*------------------------------------------------------------------------------
 * ETB_RTM type
 *-----------------------------------------------------------------------------*/
/**
 * @union ETB_RTM
 * Getted realtime monitoring structure
 */
typedef union ETB_RTM {
    size_t size;                /**< Size of this structure */
	ETB_RTM_STRUCT monStruct;	/**< Access to realtime monitoring through structure */
	ETB_RTM_TABLE monTable;		/**< Access to realtime monitoring through table */
} ETB_RTM;

/*------------------------------------------------------------------------------
 * ETB_TRAJECTORY_HANDLER type
 *-----------------------------------------------------------------------------*/
/*Type of trajectory generator function called at each interrupt*/
/*For DSC connected through DSTEB3 only */
typedef void (ETB_CALLBACK *ETB_TRAJECTORY_HANDLER)(ETB_RTM *pts);

/*------------------------------------------------------------------------------
 * ETB_RTM_AXISMASK type
 *-----------------------------------------------------------------------------*/
/*Type of axis mask structure for realtime channel*/
typedef unsigned long ETB_RTM_AXISMASK[ETB_MAX_RTM];

/*------------------------------------------------------------------------------
 * ETB_COUNTERS type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_COUNTERS
 * Etel bus counters information
 */
typedef struct ETB_COUNTERS {
    size_t size;                    /**< The size of this structure */
	#ifndef ETB_OO_API
    int tx_counter;                 /**< The number of messages transmitted */
    int rx_counter;                 /**< The number of messages received */
	#else /* ETB_OO_API */
    int txCounter;                  /**< The number of messages transmitted */
    int rxCounter;                  /**< The number of messages received */
	#endif /* ETB_OO_API */
} ETB_COUNTERS;

#define EtbCounters ETB_COUNTERS

/*------------------------------------------------------------------------------
 * ETB_FW_INFO type
 *-----------------------------------------------------------------------------*/
/**
 * @struct ETB_FW_INFO
 * Firmware information
 */
typedef struct ETB_FW_INFO {
	char title[64];			/**< The name of the firmware */
	char version[64];		/**< The version of the firmware */
} ETB_FW_INFO;

/*------------------------------------------------------------------------------
 * ETB_ISO_CONVERTER type
 *-----------------------------------------------------------------------------*/
typedef int ETB_CALLBACK ETB_ISO_CONVERTER(ETB *etb, ETB_ETCOM_VALUE *incr, double *iso, int incr_type, int conv, int axis, bool to_iso, void *user);

/**********************************************************************************************************/
/*- VARIABLES */
/**********************************************************************************************************/

#ifndef AXIS_PAR
	extern int etb_axis;
#endif /* AXIS_PAR */


#if defined QNX4
	#pragma off(unreferenced)
#endif

static ETB_DRV_INFO global_drv_info;
#define etb_init_drv_info() (memset(&global_drv_info, 0, sizeof(ETB_DRV_INFO)), global_drv_info.size = sizeof(ETB_DRV_INFO), global_drv_info)

static ETB_TIMEOUTS global_timeouts;
#define etb_init_timeouts() (memset(&global_timeouts, 0, sizeof(ETB_TIMEOUTS)), global_timeouts.size = sizeof(ETB_TIMEOUTS), global_timeouts)

static ETB_EXT_INFO global_ext_info;
#define etb_init_ext_info() (memset(&global_ext_info, 0, sizeof(ETB_EXT_INFO)), global_ext_info.size = sizeof(ETB_EXT_INFO), global_ext_info)

static ETB_DRV_STATUS global_drv_status;
#define etb_init_drv_status() (memset(&global_drv_status, 0, sizeof(ETB_DRV_STATUS)), global_drv_status.size = sizeof(ETB_DRV_STATUS), global_drv_status)

static ETB_REC_PARAM global_rec_param;
#define etb_init_rec_param() (memset(&global_rec_param, 0, sizeof(ETB_REC_PARAM)), global_rec_param)

static ETB_COUNTERS global_counters;
#define etb_init_counters() (memset(&global_counters, 0, sizeof(ETB_COUNTERS)), global_counters.size = sizeof(ETB_COUNTERS), global_counters)

static ETB_BUS_STATUS global_bus_status;
#define etb_init_bus_status() (memset(&global_bus_status, 0, sizeof(ETB_BUS_STATUS)), global_bus_status.size = sizeof(ETB_BUS_STATUS), global_bus_status)

static ETB_SVR_INFO global_svr_info;
#define etb_init_svr_info() (memset(&global_svr_info, 0, sizeof(ETB_SVR_INFO)), global_svr_info.size = sizeof(ETB_SVR_INFO), global_svr_info)

static ETB_MASTER_INFO global_master_info;
#define etb_init_master_info() (memset(&global_master_info, 0, sizeof(ETB_MASTER_INFO)), global_master_info.size = sizeof(ETB_MASTER_INFO), global_master_info)

static ETB_RTM global_etb_rtm;
#define etb_init_rtm() (memset(&global_etb_rtm, 0, sizeof(ETB_RTM)), global_etb_rtm.size = sizeof(ETB_RTM), global_etb_rtm)

#if defined QNX4
	#pragma on(unreferenced)
#endif

/**********************************************************************************************************/
/*- PROTOTYPES */
/**********************************************************************************************************/
/**
 * @addtogroup ETBAll
 */
/*@{*/

/*------------------------------------------------------------------------------
 * general functions
 *-----------------------------------------------------------------------------*/
dword   _ETB_EXPORT etb_get_version(void);
dword   _ETB_EXPORT etb_get_edi_version(void);
time_t  _ETB_EXPORT etb_get_build_time(void);
long    _ETB_EXPORT etb_get_timer(void);
char_cp _ETB_EXPORT etb_translate_error(int code);

/*------------------------------------------------------------------------------
 * utility functions
 *-----------------------------------------------------------------------------*/
void	_ETB_EXPORT etb_etcom_get_string (char *buffer, int buffer_size, ETB_ETCOM *etcom, int start_par_idx, int end_idx);
int		_ETB_EXPORT etb_fill_etcom(ETB_ETCOM *etcom, int max_param, int rec, int cmd, char *format, ...);
int		_ETB_EXPORT etb_vfill_etcom(ETB_ETCOM *etcom, int max_param, int rec, int cmd, char *format, va_list args);
void	_ETB_EXPORT etb_endian_memcpy(void *dest, void *src, int size);
void	_ETB_EXPORT etb_endian_memcpy64(void *dest, void *src, int size);
void	_ETB_EXPORT etb_endian_memcpy16(void *dest, void *src, int size);
void	_ETB_EXPORT etb_endian_buffer_to_etcom(ETB_ETCOM *etcom, unsigned char *buffer, int buffer_size);
int		_ETB_EXPORT etb_endian_etcom_to_buffer(unsigned char *buffer, int size, ETB_ETCOM *etcom);
int		_ETB_EXPORT etb_etcom_to_recs(ETB_ETCOM *etcom, ETB_REC rec[], int nb_rec, int *should_rec);
int		_ETB_EXPORT etb_recs_to_etcom(ETB_CONST_REC ETB_REC rec[], int n_rec, ETB_ETCOM *etcom, int max_param);
void	_ETB_EXPORT etb_etcom_sprintf(char *str, ETB_ETCOM *etcom);
int		_ETB_EXPORT etb_etcom_sizeof(int nb_param);
int		_ETB_EXPORT etb_etcom_record_sizeof(ETB_ETCOM *rec);

/*------------------------------------------------------------------------------
 * connection management functions
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_create_bus(ETB **retb);
int     _ETB_EXPORT etb_destroy_bus(ETB **retb);
bool    _ETB_EXPORT etb_is_valid_bus(ETB *etb);
int     _ETB_EXPORT etb_create_port(ETB_PORT **rport, ETB *etb);
int     _ETB_EXPORT etb_destroy_port(ETB_PORT **rport);
int     _ETB_EXPORT etb_create_spy_port(ETB_PORT **rport, ETB *etb);
int     _ETB_EXPORT etb_destroy_spy_port(ETB_PORT **rport);
bool    _ETB_EXPORT etb_is_valid_port(ETB_PORT *port);
int     _ETB_EXPORT etb_open(ETB *etb, const char *driver, dword flags, long baudrate, long timeout);
int     _ETB_EXPORT etb_reset(ETB *etb, dword flags, long baudrate, long timeout, bool deep);
int     _ETB_EXPORT etb_close(ETB *etb, dword flags, long timeout);
int     _ETB_EXPORT etb_is_open(ETB *etb, bool *open);
int     _ETB_EXPORT etb_get_bus(ETB_PORT *port, ETB **etb);
int     _ETB_EXPORT etb_get_driver(ETB *etb, char *buf, size_t max);
int     _ETB_EXPORT etb_get_flags(ETB *etb, dword *flags);
int     _ETB_EXPORT etb_get_baudrate(ETB *etb, long *baudrate);
int		_ETB_EXPORT etb_activate_status(ETB *etb, bool on);
int		_ETB_EXPORT etb_multi_send(ETB *etb, int nb_rec, ETB_REC send_table[], dword mask_table[], ETB_REC recv_table[], dword time_table[], int timeout);
int		_ETB_EXPORT etb_etcom_multi_send(ETB *etb, int nb_rec, ETB_ETCOM send_table[], eint64 mask_table[], ETB_ETCOM recv_table[], dword time_table[], int timeout);
int		_ETB_EXPORT etb_start_rtm(ETB *etb, ETB_TRAJECTORY_HANDLER get_trajectory_point);
int		_ETB_EXPORT etb_stop_rtm(ETB *etb);
int		_ETB_EXPORT etb_init_rtm_fct(ETB *etb, ETB_RTM_AXISMASK realtime_axis);
int		_ETB_EXPORT etb_set_rates(ETB *etb, int irq_rate, int status_rate, int mon_rate, int fast_rate, int slow_rate);
int     _ETB_EXPORT etb_get_rtm_mon(ETB *etb, ETB_RTM *rtm_mon);
int	    _ETB_EXPORT etb_set_prio(ETB *etb, int prio);
int		_ETB_EXPORT etb_link_error(ETB *etb, bool on);
int		_ETB_EXPORT etb_irq_watchdog(ETB *etb, int watchdog);
int		_ETB_EXPORT etb_read_1_slot(ETB *etb, int slot, dword *val);
int		_ETB_EXPORT etb_read_2_slot(ETB *etb, int slot1, int slot2, dword *val1, dword *val2);
int		_ETB_EXPORT etb_write_1_slot(ETB *etb, int slot, dword val);
int		_ETB_EXPORT etb_write_2_slot(ETB *etb, int slot1, int slot2, dword val1, dword val2);
int		_ETB_EXPORT etb_start_rtv_handler(ETB *etb, int nr, int rate, int delay, ETB_RTV_HANDLER handler, void *user);
int		_ETB_EXPORT etb_stop_rtv_handler(ETB *etb, int nr);
void	_ETB_EXPORT etb_bus_clear_watchdog(ETB *etb);
int		_ETB_EXPORT etb_diag(char_cp file_name, int line, int err, ETB *etb, dword mask);
int		_ETB_EXPORT etb_sdiag(char_p str, char_cp file_name, int line, int err, ETB *etb, dword mask);
int		_ETB_EXPORT etb_fdiag(char_cp output_file_name , char_cp file_name, int line, int err, ETB *etb, dword mask);
int		_ETB_EXPORT etb_etcom_diag(char_cp file_name, int line, int err, ETB *etb, eint64 mask);
int		_ETB_EXPORT etb_etcom_sdiag(char_p str, char_cp file_name, int line, int err, ETB *etb, eint64 mask);
int		_ETB_EXPORT etb_etcom_fdiag(char_cp output_file_name , char_cp file_name, int line, int err, ETB *etb, eint64 mask);

/*------------------------------------------------------------------------------
 * status/info access functions
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_get_bus_status(ETB *etb, int server, ETB_BUS_STATUS *stat);
int     _ETB_EXPORT etb_get_bus_counters(ETB *etb, int server, ETB_COUNTERS *counters);
int     _ETB_EXPORT etb_get_bus_timeouts(ETB *etb, ETB_TIMEOUTS *timeouts);
int     _ETB_EXPORT etb_get_svr_number(ETB *etb, int *number);
int     _ETB_EXPORT etb_get_svr_info(ETB *etb, int server, ETB_SVR_INFO *info);
int     _ETB_EXPORT etb_get_drv_present(ETB *etb, dword *present);
int     _ETB_EXPORT etb_etcom_get_drv_present(ETB *etb, eint64 *present);
int     _ETB_EXPORT etb_get_drv_peer(ETB *etb, dword *peer);
int     _ETB_EXPORT etb_get_drv_status(ETB *etb, int axis, ETB_DRV_STATUS *stat);
int     _ETB_EXPORT etb_etcom_get_drv_status(ETB *etb, int axis, ETB_DRV_STATUS *stat);
int     _ETB_EXPORT etb_get_drv_info(ETB *etb, int axis, ETB_DRV_INFO *info);
int     _ETB_EXPORT etb_etcom_get_drv_info(ETB *etb, int axis, ETB_DRV_INFO *info);
int     _ETB_EXPORT etb_get_ext_info(ETB *etb, int axis, ETB_EXT_INFO *info);
int     _ETB_EXPORT etb_etcom_get_ext_info(ETB *etb, int axis, ETB_EXT_INFO *info);
int     _ETB_EXPORT etb_etcom_get_master_info(ETB *etb, ETB_MASTER_INFO *info);

/*------------------------------------------------------------------------------
 * handlers management functions
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_add_bus_handler(ETB *etb, void *key, dword svr_mask, dword ev_mask, void (ETB_CALLBACK *handler)(ETB *, int, dword, void *), void *param);
int     _ETB_EXPORT etb_remove_bus_handler(ETB *etb, void *key);
int     _ETB_EXPORT etb_add_drv_handler(ETB *etb, void *key, dword axis_mask, bool and_mask, bool or_mask, dword ev_mask, void (ETB_CALLBACK *handler)(ETB *, int, dword, void *), void *param);
int     _ETB_EXPORT etb_etcom_add_drv_handler(ETB *etb, void *key, eint64 axis_mask, bool and_mask, bool or_mask, dword ev_mask, void (ETB_CALLBACK *handler)(ETB *, int, dword, void *), void *param);
int     _ETB_EXPORT etb_remove_drv_handler(ETB *etb, void *key);
int     _ETB_EXPORT etb_add_rt_handler(ETB *etb, void *key, dword axis_mask, int (ETB_CALLBACK *handler)(ETB *, int, long *, void *), void *param);
int     _ETB_EXPORT etb_remove_rt_handler(ETB *etb, void *key);
int     _ETB_EXPORT etb_add_msg_handler(ETB_PORT *port, void *key, void (ETB_CALLBACK *handler)(ETB_PORT *, void *), void *param);
int     _ETB_EXPORT etb_remove_msg_handler(ETB_PORT *port, void *key);

/*------------------------------------------------------------------------------
 * transaction support
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_begin_trans(ETB *etb, long timeout);
int     _ETB_EXPORT etb_end_trans(ETB *etb);

/*------------------------------------------------------------------------------
 * message handling functions
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_putm(ETB_PORT *port, const void *key, dword mask, ETB_CONST_REC ETB_REC *rec, long timeout);
int     _ETB_EXPORT etb_putr(ETB_PORT *port, ETB_CONST_REC ETB_REC *rec, long timeout);
int     _ETB_EXPORT etb_getm(ETB_PORT *port, const void **key, dword *mask, ETB_REC *rec, dword *rx_time, long timeout);
int     _ETB_EXPORT etb_getr(ETB_PORT *port, ETB_REC *rec, dword *rx_time, long timeout);

int     _ETB_EXPORT etb_etcom_putm(ETB_PORT *port, const void *key, eint64 mask, ETB_CONST_REC ETB_ETCOM *rec, long timeout);
int     _ETB_EXPORT etb_etcom_putr(ETB_PORT *port, eint64 mask, ETB_CONST_REC ETB_ETCOM *rec, long timeout);
int     _ETB_EXPORT etb_etcom_getm(ETB_PORT *port, const void **key, eint64 *mask, ETB_ETCOM *rec, int max_param, dword *rx_time, long timeout);
int     _ETB_EXPORT etb_etcom_getr(ETB_PORT *port, eint64 *mask, ETB_ETCOM *rec, int max_param, dword *rx_time, long timeout);
/*------------------------------------------------------------------------------
 * boot control functions
 *-----------------------------------------------------------------------------*/
int     _ETB_EXPORT etb_change_boot_mode(ETB *etb, int mode);
int     _ETB_EXPORT etb_start_download(ETB *etb, dword mask, int block);
int     _ETB_EXPORT etb_etcom_start_download(ETB *etb, eint64 mask, int block);
int     _ETB_EXPORT etb_start_download_file(ETB *etb, dword mask, char *file_name, int file_size);
int     _ETB_EXPORT etb_etcom_start_download_file(ETB *etb, eint64 mask, char *file_name, int file_size);
int     _ETB_EXPORT etb_start_upload_file(ETB *etb, dword mask, char *file_name, int *file_size);
int     _ETB_EXPORT etb_etcom_start_upload_file(ETB *etb, eint64 mask, char *file_name, int *file_size);
int     _ETB_EXPORT etb_activate_download(ETB *etb);
int     _ETB_EXPORT etb_download_segment(ETB *etb, const char *buf, size_t size);
int     _ETB_EXPORT etb_start_upload(ETB *etb, int axis, int block);
int     _ETB_EXPORT etb_etcom_start_upload(ETB *etb, int axis, int block);
int     _ETB_EXPORT etb_upload_segment(ETB *etb, char *buf, size_t size);
int     _ETB_EXPORT etb_auto_number(ETB *etb, int start, bool save);
int		_ETB_EXPORT etb_get_block_size(int block, long *size);
bool    _ETB_EXPORT etb_is_block_available(int block, int prod);
int		_ETB_EXPORT etb_download_firmware(ETB *etb, dword axis_mask, char *firmware, void (ETB_CALLBACK *user_fct)(int, int));
int		_ETB_EXPORT etb_etcom_download_firmware(ETB *etb, eint64 axis_mask, char *firmware, void (ETB_CALLBACK *user_fct)(int, int));
int		_ETB_EXPORT etb_get_firmware_info (char *firmware, ETB_FW_INFO *info);

/*------------------------------------------------------------------------------
 * debug function for dsmax2 only
 *-----------------------------------------------------------------------------*/
#ifdef LINUX
	#ifdef __powerpc__
		int _ETB_EXPORT dsmax2_set_debug_gpio1(void);
		int _ETB_EXPORT dsmax2_clear_debug_gpio1(void);
		int _ETB_EXPORT dsmax2_set_debug_gpio2(void);
		int _ETB_EXPORT dsmax2_clear_debug_gpio2(void);
		int _ETB_EXPORT dsmax2_set_debug_gpio3(void);
		int _ETB_EXPORT dsmax2_clear_debug_gpio3(void);
	#endif /* __power_pc*/
#endif /*LINUX */

/*@}*/

#ifdef __cplusplus
	} /* extern "C" */
#endif


/**********************************************************************************************************/
/*- C++ WRAPPER CLASSES */
/**********************************************************************************************************/

/*------------------------------------------------------------------------------
 * Etb handlers - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	struct EtbDrvHandler;
	struct EtbEtcomDrvHandler;
	struct EtbBusHandler;
#endif

/*------------------------------------------------------------------------------
 * EtbSvrCommands class
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	/**
	 * @struct EtbSrvCommands
	 * Server (record 00h) command numbers
	 */
	struct EtbSvrCommands {
	public:
		enum { SVR_NUMBER = 0x11 };          /**< Get the number of remote servers in the chain */
		enum { SVR_INFO_0 = 0x12 };          /**< Get the product number and soft version of server */
		enum { SVR_INFO_1 = 0x13 };          /**< Get the serial number and boot version */
		enum { SVR_INFO_2 = 0x14 };          /**< Get the name first 8 bytes*/
		enum { SVR_TIMEOUTS_0 = 0x15 };      /**< Get the bus default timeouts of a remote server */
		enum { SVR_INFO_3 = 0x16 };          /**< Get the name last 8 bytes*/
		enum { SVR_STATUS_0 = 0x21 };        /**< Get the bus status of a remote server */
		enum { SVR_STATUS_IRQ_0 = 0x22 };    /**< The bus status interrupt of a remote server */
		enum { SVR_COUNTERS_0 = 0x25 };      /**< Get the bus counters of a remote server */
		enum { SVR_COUNTERS_IRQ_0 = 0x26 };  /**< The bus counters interrupt of a remote server */
		enum { SVR_KIND = 0x27 };            /**< Get the kind of the server */
		enum { CHANGE_BOOT_MODE = 0x31 };    /**< Change the boot mode of the remote drive */
		enum { START_DOWNLOAD = 0x32 };      /**< Start download of the remote drive */
		enum { DOWNLOAD_SEGMENT = 0x33 };    /**< Download a data segment in the remote drive */
		enum { START_UPLOAD = 0x34 };        /**< Start upload of the remote drive */
		enum { UPLOAD_SEGMENT = 0x35 };      /**< Upload a data segment in the remote drive */
		enum { AUTO_NUMBER = 0x36 };         /**< Renumber the remote drives. Obsolete */
		enum { START_DOWNLOAD_FILE = 0x37 }; /**< start download of a complete file to the remote drive */
		enum { ACTIVATE_DOWNLOAD = 0x38 };   /**< activate the new downloaded firmware (dsgat2 only) */
		enum { START_UPLOAD_FILE = 0x39 };   /**< start upload of a complete file from the remote drive */
		enum { OPEN = 0x41 };                /**< Open a new connection - first message */
		enum { RESET = 0x42 };               /**< Reset the current connection to the server */
		enum { CLOSE = 0x43 };               /**< Close the current connection - last message */
		enum { KEEP_ALIVE = 0x44 };          /**< Keep connection with the server alive */
		enum { START_IRQ = 0x45 };           /**< Ask server to start sendnig irqs when required */
		enum { PURGE_STOP = 0x46 };          /**< Purge queues and stop sending data / interrupts */
		enum { R_MULTI_SEND = 0x50 };        /**< send multiple records */
		enum { R_ALIVE_RATE = 0x60 };        /**< message to define timeout of connection break */
		enum { DOWNLOAD_DATA = 0xF1};        /**< start download of a set of data */
		enum { UPLOAD_DATA = 0xF3};	         /**< start upload of a set of data */
	};
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * EtbMagic class
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	/**
	 * @struct EtbMagic
	 * Magic commands for record 04/12/14
	 */
	struct EtbMagic {
	public:
		enum { WAITING_REC_14 = 0x80 };      /**< Mark a waiting request (record 14) */
		enum { PRESENT = 0x90 };             /**< Mark a drive present request (record 14) */
		enum { WAITING_REC_12 = 0x80 };      /**< Mark a waiting request (record 12) */
		enum { STATUS_DRV_0 = 0x90 };        /**< Mark a drive status request (record 12) */
		enum { STATUS_DRV_IRQ_0 = 0xA0 };    /**< Mark a drive status interrupt (record 12) */
		enum { INFO_DRV_0 = 0xB0 };          /**< Mark the first drive information request (record 12) */
		enum { INFO_DRV_1 = 0xC0 };          /**< Mark the second drive information request (record 12) */
		enum { INFO_DRV_2 = 0xC1 };          /**< Mark the third drive information request (record 12) */
		enum { INFO_DRV_3 = 0xC2 };          /**< Mark the fourth drive information request (record 12) */
		enum { INFO_EXT_0 = 0xD0 };          /**< Mark the first extension card information request (record 12) */
		enum { INFO_EXT_1 = 0xE0 };          /**< Mark the second extension card information request (record 12) */
	};
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * EtbBusEvent class
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	/**
	 * @struct EtbBusEvent
	 * Etel bus handler structure
	 */
	struct EtbBusEvent {
	public:
		enum { ERROR_SET = 0x00000001 };      /**< The error bit has been set */
		enum { ERROR_CLR = 0x00000002 };      /**< The error bit has been cleared */
		enum { ERROR_BIT = 0x00000003 };      /**< The error bit has changed */
		enum { WARNING_SET = 0x00000004 };    /**< The warning bit has been set */
		enum { WARNING_CLR = 0x00000008 };    /**< The warning bit has been cleared */
		enum { WARNING_BIT = 0x0000000C };    /**< The warning bit has changed */
		enum { RESET_SET =  0x00000010 };     /**< The driver has entered reset mode */
		enum { RESET_CLR = 0x00000020 };      /**< The driver has exited reset mode */
		enum { RESET_BIT = 0x00000030 };      /**< The reset bit has changed */
		enum { OPEN_SET = 0x00000040 };       /**< The driver is open */
		enum { OPEN_CLR = 0x00000080 };       /**< The driver is closed */
		enum { OPEN_BIT = 0x000000C0 };       /**< The open bit has changed */
		enum { WATCHDOG_SET =  0x00000100 };  /**< the watchdog bit has been set */
		enum { WATCHDOG_CLR = 0x00000200 };   /**< the watchdog bit has been cleared */
		enum { WATCHDOG_BIT = 0x00000300 };   /**< The watchdog bit has changed */
		enum { STATUS_BIT = 0x00001000 };     /**< The bus status has changed */
	};
#endif

/*------------------------------------------------------------------------------
 * EtbDrvPresent class
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	/**
	 * @struct EtbDrvPresent
	 * Etel bus drive event
	 */
	struct EtbDrvEvent {
	public:
		enum { ERROR_SET = 0x00000001 };      /**< One of the error bit has been set */
		enum { ERROR_CLR = 0x00000002 };      /**< One of the error bit has been cleared */
		enum { ERROR_BIT = 0x00000003 };      /**< One of the error bit has changed */
		enum { WARNING_SET = 0x00000004 };    /**< One of the warning bit has been set */
		enum { WARNING_CLR = 0x00000008 };    /**< One of the warning bit has been cleared */
		enum { WARNING_BIT = 0x0000000C };    /**< One of the warning bit has changed */
		enum { PRESENT_SET = 0x00000010 };    /**< A new drive is present */
		enum { PRESENT_CLR = 0x00000020 };    /**< A drive has disappeared */
		enum { PRESENT_BIT = 0x00000030 };    /**< The present bit has changed */
		enum { STATUS_1 = 0x00000100 };       /**< The first status word has changed */
		enum { STATUS_2 = 0x00000200 };       /**< The second status word has changed */
		enum { STATUS_BIT = 0x00000300 };     /**< One of the status word has changed */
		enum { USER = 0x00001000 };           /**< The user field has changed */
	};
#endif

/*------------------------------------------------------------------------------
 * Etb base class - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	class Etb {
		/*
		 * some public constants
		 */
	public:
		enum { DRIVES = ETB_DRIVES };				  /* the maximum number of drives in an old bus type like */
													  /* EBL2, DSMAX1, DSMAX2, DSMAX3, DSTEB1, DSTEB3 */
													  /* The records passing on these kinds of bus are ETB_REC */
		enum { ETCOM_DRIVES = ETB_ETCOM_DRIVES };     /* the maximum number of drives in an new bus type like */
													  /* UltimET, USB for AccurET */
													  /* The records passing on these kinds of bus are ETB_ETCOM */
		enum { SERVERS = ETB_SERVERS };				  /* the maximum number of servers in the path */

		/*
		 * etb special axis number
		 */
	public:
		enum { ALL_AXIS = 0x40 };                        /* special axis value meaning all axis*/
		enum { MSK_AXIS = 0x20 };                        /* special axis value meaning masked axis */

		/*
		 * timeout special values
		 */
	public:
		enum { DEF_TIMEOUT = (-2L) };                    /* use the default timeout appropriate for this communication */

		/*
		 * versions access
		 */
	public:
		static dword getVersion() {
			return etb_get_version();
		}
		static dword getEdiVersion() {
			return etb_get_edi_version();
		}
		static time_t getBuildTime() {
			return etb_get_build_time();
		}
		static long getTimer() {
			return etb_get_timer();
		}
	public:
		static EtbDrvInfo etbInitDrvInfo(void) {
			EtbDrvInfo info = etb_init_drv_info();
			return info;
		}
		static EtbTimeouts etbInitTimeouts(void) {
			EtbTimeouts timeouts = etb_init_timeouts();
			return timeouts;
		}
		static EtbExtInfo etbInitExtInfo(void) {
			EtbExtInfo info = etb_init_ext_info();
			return info;
		}
		static EtbDrvStatus etbInitDrvStatus(void) {
			EtbDrvStatus status= etb_init_drv_status();
			return status;
		}
		static EtbMasterInfo etbInitMasterInfo(void) {
			EtbMasterInfo info= etb_init_master_info();
			return info;
		}
		static EtbRecParam etbInitRecParam(void) {
			EtbRecParam param = etb_init_rec_param();
			return param;
		}
		static EtbCounters etbInitCounters(void) {
			EtbCounters counters = etb_init_counters();
			return counters;
		}
		static EtbBusStatus etbInitBusStatus(void) {
			EtbBusStatus busStatus = etb_init_bus_status();
			return busStatus;
		}
		static EtbSvrInfo etbInitSvrInfo(void) {
			EtbSvrInfo info = etb_init_svr_info();
			return info;
		}
	};
#endif /* ETB_OO_API */


/*------------------------------------------------------------------------------
 * Etb exception - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	class EtbException {
	friend class EtbBus;
	friend class EtbPortBase;
	friend class EtbPort;
	friend class EtbSpyPort;
	friend class EtbTraductor;
		/*
		 * public error codes
		 */
	public:
		    enum {EBADDRIVER = -293 };                      /* wrong version of the installed device driver */
    enum {EBADDRVVER = -218 };                      /* a drive with a version < 3.00 has been detected */
    enum {EBADFIRMWARE = -200 };                    /* file is not a firmware file */
    enum {EBADHOST = -253 };                        /* the specified host address cannot be translated */
    enum {EBADLIBRARY = -217 };                     /* function of external library not found */
    enum {EBADMODE = -225 };                        /* the drive is in a bad mode */
    enum {EBADMSG = -219 };                         /* a bad message is given */
    enum {EBADOS = -270 };                          /* function unavilable on actual OS */
    enum {EBADPARAM = -215 };                       /* one of the parameter is not valid */
    enum {EBADSERVER = -224 };                      /* a bad/incompatible server was found */
    enum {EBADSTATE = -222 };                       /* this operation is not allowed in this state */
    enum {EBAUDRATE = -292 };                       /* matching baudrate not found */
    enum {EBOOTENTER = -261 };                      /* cannot enter in boot mode */
    enum {EBOOTFAILED = -229 };                     /* a problem has occured while communicating with the boot */
    enum {EBOOTHEADER = -262 };                     /* bad header in boot protocol */
    enum {EBOOTPASSWD = -260 };                     /* bad password when enter in boot mode */
    enum {EBOOTPROG = -263 };                       /* bad block programming */
    enum {EBUSERROR = -220 };                       /* the underlaying etel-bus is in error state */
    enum {EBUSRESET = -221 };                       /* the underlaying etel-bus in performing a reset operation */
    enum {ECHECKSUM = -249 };                       /* checksum error with serial communication */
    enum {ECRC = -230 };                            /* a CRC error has occured */
    enum {EFLASHDEV = -280 };                       /* unable to open flash device */
    enum {EFLASHINFO = -281 };                      /* unable to read flash information */
    enum {EFLASHNOTLOCKED = -285 };                 /* flash not locked */
    enum {EFLASHPROTECTED = -284 };                 /* flash protected */
    enum {EFLASHREAD = -282 };                      /* unable to read flash */
    enum {EFLASHWRITE = -283 };                     /* unable to write flash */
    enum {EFPGAFILENOTFOUND = -291 };               /* FPGA file is not found in path */
    enum {EGPIODEV = -286 };                        /* cannot open the gpio device */
    enum {EINTERNAL = -212 };                       /* some internal error in the etel software */
    enum {EMASTER = -213 };                         /* cannot enter or quit master mode */
    enum {ENETWORK = -252 };                        /* network problem */
    enum {ENODRIVE = -214 };                        /* the specified drive does not respond */
    enum {ENOLIBRARY = -216 };                      /* external library not found */
    enum {EOBSOLETE = -202 };                       /* function is obsolete */
    enum {EOPENCOM = -240 };                        /* the specified communication port cannot be opened */
    enum {EOPENSOCK = -250 };                       /* the specified socket connection cannot be opened */
    enum {ERECTOSMALL = -201 };                     /* size of received record too small */
    enum {ERTVREADSYNCRO = -294 };                  /* RTV read synchronisation error */
    enum {ESERVER = -223 };                         /* the server has incorrect behavior */
    enum {ESOCKRESET = -251 };                      /* the socket connection has been broken by peer */
    enum {ESYSTEM = -211 };                         /* some system resource return an error */
    enum {ETIMEOUT = -210 };                        /* a timeout has occured */
    enum {ETOOSMALL = -203 };                       /* the size of the record table is too small */
    enum {EUNAVAILABLE = -290 };                    /* function not available for the driver */



		/*
		 * error translation
		 */
	public:
		static const char *translate(int code) {
			return etb_translate_error(code);
		}

		/*
		 * exception code
		 */
	private:
		int code;

		/*
		 * constructor
		 */
	protected:
		EtbException(int e) { code = e; };

		/*
		 * get error description
		 */
	public:
		int getCode() {
			return code;
		}
		const char *getText() {
			return translate(code);
		}
	};
#endif /* ETB_OO_API */


/*------------------------------------------------------------------------------
 * Bus class - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	#define ERRCHK(a) do { int _err = (a); if (_err) throw EtbException(_err); } while(0)
	class EtbBus {
	friend class EtbPortBase;
	friend class EtbPort;
	friend class EtbSpyPort;
		/*
		 * internal etb pointer
		 */
	protected:
		ETB *etb;

		/*
		 * open/reset/close flags
		 */
	public:
		enum { FLAG_BOOT_RUN =           0x00000001 }; /* assumes that the drive is in run mode */
		enum { FLAG_BOOT_DIRECT =        0x00000002 }; /* assumes that the drive is in boot mode */
		enum { FLAG_BOOT_BRIDGE =        0x00000004 }; /* assumes that the drive is in boot bridge mode */

		enum { FLAG_MASTER_BRIDGE =      0x00000010 }; /* enter master if an axis 0 is connected */
		enum { FLAG_MASTER_EXIT =        0x00000020 }; /* return to slave mode if the axis 0 is in master mode */
		enum { FLAG_MASTER_NORMAL =      0x00000040 }; /* enter master mas.0=1 if an axis 0 is connected */
		enum { FLAG_MASTER_SPY =         0x00000080 }; /* enter master mas.!=255 */

		enum { FLAG_TIMEOUT_GUARDED =    0x00000100 }; /* check for continous connection in both pc and drive side */
		enum { FLAG_TIMEOUT_DEBUG =      0x00000200 }; /* allows disconnection of the communication - try to recover */
		enum { FLAG_TIMEOUT_DISABLE =    0x00000400 }; /* disable all timeouts on the drive side  - try to recover */

		enum { FLAG_STATUS_POLL =        0x00001000 }; /* continuously send status drive status requests */
		enum { FLAG_STATUS_OFF =         0x00002000 }; /* don't send drive status requests */
		enum { FLAG_STATUS_IRQ =         0x00004000 }; /* use drive interrupt to poll status */
		enum { FLAG_DETECT_OFF =         0x00008000 }; /* don't send any traffics without requests */

		enum { FLAG_CAN_STANDARD =       0x00100000 }; /* use CAN standard 11 bit identifiers */
		enum { FLAG_CAN_EXTENDED =       0x00200000 }; /* use CAN extended 29 bit identifiers */

		enum { FLAG_SYNCHRO_OFF =        0x01000000 }; /* communication detection and bus synchronisation off */
		enum { FLAG_ALL_REQUEST_OFF =    0x02000000 }; /* don't check present axis */
		enum { FLAG_INFO_DRIVE_OFF =     0x04000000 }; /* don't ask drivers informations */
		enum { FLAG_INFO_EXTENSION_OFF = 0x08000000 }; /* don't ask extensions informations */

		enum { FLAG_SPECIAL_SL =         0x10000000 }; /* use speed loop drive - special mode for download only */
		enum { FLAG_RESET_MASTER =       0x20000000 }; /* reset the master (used only with DSMAX) */
		enum { FLAG_RESET_SLAVES =       0x40000000 }; /* reset all slaves (used only with DSC) */
		enum { FLAG_DEBUG_MODE =         0x80000000 }; /* the communication is in a special mode for debug */

		/*
		 * boot modes
		 */
	public:
		enum { BOOT_MODE_RUN = 0 };                      /* drive run mode - normal operation */
		enum { BOOT_MODE_DIRECT = 1 };                   /* direct communication to the connected drive boot */
		enum { BOOT_MODE_BRIDGE = 2 };                   /* allows access to etel bus slave boot */

		/*
		 * special axis number
		 */
	public:
		enum { AXIS_AND = (-2) };                        /* and value of the status bits of all drives presents */
		enum { AXIS_OR = (-1) };                         /* or value of the status bits of all drives presents */

		/*
		 * real-time modes
		 */
	public:
		enum { RT_ACTIVE = 1 };                          /* real-time is running */
		enum { RT_IDLE = 0 };                            /* real-time is idle */
		enum { RT_ERROR = -1 };                          /* real-time is in error */

		/*
		 * constructors
		 */
	public:
		EtbBus() {
			etb = NULL;
			etb_create_bus(&etb);
		}
	protected:
		EtbBus(ETB *b) {
			etb = b;
		};
	public:
		bool isValid() {
			return etb_is_valid_bus(etb);
		}

		/*
		 * destructor function
		 */
		void destroy() {
			ERRCHK(etb_destroy_bus(&etb));
		}

		/*
		 * connection management functions
		 */
	public:
		void open(const char *s, dword flags, long baudrate = 0, long timeout = 0) {
			ERRCHK(etb_open(etb, s, flags, baudrate, timeout));
		}
		void reset(dword flags = 0, long baudrate = 0, long timeout = 0, bool deep = false) {
			ERRCHK(etb_reset(etb, flags, baudrate, timeout, deep));
		}
		void close(dword flags = 0, long timeout = 0) {
			ERRCHK(etb_close(etb, flags, timeout));
		}
		bool isOpen() {
			bool open;
			ERRCHK(etb_is_open(etb, &open));
			return open;
		}
		void getDriver(char *buf, size_t max) {
			ERRCHK(etb_get_driver(etb, buf, max));
		}
		dword getFlags() {
			dword flags;
			ERRCHK(etb_get_flags(etb, &flags));
			return flags;
		}
		long getBaudrate() {
			long baudrate;
			ERRCHK(etb_get_baudrate(etb, &baudrate));
			return baudrate;
		}
		void activateStatus(bool on) {
			int err = etb_activate_status(etb, on);
			ERRCHK(err);
		}
		void diag(char_cp file_name, int line, int err, dword mask) {
			ERRCHK(etb_diag(file_name, line, err, etb, mask));
		}
		void sdiag(char_p str, char_cp file_name, int line, int err, dword mask) {
			ERRCHK(etb_sdiag(str, file_name, line, err, etb, mask));
		}
		void fdiag(char_cp output_file_name, char_cp file_name, int line, int err, dword mask) {
			ERRCHK(etb_fdiag(output_file_name, file_name, line, err, etb, mask));
		}
		void etcomDiag(char_cp file_name, int line, int err, eint64 mask) {
			ERRCHK(etb_etcom_diag(file_name, line, err, etb, mask));
		}
		void etcomSdiag(char_p str, char_cp file_name, int line, int err, eint64 mask) {
			ERRCHK(etb_etcom_sdiag(str, file_name, line, err, etb, mask));
		}
		void etcomFdiag(char_cp output_file_name, char_cp file_name, int line, int err, eint64 mask) {
			ERRCHK(etb_etcom_fdiag(output_file_name, file_name, line, err, etb, mask));
		}

		/*
		 * status/info access functions
		 */
	public:
		EtbBusStatus getBusStatus(int server) {
			ETB_BUS_STATUS status;
			memset(&status, 0, sizeof(ETB_BUS_STATUS));
			status.size = sizeof(ETB_BUS_STATUS);
			ERRCHK(etb_get_bus_status(etb, server, &status));
			return status;
		}
		EtbTimeouts getBusTimeouts() {
			ETB_TIMEOUTS timeouts;
			memset(&timeouts, 0, sizeof(ETB_TIMEOUTS));
			timeouts.size = sizeof(ETB_TIMEOUTS);
			ERRCHK(etb_get_bus_timeouts(etb, &timeouts));
			return timeouts;
		}
		EtbCounters getBusCounters(int server) {
			ETB_COUNTERS counters;
			memset(&counters, 0, sizeof(ETB_COUNTERS));
			counters.size = sizeof(ETB_COUNTERS);
			ERRCHK(etb_get_bus_counters(etb, server, &counters));
			return counters;
		}
		int getSvrNumber() {
			int number;
			ERRCHK(etb_get_svr_number(etb, &number));
			return number;
		}
		EtbSvrInfo getSvrInfo(int server) {
			ETB_SVR_INFO info;
			memset(&info, 0, sizeof(ETB_SVR_INFO));
			info.size = sizeof(ETB_SVR_INFO);
			ERRCHK(etb_get_svr_info(etb, server, &info));
			return info;
		}
		dword getDrvPresent() {
			dword mask;
			ERRCHK(etb_get_drv_present(etb, &mask));
			return mask;
		}
		eint64 etcomGetDrvPresent() {
			eint64 mask;
			ERRCHK(etb_etcom_get_drv_present(etb, &mask));
			return mask;
		}
		int getDrvPeer() {
			dword peer;
			ERRCHK(etb_get_drv_peer(etb, &peer));
			return peer;
		}
		EtbDrvStatus getDrvStatus(int axis) {
			ETB_DRV_STATUS status;
			memset(&status, 0, sizeof(ETB_DRV_STATUS));
			status.size = sizeof(ETB_DRV_STATUS);
			ERRCHK(etb_get_drv_status(etb, axis, &status));
			return status;
		}
		EtbDrvInfo getDrvInfo(int axis) {
			ETB_DRV_INFO info;
			memset(&info, 0, sizeof(ETB_DRV_INFO));
			info.size = sizeof(ETB_DRV_INFO);
			ERRCHK(etb_get_drv_info(etb, axis, &info));
			return info;
		}
		EtbExtInfo getExtInfo(int axis) {
			ETB_EXT_INFO info;
			memset(&info, 0, sizeof(ETB_EXT_INFO));
			info.size = sizeof(ETB_EXT_INFO);
			ERRCHK(etb_get_ext_info(etb, axis, &info));
			return info;
		}
		EtbDrvStatus getEtcomDrvStatus(int axis) {
			ETB_DRV_STATUS status;
			memset(&status, 0, sizeof(ETB_DRV_STATUS));
			status.size = sizeof(ETB_DRV_STATUS);
			ERRCHK(etb_etcom_get_drv_status(etb, axis, &status));
			return status;
		}
		EtbDrvInfo getEtcomDrvInfo(int axis) {
			ETB_DRV_INFO info;
			memset(&info, 0, sizeof(ETB_DRV_INFO));
			info.size = sizeof(ETB_DRV_STATUS);
			ERRCHK(etb_etcom_get_drv_info(etb, axis, &info));
			return info;
		}
		EtbMasterInfo getEtcomMasterInfo() {
			ETB_MASTER_INFO info;
			memset(&info, 0, sizeof(ETB_MASTER_INFO));
			info.size = sizeof(ETB_MASTER_INFO);
			ERRCHK(etb_etcom_get_master_info(etb, &info));
			return info;
		}
		EtbExtInfo getEtcomExtInfo(int axis) {
			ETB_EXT_INFO info;
			memset(&info, 0, sizeof(ETB_EXT_INFO));
			info.size = sizeof(ETB_EXT_INFO);
			ERRCHK(etb_etcom_get_ext_info(etb, axis, &info));
			return info;
		}

		/*
		 * handler management functions
		 */
	public:
		void addBusHandler(void *key, dword svr_mask, dword ev_mask, void (ETB_CALLBACK *handler)(EtbBus, int, dword, void *), void *param) {
			ERRCHK(etb_add_bus_handler(etb, key, svr_mask, ev_mask, (void (ETB_CALLBACK *)(ETB *, int, dword, void *))handler, param));
		}
		void removeBusHandler(void *key) {
			ERRCHK(etb_remove_bus_handler(etb, key));
		}
		void addDrvHandler(void *key, dword axis_mask, bool and_mask, bool or_mask, dword ev_mask, void (ETB_CALLBACK *handler)(EtbBus, int, dword, void *), void *param) {
			ERRCHK(etb_add_drv_handler(etb, key, axis_mask, and_mask, or_mask, ev_mask, (void (ETB_CALLBACK *)(ETB *, int, dword, void *))handler, param));
		}
		void etcomAddDrvHandler(void *key, eint64 axis_mask, bool and_mask, bool or_mask, dword ev_mask, void (ETB_CALLBACK *handler)(EtbBus, int, dword, void *), void *param) {
			ERRCHK(etb_etcom_add_drv_handler(etb, key, axis_mask, and_mask, or_mask, ev_mask, (void (ETB_CALLBACK *)(ETB *, int, dword, void *))handler, param));
		}
		void removeDrvHandler(void *key) {
			ERRCHK(etb_remove_drv_handler(etb, key));
		}
		void addRTHandler(void *key, dword axis_mask, int (ETB_CALLBACK *handler)(EtbBus, int, long *, void *), void *param) {
			ERRCHK(etb_add_rt_handler(etb, key, axis_mask, (int (ETB_CALLBACK *)(ETB *, int, long *, void *))handler, param));
		}
		void removeRTHandler(void *key) {
			ERRCHK(etb_remove_rt_handler(etb, key));
		}

		/*
		 * transaction support
		 */
		void beginTrans(long timeout) {
			ERRCHK(etb_begin_trans(etb, timeout));
		}
		void endTrans() {
			ERRCHK(etb_end_trans(etb));
		}

		/*
		 * boot control functions
		 */
	public:
		void changeBootMode(int mode) {
			ERRCHK(etb_change_boot_mode(etb, mode));
		}
		void startDownload(dword mask, int block) {
			ERRCHK(etb_start_download(etb, mask, block));
		}
		void etcomStartDownload(eint64 mask, int block) {
			ERRCHK(etb_etcom_start_download(etb, mask, block));
		}
		void startDownloadFile(dword mask, char *fileName, int fileSize) {
			ERRCHK(etb_start_download_file(etb, mask, fileName, fileSize));
		}
		void etcomStartDownloadFile(eint64 mask, char *fileName, int fileSize) {
			ERRCHK(etb_etcom_start_download_file(etb, mask, fileName, fileSize));
		}
		void startUploadFile(dword mask, char *fileName, int *fileSize) {
			ERRCHK(etb_start_upload_file(etb, mask, fileName, fileSize));
		}
		void etcomStartUploadFile(eint64 mask, char *fileName, int *fileSize) {
			ERRCHK(etb_etcom_start_upload_file(etb, mask, fileName, fileSize));
		}
		void activateDownload() {
			ERRCHK(etb_activate_download(etb));
		}
		void downloadSegment(const char *buf, size_t size) {
			ERRCHK(etb_download_segment(etb, buf, size));
		}
		void startUpload(int axis, int block) {
			ERRCHK(etb_start_upload(etb, axis, block));
		}
		void etcomStartUpload(int axis, int block) {
			ERRCHK(etb_etcom_start_upload(etb, axis, block));
		}
		void uploadSegment(char *buf, size_t size) {
			ERRCHK(etb_upload_segment(etb, buf, size));
		}
		void autoNumber(int start, bool save) {
			ERRCHK(etb_auto_number(etb, start, save));
		}
		long getBlockSize(int block) {
			long size;
			ERRCHK(etb_get_block_size(block, &size));
			return size;
		}
		void multiSend(int nb_rec, ETB_REC send_table[], dword mask_table[], ETB_REC recv_table[], dword time_table[], int timeout) {
			ERRCHK(etb_multi_send(etb, nb_rec, send_table, mask_table, recv_table, time_table, timeout));
		}
		void etcomMultiSend(int nb_rec, ETB_ETCOM send_table[], eint64 mask_table[], ETB_ETCOM recv_table[], dword time_table[], int timeout) {
			ERRCHK(etb_etcom_multi_send(etb, nb_rec, send_table, mask_table, recv_table, time_table, timeout));
		}
		void startRTM(ETB_TRAJECTORY_HANDLER get_trajectory_point) {
			ERRCHK(etb_start_rtm(etb, get_trajectory_point));
		}
		void stopRTM(void) {
			ERRCHK(etb_stop_rtm(etb));
		}
		void initRTM(ETB_RTM_AXISMASK realtime_axis) {
			ERRCHK(etb_init_rtm_fct(etb, realtime_axis));
		}
		void setPrio(int prio) {
			ERRCHK(etb_set_prio(etb, prio));
		}
		void setRates(int irq_rate, int status_rate, int mon_rate, int fast_rate, int slow_rate) {
			ERRCHK(etb_set_rates(etb, irq_rate, status_rate, mon_rate, fast_rate, slow_rate));
		}
		void getRTMMon(ETB_RTM *rtm_mon) {
			ERRCHK(etb_get_rtm_mon(etb, rtm_mon));
		}
		void linkError(bool on) {
			ERRCHK(etb_link_error(etb, on));
		}
		void irq_watchdog(int watchdog) {
			ERRCHK(etb_irq_watchdog(etb, watchdog));
		}
		void downloadFirmware(dword axis_mask, char *firmware, void (ETB_CALLBACK *user_fct)(int, int)) {
			ERRCHK(etb_download_firmware(etb, axis_mask, firmware, (void (ETB_CALLBACK *)(int, int))user_fct));
		}
		void etcomDownloadFirmware(eint64 axis_mask, char *firmware, void (ETB_CALLBACK *user_fct)(int, int)) {
			ERRCHK(etb_etcom_download_firmware(etb, axis_mask, firmware, (void (ETB_CALLBACK *)(int, int))user_fct));
		}
		void read1Slot(int slot, dword *value) {
			ERRCHK(etb_read_1_slot(etb, slot, value));
		}
		void read2Slot(int slot1, int slot2, dword *value1, dword *value2) {
			ERRCHK(etb_read_2_slot(etb, slot1, slot2, value1, value2));
		}
		void write1Slot(int slot, dword value) {
			ERRCHK(etb_write_1_slot(etb, slot, value));
		}
		void write2Slot(int slot1, int slot2, dword value1, dword value2) {
			ERRCHK(etb_write_2_slot(etb, slot1, slot2, value1, value2));
		}
		void startRTVHandler(int nr, int rate, int delay, ETB_RTV_HANDLER handler, void *user) {
			ERRCHK(etb_start_rtv_handler(etb, nr, rate, delay, handler, user));
		}
		void stopRTVHandler(int nr) {
			ERRCHK(etb_stop_rtv_handler(etb, nr));
		}
	};
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * Port Base class - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	class EtbPortBase {
		/*
		 * internal etb pointer
		 */
	protected:
		ETB_PORT *port;

	public:
		bool isValid() {
			return etb_is_valid_port(port);
		}
		EtbBus getBus() {
			ETB *etb;
			ERRCHK(etb_get_bus(port, &etb));
			EtbBus bus(etb);
			return bus;
		}

		/*
		 * handler management functions
		 */
	public:
		void addMsgHandler(void *key, void (ETB_CALLBACK *handler)(EtbPort, void *), void *param) {
			ERRCHK(etb_add_msg_handler(port, key, (void (ETB_CALLBACK *)(ETB_PORT *, void *))handler, param));
		}
		void removeMsgHandler(void *key) {
			ERRCHK(etb_remove_msg_handler(port, key));
		}

		/*
		 * message handling functions
		 */
	public:
		EtbRec getMsg(dword *mask, const void **key = NULL, dword *rx_time = NULL, long timeout = 0) {
			EtbRec rec;
			ERRCHK(etb_getm(port, key, mask, (ETB_REC *)&rec, rx_time, timeout));
			return rec;
		}
		EtbEtcomMax etcomGetMsg(eint64 *mask, const void **key = NULL, dword *rx_time = NULL, long timeout = 0) {
			EtbEtcomMax rec;
			ERRCHK(etb_etcom_getm(port, key, mask, (ETB_ETCOM *)&rec, ETB_ETCOM_MAX_PARAM, rx_time, timeout));
			return rec;
		}
		EtbRec getRec(dword *rx_time = NULL, long timeout = 0) {
			EtbRec rec;
			ERRCHK(etb_getr(port, (ETB_REC *)&rec, rx_time, timeout));
			return rec;
		}
		EtbEtcomMax etcomGetRec(eint64 *mask = NULL, dword *rx_time = NULL, long timeout = 0) {
			EtbEtcomMax rec;
			ERRCHK(etb_etcom_getr(port, mask, (ETB_ETCOM *)&rec, sizeof(ETB_ETCOMMAX), rx_time, timeout));
			return rec;
		}
	};
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * Port class - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	class EtbPort : public EtbPortBase {
		/*
		 * constructors
		 */
	public:
		EtbPort(EtbBus etb) {
			port = NULL;
			etb_create_port(&port, etb.etb);
		}
	protected:
		EtbPort(ETB_PORT *p) {
			port = p;
		};

		/*
		 * destructor function
		 */
	public:
		void destroy() {
			ERRCHK(etb_destroy_port(&port));
		}

		/*
		 * message handling functions
		 */
	public:
		void putMsg(dword mask, const EtbRec &rec, const void *key = NULL, long timeout = 0) {
			ERRCHK(etb_putm(port, key, mask, (const ETB_REC *)&rec, timeout));
		}
		void etcomPutMsg(dword mask, const EtbEtcom &rec, const void *key = NULL, long timeout = 0) {
			ERRCHK(etb_etcom_putm(port, key, mask, (const ETB_ETCOM *)&rec, timeout));
		}
		void putRec(const EtbRec &rec, long timeout = 0) {
			ERRCHK(etb_putr(port, (const ETB_REC *)&rec, timeout));
		}
		void etcomPutRec(eint64 mask, const EtbEtcom &rec, long timeout = 0) {
			ERRCHK(etb_etcom_putr(port, mask, (const ETB_ETCOM *)&rec, timeout));
		}
	};
#endif /* ETB_OO_API */

/*------------------------------------------------------------------------------
 * Spy Port class - c++
 *-----------------------------------------------------------------------------*/
#ifdef ETB_OO_API
	class EtbSpyPort : public EtbPortBase {
		/*
		 * constructors
		 */
	public:
		EtbSpyPort(EtbBus etb) {
			port = NULL;
			etb_create_spy_port(&port, etb.etb);
		}
	protected:
		EtbSpyPort(ETB_PORT *p) {
			port = p;
		};

		/*
		 * destructor function
		 */
	public:
		void destroy() {
			ERRCHK(etb_destroy_spy_port(&port));
		}
	};
#endif /* ETB_OO_API */

#ifdef ETB_OO_API
typedef void (ETB_CALLBACK *EtbIsoConverter)(EtbBus bus, EtbEtcomValue *incr, double *iso, int incr_type, int conv, int axis, bool to_iso, void *user);
#endif /* ETB_OO_API */

#undef ERRCHK

#endif /* _ETB20_H */

