Re: 'error' from mfilename

I don't know how to attach it, but here is the header file:

The matlab mfile created is copied below it.

Sorry, it's a bit incomprehensible like this...

//********************************************************************
*********//
//********************************************************************
*********//
//
// Source: C:/PCI driver/msdev6/PCIBird/rcs/PCIBird.h
//
// Author: crobertson
//
// Revision: 1.5
//
// Date: 2002/02/19 13:27:58
//
// COPYRIGHT: COPYRIGHT ASCENSION TECHNOLOGY CORPORATION - 2000,
2001
//
//********************************************************************
*********//
//********************************************************************
*********//
//
// DESCRIPTION: PCIBird2.h
//
// Header file containing function prototypes for the BIRD system API
// Also contains definitions of constants and structures required.
//
//********************************************************************
*********//
//********************************************************************
*********//

#define CPLUSPLUS

#ifdef DEF_FILE
#ifdef PCIBIRD2_EXPORTS
#define PCIBIRD_API
#else
#define PCIBIRD_API
#endif
#else
#ifdef CPLUSPLUS
#ifdef PCIBIRD2_EXPORTS
#define PCIBIRD_API __declspec(dllexport)
#else
#define PCIBIRD_API __declspec(dllimport)
#endif
#else
#ifdef PCIBIRD2_EXPORTS
#define PCIBIRD_API extern "C" __declspec(dllexport)
#else
#define PCIBIRD_API extern "C" __declspec(dllimport)
#endif
#endif
#endif

/*********************************************************************
********
ENUMERATED CONSTANTS

**********************************************************************
*******/

//********************************************************************
*********
//
// ERROR MESSAGE format is as follows:
// ===================================
//
// All commands return a 32-bit integer with the following bit
definitions:
//
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
// +-+-+-+-+-+-+-----------+-------+-------------------------------+
// |E|W|X|R|B|M| Reserved |Address| Code |
// +-+-+-+-+-+-+-----------+-------+-------------------------------+
//
// where
//
// E - indicates an ERROR
// (Operation either cannot or will not proceed as intended
// e.g. EEPROM error of some kind. Requires hardware reset
// of system and/or replacement of hardware)
// W - indicates a WARNING
// (Operation may proceed but remedial action needs to be taken
// e.g. Sensor has been removed. Fix by replacing Sensor)
// X - indicates Transmitter related message
// R - indicates Sensor related message
// (If neither X nor R is set then the message is a SYSTEM message)
// B - indicates message originated in the BIRD hardware
// M - indicates there are more messages pending (no longer used)
//
// Address gives the index number of the device generating the
message
// (Driver and system messages always have address 0)
//
// Code - is the status code as enumerated in BIRD_ERROR_CODES
//
//********************************************************************
*********
enum BIRD_ERROR_CODES
{
// ERROR CODE DISPOSITION
// | (Some error codes have been retired.
// | The column below describes which codes
// | have been retired and why. O = Obolete,
// V I = handled internally)
BIRD_ERROR_SUCCESS=0, //00 < > No error
BIRD_ERROR_PCB_HARDWARE_FAILURE, //01 < > indeterminate
failure on PCB
BIRD_ERROR_TRANSMITTER_EEPROM_FAILURE, //02 <I> transmitter
bad eeprom
BIRD_ERROR_SENSOR_SATURATION_START, //03 <I> sensor has gone
into saturation
BIRD_ERROR_ATTACHED_DEVICE_FAILURE, //04 <O> either a sensor
or transmitter reports bad
BIRD_ERROR_CONFIGURATION_DATA_FAILURE, //05 <O> device EEPROM
detected but corrupt
BIRD_ERROR_ILLEGAL_COMMAND_PARAMETER, //06 < > illegal
PARAMETER_TYPE passed to driver
BIRD_ERROR_PARAMETER_OUT_OF_RANGE, //07 < > PARAMETER_TYPE
legal, but PARAMETER out of range
BIRD_ERROR_NO_RESPONSE, //08 <O> no response at all from
target card firmware
BIRD_ERROR_COMMAND_TIME_OUT, //09 < > time out before
response from target board
BIRD_ERROR_INCORRECT_PARAMETER_SIZE, //10 < > size of
parameter passed is incorrect
BIRD_ERROR_INVALID_VENDOR_ID, //11 <O> driver started with
invalid PCI vendor ID
BIRD_ERROR_OPENING_DRIVER, //12 < > couldn't start driver
BIRD_ERROR_INCORRECT_DRIVER_VERSION, //13 < > wrong driver
version found
BIRD_ERROR_NO_DEVICES_FOUND, //14 < > no BIRDs were found
anywhere
BIRD_ERROR_ACCESSING_PCI_CONFIG, //15 < > couldn't access
BIRDs config space
BIRD_ERROR_INVALID_DEVICE_ID, //16 < > device ID out of
range
BIRD_ERROR_FAILED_LOCKING_DEVICE, //17 < > couldn't lock
driver
BIRD_ERROR_BOARD_MISSING_ITEMS, //18 < > config space items
missing
BIRD_ERROR_NOTHING_ATTACHED, //19 <O> card found but no
sensors or transmitters attached
BIRD_ERROR_SYSTEM_PROBLEM, //20 <O> non specific system
problem
BIRD_ERROR_INVALID_SERIAL_NUMBER, //21 <O> serial number does
not exist in system
BIRD_ERROR_DUPLICATE_SERIAL_NUMBER, //22 <O> 2 identical
serial numbers passed in set command
BIRD_ERROR_FORMAT_NOT_SELECTED, //23 <O> data format not
selected yet
BIRD_ERROR_COMMAND_NOT_IMPLEMENTED, //24 < > valid command,
not implemented yet
BIRD_ERROR_INCORRECT_BOARD_DEFAULT, //25 < > incorrect
response to reading parameter
BIRD_ERROR_INCORRECT_RESPONSE, //26 <O> response received,
but data,values in error
BIRD_ERROR_NO_TRANSMITTER_RUNNING, //27 < > there is no
transmitter running
BIRD_ERROR_INCORRECT_RECORD_SIZE, //28 < > data record size
does not match data format size
BIRD_ERROR_TRANSMITTER_OVERCURRENT, //29 <I> transmitter
over-current detected
BIRD_ERROR_TRANSMITTER_OPEN_CIRCUIT, //30 <I> transmitter open
circuit or removed
BIRD_ERROR_SENSOR_EEPROM_FAILURE, //31 <I> sensor bad eeprom
BIRD_ERROR_SENSOR_DISCONNECTED, //32 <I> previously good
sensor has been removed
BIRD_ERROR_SENSOR_REATTACHED, //33 <I> previously good
sensor has been reattached
BIRD_ERROR_NEW_SENSOR_ATTACHED, //34 <O> new sensor attached
BIRD_ERROR_UNDOCUMENTED, //35 <I> undocumented error code
received from bird
BIRD_ERROR_TRANSMITTER_REATTACHED, //36 <I> previously good
transmitter has been reattached
BIRD_ERROR_WATCHDOG, //37 < > watchdog timeout
BIRD_ERROR_CPU_TIMEOUT_START, //38 <I> CPU ran out of time
executing algorithm (start)
BIRD_ERROR_PCB_RAM_FAILURE, //39 <I> BIRD on-board RAM
failure
BIRD_ERROR_INTERFACE, //40 <I> BIRD PCI interface error
BIRD_ERROR_PCB_EPROM_FAILURE, //41 <I> BIRD on-board EPROM
failure
BIRD_ERROR_SYSTEM_STACK_OVERFLOW, //42 <I> BIRD program stack
overrun
BIRD_ERROR_QUEUE_OVERRUN, //43 <I> BIRD error message queue
overrun
BIRD_ERROR_PCB_EEPROM_FAILURE, //44 <I> PCB bad EEPROM
BIRD_ERROR_SENSOR_SATURATION_END, //45 <I> Sensor has gone
out of saturation
BIRD_ERROR_NEW_TRANSMITTER_ATTACHED, //46 <O> new transmitter
attached
BIRD_ERROR_SYSTEM_UNINITIALIZED, //47 < >
InitializeBIRDSystem not called yet
BIRD_ERROR_12V_SUPPLY_FAILURE, //48 <I > 12V Power supply
not within specification
BIRD_ERROR_CPU_TIMEOUT_END, //49 <I> CPU ran out of time
executing algorithm (end)
BIRD_ERROR_INCORRECT_PLD, //50 < > PCB PLD not compatible
with this API DLL
BIRD_ERROR_NO_TRANSMITTER_ATTACHED, //51 < > No transmitter
attached to this ID
BIRD_ERROR_NO_SENSOR_ATTACHED, //52 < > No sensor attached
to this ID

// new error codes added 2/27/03
// (Version 1,31,5,01) multi-sensor, synchronized
BIRD_ERROR_SENSOR_BAD, //53 < > Non-specific hardware
problem
BIRD_ERROR_SENSOR_SATURATED, //54 < > Sensor saturated error
BIRD_ERROR_CPU_TIMEOUT, //55 < > CPU unable to complete
algorithm on current cycle
BIRD_ERROR_UNABLE_TO_CREATE_FILE, //56 < > Could not create
and open file for saving setup
BIRD_ERROR_UNABLE_TO_OPEN_FILE, //57 < > Could not open file
for restoring setup
BIRD_ERROR_MISSING_CONFIGURATION_ITEM, //58 < > Mandatory item
missing from configuration file
BIRD_ERROR_MISMATCHED_DATA, //59 < > Data item in file does
not match system value
BIRD_ERROR_CONFIG_INTERNAL, //60 < > Internal error in
config file handler
BIRD_ERROR_UNRECOGNIZED_MODEL_STRING, //61 < > Board does not
have a valid model string
BIRD_ERROR_INCORRECT_SENSOR, //62 < > Invalid sensor type
attached to this board
BIRD_ERROR_INCORRECT_TRANSMITTER, //63 < > Invalid
transmitter type attached to this board
BIRD_ERROR_MAXIMUM_VALUE // ## value = number of error codes
##
};

// error message defines
#define ERROR_FLAG 0x80000000
#define WARNING_FLAG 0x40000000

#define XMTR_ERROR_SOURCE 0x20000000
#define RCVR_ERROR_SOURCE 0x10000000
#define BIRD_ERROR_SOURCE 0x08000000
// SYSTEM error = none of the above

// NOTE: The MULTIPLE_ERRORS flag is no longer generated
// It has been left in for backwards compatibility
#define MULTIPLE_ERRORS 0x04000000

// DEVICE STATUS ERROR BIT DEFINITIONS
#define GLOBAL_ERROR 0x00000001
#define NOT_ATTACHED 0x00000002
#define SATURATED 0x00000004
#define BAD_EEPROM 0x00000008
#define HARDWARE 0x00000010
#define NON_EXISTENT 0x00000020
#define UNINITIALIZED 0x00000040
#define NO_TRANSMITTER 0x00000080
#define BAD_12V 0x00000100
#define CPU_TIMEOUT 0x00000200
#define INVALID_DEVICE 0x00000400

#define TRUE 1
#define FALSE 0

enum MESSAGE_TYPE
{
SIMPLE_MESSAGE, // short string describing error code
VERBOSE_MESSAGE // long string describing error code
};

enum TRANSMITTER_PARAMETER_TYPE
{
SERIAL_NUMBER_TX, // attached transmitter's serial number
REFERENCE_FRAME, // structure of type DOUBLE_ANGLES_RECORD
XYZ_REFERENCE_FRAME, // boolean value to select/deselect mode
END_OF_TX_LIST
};

enum SENSOR_PARAMETER_TYPE
{
DATA_FORMAT, // enumerated constant of type DATA_FORMAT_TYPE
ANGLE_ALIGN, // structure of type DOUBLE_ANGLES_RECORD
HEMISPHERE, // enumerated constant of type HEMISPHERE_TYPE
FILTER_AC_WIDE_NOTCH, // boolean value to select/deselect filter
FILTER_AC_NARROW_NOTCH, // boolean value to select/deselect filter
FILTER_DC_ADAPTIVE, // double value in range 0.0 (no filtering) to
1.0 (max)
FILTER_ALPHA_PARAMETERS,// structure of type ADAPTIVE_PARAMETERS
FILTER_LARGE_CHANGE, // boolean value to select/deselect filter
QUALITY, // structure of type QUALITY_PARAMETERS
SERIAL_NUMBER_RX, // attached sensor's serial number
END_OF_RX_LIST
};

enum BOARD_PARAMETER_TYPE
{
SERIAL_NUMBER_PCB, // installed board's serial number
END_OF_PCB_LIST
};

enum SYSTEM_PARAMETER_TYPE
{
SELECT_TRANSMITTER, // short int equal to transmitterID of selected
transmitter
POWER_LINE_FREQUENCY, // double value (range is hardware dependent)
AGC_MODE, // enumerated constant of type AGC_MODE_TYPE
MEASUREMENT_RATE, // double value (range is hardware dependent)
MAXIMUM_RANGE, // double value (range is hardware dependent)
METRIC, // boolean value to select metric units for position
END_OF_LIST // end of list place holder
};

enum FILTER_OPTION
{
NO_FILTER,
DEFAULT_FLOCK_FILTER
};

enum HEMISPHERE_TYPE
{
FRONT,
BACK,
TOP,
BOTTOM,
LEFT,
RIGHT
};

enum AGC_MODE_TYPE
{
TRANSMITTER_AND_SENSOR_AGC, // Old style normal addressing mode
SENSOR_AGC_ONLY // Old style extended addressing mode
};

enum DATA_FORMAT_TYPE
{
NO_FORMAT_SELECTED=0,

// SHORT (integer) formats
SHORT_POSITION,
SHORT_ANGLES,
SHORT_MATRIX,
SHORT_QUATERNIONS,
SHORT_POSITION_ANGLES,
SHORT_POSITION_MATRIX,
SHORT_POSITION_QUATERNION,

// DOUBLE (floating point) formats
DOUBLE_POSITION,
DOUBLE_ANGLES,
DOUBLE_MATRIX,
DOUBLE_QUATERNIONS,
DOUBLE_POSITION_ANGLES, // system default
DOUBLE_POSITION_MATRIX,
DOUBLE_POSITION_QUATERNION,

// DOUBLE (floating point) formats with time stamp appended
DOUBLE_POSITION_TIME_STAMP,
DOUBLE_ANGLES_TIME_STAMP,
DOUBLE_MATRIX_TIME_STAMP,
DOUBLE_QUATERNIONS_TIME_STAMP,
DOUBLE_POSITION_ANGLES_TIME_STAMP,
DOUBLE_POSITION_MATRIX_TIME_STAMP,
DOUBLE_POSITION_QUATERNION_TIME_STAMP,

// DOUBLE (floating point) formats with time stamp appended and
quality #
DOUBLE_POSITION_TIME_Q,
DOUBLE_ANGLES_TIME_Q,
DOUBLE_MATRIX_TIME_Q,
DOUBLE_QUATERNIONS_TIME_Q,
DOUBLE_POSITION_ANGLES_TIME_Q,
DOUBLE_POSITION_MATRIX_TIME_Q,
DOUBLE_POSITION_QUATERNION_TIME_Q,

// These DATA_FORMAT_TYPE codes contain every format in a single
structure
SHORT_ALL,
DOUBLE_ALL,
DOUBLE_ALL_TIME_STAMP,
DOUBLE_ALL_TIME_STAMP_Q,
DOUBLE_ALL_TIME_STAMP_Q_RAW, // this format contains a raw data
matrix and
// is for factory use only...
MAXIMUM_FORMAT_CODE
};

enum BOARD_TYPES
{
PCIBIRDII, // <obsolete>
PCIBIRD_STD1, // single standard sensor
PCIBIRD_STD2, // dual standard sensor
PCIBIRD_8mm1, // single 8mm sensor
PCIBIRD_8mm2, // dual 8mm sensor
PCIBIRD_2mm1, // single 2mm sensor (microsensor)
PCIBIRD_2mm2, // dual 2mm sensor (microsensor)
PCIBIRD_UNKNOWN // default
};

enum DEVICE_TYPES
{
STANDARD_SENSOR, // standard sensor
TYPE_800_SENSOR, // 8mm sensor
STANDARD_TRANSMITTER, //
MINIBIRD_TRANSMITTER, //
SMALL_TRANSMITTER, // "compact" transmitter
TYPE_500_SENSOR, // 5mm sensor
TYPE_180_SENSOR, // microsensor
UNKNOWN_SENSOR, // default
UNKNOWN_TRANSMITTER // default
};

/*********************************************************************
********
TYPEDEF DEFINITIONS

**********************************************************************
*******/

#ifndef BASETYPES
#define BASETYPES
typedef unsigned long ULONG;
typedef ULONG *PULONG;
typedef unsigned short USHORT;
typedef USHORT *PUSHORT;
typedef unsigned char UCHAR;
typedef UCHAR *PUCHAR;
typedef char *PSZ;
#endif /* !BASETYPES */

typedef char CHAR;
typedef const CHAR *LPCSTR, *PCSTR;
typedef LPCSTR LPCTSTR;
typedef int BOOL;
typedef ULONG DEVICE_STATUS;

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned long DWORD;

/*********************************************************************
********
STRUCTURE DEFINITIONS

**********************************************************************
*******/

typedef struct tagTRANSMITTER_CONFIGURATION
{
ULONG serialNumber;
USHORT boardNumber;
USHORT channelNumber;
enum DEVICE_TYPES type;
BOOL attached;
} TRANSMITTER_CONFIGURATION;

typedef struct tagSENSOR_CONFIGURATION
{
ULONG serialNumber;
USHORT boardNumber;
USHORT channelNumber;
enum DEVICE_TYPES type;
BOOL attached;
} SENSOR_CONFIGURATION;

typedef struct tagBOARD_CONFIGURATION
{
ULONG serialNumber;
enum BOARD_TYPES type;
USHORT revision;
USHORT numberTransmitters;
USHORT numberSensors;
USHORT firmwareNumber;
USHORT firmwareRevision;
char modelString[10];

} BOARD_CONFIGURATION;

typedef struct tagSYSTEM_CONFIGURATION
{
double measurementRate;
double powerLineFrequency;
double maximumRange;
enum AGC_MODE_TYPE agcMode;
int numberBoards;
int numberSensors;
int numberTransmitters;
int transmitterIDRunning;
BOOL metric;
} SYSTEM_CONFIGURATION;

typedef struct tagADAPTIVE_PARAMETERS
{
USHORT alphaMin[7];
USHORT alphaMax[7];
USHORT vm[7];
BOOL alphaOn;
} ADAPTIVE_PARAMETERS;

typedef struct tagQUALITY_PARAMETERS
{
USHORT error_slope;
USHORT error_offset;
USHORT error_sensitivity;
USHORT filter_alpha;
} QUALITY_PARAMETERS;

typedef struct tagSHORT_POSITION
{
short x;
short y;
short z;
} SHORT_POSITION_RECORD;

typedef struct tagSHORT_ANGLES
{
short a; // azimuth
short e; // elevation
short r; // roll
} SHORT_ANGLES_RECORD;

typedef struct tagSHORT_MATRIX
{
short s[3][3];
} SHORT_MATRIX_RECORD;

typedef struct tagSHORT_QUATERNIONS
{
short q[4];
} SHORT_QUATERNIONS_RECORD;

typedef struct tagSHORT_POSITION_ANGLES
{
short x;
short y;
short z;
short a;
short e;
short r;
} SHORT_POSITION_ANGLES_RECORD;

typedef struct tagSHORT_POSITION_MATRIX
{
short x;
short y;
short z;
short s[3][3];
} SHORT_POSITION_MATRIX_RECORD;

typedef struct tagSHORT_POSITION_QUATERNION
{
short x;
short y;
short z;
short q[4];
} SHORT_POSITION_QUATERNION_RECORD;

typedef struct tagDOUBLE_POSITION
{
double x;
double y;
double z;
} DOUBLE_POSITION_RECORD;

typedef struct tagDOUBLE_ANGLES
{
double a; // azimuth
double e; // elevation
double r; // roll
} DOUBLE_ANGLES_RECORD;

typedef struct tagDOUBLE_MATRIX
{
double s[3][3];
} DOUBLE_MATRIX_RECORD;

typedef struct tagDOUBLE_QUATERNIONS
{
double q[4];
} DOUBLE_QUATERNIONS_RECORD;

typedef struct tagDOUBLE_POSITION_ANGLES
{
double x;
double y;
double z;
double a;
double e;
double r;
} DOUBLE_POSITION_ANGLES_RECORD;

typedef struct tagDOUBLE_POSITION_MATRIX
{
double x;
double y;
double z;
double s[3][3];
} DOUBLE_POSITION_MATRIX_RECORD;

typedef struct tagDOUBLE_POSITION_QUATERNION
{
double x;
double y;
double z;
double q[4];
} DOUBLE_POSITION_QUATERNION_RECORD;

typedef struct tagDOUBLE_POSITION_TIME_STAMP
{
double x;
double y;
double z;
double time;
} DOUBLE_POSITION_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_ANGLES_TIME_STAMP
{
double a; // azimuth
double e; // elevation
double r; // roll
double time;
} DOUBLE_ANGLES_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_MATRIX_TIME_STAMP
{
double s[3][3];
double time;
} DOUBLE_MATRIX_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_QUATERNIONS_TIME_STAMP
{
double q[4];
double time;
} DOUBLE_QUATERNIONS_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_POSITION_ANGLES_TIME_STAMP
{
double x;
double y;
double z;
double a;
double e;
double r;
double time;
} DOUBLE_POSITION_ANGLES_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_POSITION_MATRIX_STAMP_RECORD
{
double x;
double y;
double z;
double s[3][3];
double time;
} DOUBLE_POSITION_MATRIX_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_POSITION_QUATERNION_STAMP_RECORD
{
double x;
double y;
double z;
double q[4];
double time;
} DOUBLE_POSITION_QUATERNION_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_POSITION_TIME_Q
{
double x;
double y;
double z;
double time;
USHORT quality;
} DOUBLE_POSITION_TIME_Q_RECORD;

typedef struct tagDOUBLE_ANGLES_TIME_Q
{
double a; // azimuth
double e; // elevation
double r; // roll
double time;
USHORT quality;
} DOUBLE_ANGLES_TIME_Q_RECORD;

typedef struct tagDOUBLE_MATRIX_TIME_Q
{
double s[3][3];
double time;
USHORT quality;
} DOUBLE_MATRIX_TIME_Q_RECORD;

typedef struct tagDOUBLE_QUATERNIONS_TIME_Q
{
double q[4];
double time;
USHORT quality;
} DOUBLE_QUATERNIONS_TIME_Q_RECORD;

typedef struct tagDOUBLE_POSITION_ANGLES_TIME_Q
{
double x;
double y;
double z;
double a;
double e;
double r;
double time;
USHORT quality;
} DOUBLE_POSITION_ANGLES_TIME_Q_RECORD;

typedef struct tagDOUBLE_POSITION_MATRIX_TIME_Q_RECORD
{
double x;
double y;
double z;
double s[3][3];
double time;
USHORT quality;
} DOUBLE_POSITION_MATRIX_TIME_Q_RECORD;

typedef struct tagDOUBLE_POSITION_QUATERNION_TIME_Q_RECORD
{
double x;
double y;
double z;
double q[4];
double time;
USHORT quality;
} DOUBLE_POSITION_QUATERNION_TIME_Q_RECORD;

typedef struct tagSHORT_ALL_RECORD
{
short x;
short y;
short z;
short a; // azimuth
short e; // elevation
short r; // roll
short s[3][3];
short q[4];
}SHORT_ALL_RECORD;

typedef struct tagDOUBLE_ALL_RECORD
{
double x;
double y;
double z;
double a; // azimuth
double e; // elevation
double r; // roll
double s[3][3];
double q[4];
}DOUBLE_ALL_RECORD;

typedef struct tagDOUBLE_ALL_TIME_STAMP_RECORD
{
double x;
double y;
double z;
double a; // azimuth
double e; // elevation
double r; // roll
double s[3][3];
double q[4];
double time;
}DOUBLE_ALL_TIME_STAMP_RECORD;

typedef struct tagDOUBLE_ALL_TIME_STAMP_Q_RECORD
{
double x;
double y;
double z;
double a; // azimuth
double e; // elevation
double r; // roll
double s[3][3];
double q[4];
double time;
USHORT quality;
}DOUBLE_ALL_TIME_STAMP_Q_RECORD;

typedef struct tagDOUBLE_ALL_TIME_STAMP_Q_RAW_RECORD
{
double x;
double y;
double z;
double a; // azimuth
double e; // elevation
double r; // roll
double s[3][3];
double q[4];
double time;
USHORT quality;
double raw[3][3];
}DOUBLE_ALL_TIME_STAMP_Q_RAW_RECORD;

/*********************************************************************
********
FUNCTION PROTOTYPES

**********************************************************************
*******/

/*
InitializeBIRDSystem Starts and initializes driver, resets
hardware and interrogates hardware. Builds
local database of system resources.

Parameters Passed: none

Return Value: error status

Remarks: Can be used anytime a catastrophic failure
has occurred and the system needs to be
restarted.

*/
PCIBIRD_API int InitializeBIRDSystem(void);

/*
GetBIRDSystemConfiguration

Parameters Passed: SYSTEM_CONFIGURATION*

Return Value: error status

Remarks: Returns SYSTEM_CONFIGURATION structure
It contains values equal to the number of
transmitters, sensors and boards detected
in the system. (The board information is for
test/diagnostic purposes, all commands
reference sensors and transmitters only) Once
the number of devices is known, (e.g. n) the
range of IDs for those devices becomes 0..(n-1)
*/
PCIBIRD_API int GetBIRDSystemConfiguration(
SYSTEM_CONFIGURATION* systemConfiguration
);

/*
GetTransmitterConfiguration

Parameters Passed: USHORT transmitterID
TRANSMITTER_CONFIGURATION *transmitterConfiguration

Return Value: error status

Remarks: After getting system config the user can then pass
the index of a transmitter of interest to this function
which will then return the config for that transmitter.
Items of interest are the serial number and status.

*/
PCIBIRD_API int GetTransmitterConfiguration(
USHORT transmitterID,
TRANSMITTER_CONFIGURATION* transmitterConfiguration
);

/*
GetSensorConfiguration

Parameters Passed: USHORT sensorID,
SENSOR_CONFIGURATION* sensorConfiguration

Return Value: error status

Remarks: Similar to the transmitter function.

*/
PCIBIRD_API int GetSensorConfiguration(
USHORT sensorID,
SENSOR_CONFIGURATION* sensorConfiguration
);

/*
GetBoardConfiguration

Parameters Passed: USHORT boardID,
BOARD_CONFIGURATION* boardConfiguration

Return Value: error status

Remarks: Similar to the Sensor and Transmitter
functions. Also returns information on
how many sensors and transmitters are
attached. NOTE: Board information is not
needed during normal operation this is
only provided for "accounting" purposes.

*/
PCIBIRD_API int GetBoardConfiguration(
USHORT boardID,
BOARD_CONFIGURATION* boardConfiguration
);

/*
GetAsynchronousRecord

Parameters Passed: USHORT sensorID,
void *pRecord,
int recordSize

Return Value: error status

Remarks: Returns data immediately in the currently
selected format from the last measurement
cycle. Requires user providing a buffer large
enough for the result otherwise an error is
generated and data lost.
(Old style BIRD POINT mode)

*/
PCIBIRD_API int GetAsynchronousRecord(
USHORT sensorID,
void *pRecord,
int recordSize
);

/*
GetSynchronousRecord

Parameters Passed: USHORT sensorID,
void *pRecord,
int recordSize

Return Value: error status

Remarks: Returns a record after next measurement cycle. Puts
system into mode where records are generated 1/cycle.
Will return one and only one record per measurement
cycle. Will queue the records for each measurement
cycle if command not issued sufficiently often. If
command issued too often will time-out with no data.
(old style BIRD STREAM mode)

*/
PCIBIRD_API int GetSynchronousRecord(
USHORT sensorID,
void *pRecord,
int recordSize
);

/*
GetSystemParameter

Parameters Passed: PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: When a properly enumerated parameter type constant
is used, the command will return the parameter value
to the buffer provided by the user. An error is
generated if the buffer is incorrectly sized

*/
PCIBIRD_API int GetSystemParameter(
enum SYSTEM_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
SetSystemParameter

Parameters Passed: PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: Similar to GetSystemParameter but allows user
to set (write) the parameter.

*/
PCIBIRD_API int SetSystemParameter(
enum SYSTEM_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
GetSensorParameter

Parameters Passed: USHORT sensorID,
PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: When a sensor is selected with a valid index (ID)
and a properly enumerated parameter type constant
is used, the command will return the parameter value
to the buffer provided by the user. An error is
generated if the buffer is incorrectly sized

*/
PCIBIRD_API int GetSensorParameter(
USHORT sensorID,
enum SENSOR_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
SetSensorParameter

Parameters Passed: USHORT sensorID,
PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: Similar to GetSensorParameter but allows user
to set (write) the parameter.

*/
PCIBIRD_API int SetSensorParameter(
USHORT sensorID,
enum SENSOR_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
GetTransmitterParameter

Parameters Passed: USHORT transmitterID,
PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: Same as Sensor command

*/
PCIBIRD_API int GetTransmitterParameter(
USHORT transmitterID,
enum TRANSMITTER_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
SetTransmitterParameter

Parameters Passed: USHORT transmitterID,
PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize

Return Value: error status

Remarks: Same as sensor command

*/
PCIBIRD_API int SetTransmitterParameter(
USHORT transmitterID,
enum TRANSMITTER_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*
GetBIRDError

Parameters Passed: none

Return Value: error status

Remarks: Returns next error in queue
if available

*/
PCIBIRD_API int GetBIRDError(
void
);

/*
GetErrorText

Parameters Passed: int errorCode
char *pBuffer
int bufferSize
int type

Return Value: error status as a text string

Remarks: ErrorCode contains the error code returned from
either a command or in response to GetBIRDError
and which is to be described by a text string.
Pass a pointer pBuffer to a buffer to contain
the result of the command. The size of the
buffer is contained in bufferSize. The type
parameter is an enumerated constant of
the type MESSAGE_TYPE.

*/
PCIBIRD_API int GetErrorText(
int errorCode,
char *pBuffer,
int bufferSize,
enum MESSAGE_TYPE type
);

/*

*/
PCIBIRD_API DEVICE_STATUS GetSensorStatus(
USHORT sensorID
);

/*

*/
PCIBIRD_API DEVICE_STATUS GetTransmitterStatus(
USHORT transmitterID
);

/*

*/
PCIBIRD_API DEVICE_STATUS GetBoardStatus(
USHORT boardID
);

/*

*/
PCIBIRD_API DEVICE_STATUS GetSystemStatus(
// no id required
);

/*

*/
PCIBIRD_API int SaveSystemConfiguration(
LPCTSTR lpFileName
);

/*

*/
PCIBIRD_API int RestoreSystemConfiguration(
LPCTSTR lpFileName
);

/*

*/
PCIBIRD_API int GetBoardParameter(
USHORT boardID,
enum BOARD_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*

*/
PCIBIRD_API int SetBoardParameter(
USHORT boardID,
enum BOARD_PARAMETER_TYPE parameterType,
void *pBuffer,
int bufferSize
);

/*

*/
PCIBIRD_API int CloseBIRDSystem(void);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Matlab file:
function [methodinfo,structs,enuminfo]=newPCIBird;
% newPCIBird Create structures to define interfaces found in
'PCIBird3'.
%This function was generated by the perl file prototypes.pl called
from loadlibary.m on Fri Feb 3 15:53:28 2006
%perl options:'PCIBird3.i -outfile=newPCIBird.m'
ival={cell(1,0)}; % change 0 to the actual number of functions to
preallocate the data.
fcns=struct('name',ival,'calltype',ival,'LHS',ival,'RHS',ival,'alias',
ival);
structs=[];enuminfo=[];fcnNum=1;
% int InitializeBIRDSystem(void);
fcns.name{fcnNum}='InitializeBIRDSystem';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}=[];fcnNum=fcnNum+1;
% int GetBIRDSystemConfiguration( SYSTEM_CONFIGURATION*
systemConfiguration );
fcns.name{fcnNum}='GetBIRDSystemConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'tagSYSTEM_CONFIGURATIONPtr'};fcnNum=fcnNum+1;
% int GetTransmitterConfiguration( USHORT transmitterID,
TRANSMITTER_CONFIGURATION* transmitterConfiguration );
fcns.name{fcnNum}='GetTransmitterConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16',
'tagTRANSMITTER_CONFIGURATIONPtr'};fcnNum=fcnNum+1;
% int GetSensorConfiguration( USHORT sensorID,
SENSOR_CONFIGURATION* sensorConfiguration );
fcns.name{fcnNum}='GetSensorConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16',
'tagSENSOR_CONFIGURATIONPtr'};fcnNum=fcnNum+1;
% int GetBoardConfiguration( USHORT boardID, BOARD_CONFIGURATION*
boardConfiguration );
fcns.name{fcnNum}='GetBoardConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16',
'tagBOARD_CONFIGURATIONPtr'};fcnNum=fcnNum+1;
% int GetAsynchronousRecord( USHORT sensorID, void *pRecord, int
recordSize );
fcns.name{fcnNum}='GetAsynchronousRecord';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int GetSynchronousRecord( USHORT sensorID, void *pRecord, int
recordSize );
fcns.name{fcnNum}='GetSynchronousRecord';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int GetSystemParameter( enum SYSTEM_PARAMETER_TYPE parameterType,
void *pBuffer, int bufferSize );
fcns.name{fcnNum}='GetSystemParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'error', 'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int SetSystemParameter( enum SYSTEM_PARAMETER_TYPE parameterType,
void *pBuffer, int bufferSize );
fcns.name{fcnNum}='SetSystemParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'error', 'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int GetSensorParameter( USHORT sensorID, enum
SENSOR_PARAMETER_TYPE parameterType, void *pBuffer, int bufferSize );

fcns.name{fcnNum}='GetSensorParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'error', 'voidPtr',
'int32'};fcnNum=fcnNum+1;
% int SetSensorParameter( USHORT sensorID, enum
SENSOR_PARAMETER_TYPE parameterType, void *pBuffer, int bufferSize );

fcns.name{fcnNum}='SetSensorParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'error', 'voidPtr',
'int32'};fcnNum=fcnNum+1;
% int GetTransmitterParameter( USHORT transmitterID, enum
TRANSMITTER_PARAMETER_TYPE parameterType, void *pBuffer, int
bufferSize );
fcns.name{fcnNum}='GetTransmitterParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'error', 'voidPtr',
'int32'};fcnNum=fcnNum+1;
% int SetTransmitterParameter( USHORT transmitterID, enum
TRANSMITTER_PARAMETER_TYPE parameterType, void *pBuffer, int
bufferSize );
fcns.name{fcnNum}='SetTransmitterParameter';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'uint16', 'error', 'voidPtr',
'int32'};fcnNum=fcnNum+1;
% int GetBIRDError( void );
fcns.name{fcnNum}='GetBIRDError'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}=[];fcnNum=fcnNum+1;
% int GetErrorText( int errorCode, char *pBuffer, int bufferSize,
enum MESSAGE_TYPE type );
fcns.name{fcnNum}='GetErrorText'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'string',
'int32', 'error'};fcnNum=fcnNum+1;
% DEVICE_STATUS GetSensorStatus( USHORT sensorID );
fcns.name{fcnNum}='GetSensorStatus'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='uint32';
fcns.RHS{fcnNum}={'uint16'};fcnNum=fcnNum+1;
% DEVICE_STATUS GetTransmitterStatus( USHORT transmitterID );
fcns.name{fcnNum}='GetTransmitterStatus';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='uint32';
fcns.RHS{fcnNum}={'uint16'};fcnNum=fcnNum+1;
% DEVICE_STATUS GetBoardStatus( USHORT boardID );
fcns.name{fcnNum}='GetBoardStatus'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='uint32';
fcns.RHS{fcnNum}={'uint16'};fcnNum=fcnNum+1;
% DEVICE_STATUS GetSystemStatus( );
fcns.name{fcnNum}='GetSystemStatus'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='uint32';
fcns.RHS{fcnNum}={'error'};fcnNum=fcnNum+1;
% int SaveSystemConfiguration( LPCTSTR lpFileName );
fcns.name{fcnNum}='SaveSystemConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'int8Ptr'};fcnNum=fcnNum+1;
% int RestoreSystemConfiguration( LPCTSTR lpFileName );
fcns.name{fcnNum}='RestoreSystemConfiguration';
fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32';
fcns.RHS{fcnNum}={'int8Ptr'};fcnNum=fcnNum+1;
% int GetBoardParameter( USHORT boardID, enum BOARD_PARAMETER_TYPE
parameterType, void *pBuffer, int bufferSize );
fcns.name{fcnNum}='GetBoardParameter'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'uint16', 'error',
'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int SetBoardParameter( USHORT boardID, enum BOARD_PARAMETER_TYPE
parameterType, void *pBuffer, int bufferSize );
fcns.name{fcnNum}='SetBoardParameter'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'uint16', 'error',
'voidPtr', 'int32'};fcnNum=fcnNum+1;
% int CloseBIRDSystem(void);
fcns.name{fcnNum}='CloseBIRDSystem'; fcns.calltype{fcnNum}='cdecl';
fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}=[];fcnNum=fcnNum+1;
structs.tagTRANSMITTER_CONFIGURATION.packing=8;
structs.tagTRANSMITTER_CONFIGURATION.members=struct('serialNumber',
'uint32', 'boardNumber', 'uint16', 'channelNumber', 'uint16', 'type',
'error', 'attached', 'int32');
structs.tagSENSOR_CONFIGURATION.packing=8;
structs.tagSENSOR_CONFIGURATION.members=struct('serialNumber',
'uint32', 'boardNumber', 'uint16', 'channelNumber', 'uint16', 'type',
'error', 'attached', 'int32');
structs.tagBOARD_CONFIGURATION.packing=8;
structs.tagBOARD_CONFIGURATION.members=struct('serialNumber',
'uint32', 'type', 'error', 'revision', 'uint16',
'numberTransmitters', 'uint16', 'numberSensors', 'uint16',
'firmwareNumber', 'uint16', 'firmwareRevision', 'uint16', 'error0', '
char modelString[10]');
structs.tagSYSTEM_CONFIGURATION.packing=8;
structs.tagSYSTEM_CONFIGURATION.members=struct('measurementRate',
'double', 'powerLineFrequency', 'double', 'maximumRange', 'double',
'agcMode', 'error', 'numberBoards', 'int32', 'numberSensors',
'int32', 'numberTransmitters', 'int32', 'transmitterIDRunning',
'int32', 'metric', 'int32');
structs.tagADAPTIVE_PARAMETERS.packing=8;
structs.tagADAPTIVE_PARAMETERS.members=struct('error0', ' USHORT
alphaMin[7]', 'error1', ' USHORT alphaMax[7]', 'error2', ' USHORT
vm[7]', 'alphaOn', 'int32');
structs.tagQUALITY_PARAMETERS.packing=8;
structs.tagQUALITY_PARAMETERS.members=struct('error_slope', 'uint16',
'error_offset', 'uint16', 'error_sensitivity', 'uint16',
'filter_alpha', 'uint16');
structs.tagSHORT_POSITION.packing=8;
structs.tagSHORT_POSITION.members=struct('x', 'int16', 'y', 'int16',
'z', 'int16');
structs.tagSHORT_ANGLES.packing=8;
structs.tagSHORT_ANGLES.members=struct('a', 'int16', 'e', 'int16',
'r', 'int16');
structs.tagSHORT_MATRIX.packing=8;
structs.tagSHORT_MATRIX.members=struct('error0', ' short s[3][3]');
structs.tagSHORT_QUATERNIONS.packing=8;
structs.tagSHORT_QUATERNIONS.members=struct('error0', ' short q[4]');
structs.tagSHORT_POSITION_ANGLES.packing=8;
structs.tagSHORT_POSITION_ANGLES.members=struct('x', 'int16', 'y',
'int16', 'z', 'int16', 'a', 'int16', 'e', 'int16', 'r', 'int16');
structs.tagSHORT_POSITION_MATRIX.packing=8;
structs.tagSHORT_POSITION_MATRIX.members=struct('x', 'int16', 'y',
'int16', 'z', 'int16', 'error0', ' short s[3][3]');
structs.tagSHORT_POSITION_QUATERNION.packing=8;
structs.tagSHORT_POSITION_QUATERNION.members=struct('x', 'int16',
'y', 'int16', 'z', 'int16', 'error0', ' short q[4]');
structs.tagDOUBLE_POSITION.packing=8;
structs.tagDOUBLE_POSITION.members=struct('x', 'double', 'y',
'double', 'z', 'double');
structs.tagDOUBLE_ANGLES.packing=8;
structs.tagDOUBLE_ANGLES.members=struct('a', 'double', 'e', 'double',
'r', 'double');
structs.tagDOUBLE_MATRIX.packing=8;
structs.tagDOUBLE_MATRIX.members=struct('error0', ' double s[3][3]');
structs.tagDOUBLE_QUATERNIONS.packing=8;
structs.tagDOUBLE_QUATERNIONS.members=struct('error0', ' double
q[4]');
structs.tagDOUBLE_POSITION_ANGLES.packing=8;
structs.tagDOUBLE_POSITION_ANGLES.members=struct('x', 'double', 'y',
'double', 'z', 'double', 'a', 'double', 'e', 'double', 'r',
'double');
structs.tagDOUBLE_POSITION_MATRIX.packing=8;
structs.tagDOUBLE_POSITION_MATRIX.members=struct('x', 'double', 'y',
'double', 'z', 'double', 'error0', ' double s[3][3]');
structs.tagDOUBLE_POSITION_QUATERNION.packing=8;
structs.tagDOUBLE_POSITION_QUATERNION.members=struct('x', 'double',
'y', 'double', 'z', 'double', 'error0', ' double q[4]');
structs.tagDOUBLE_POSITION_TIME_STAMP.packing=8;
structs.tagDOUBLE_POSITION_TIME_STAMP.members=struct('x', 'double',
'y', 'double', 'z', 'double', 'time', 'double');
structs.tagDOUBLE_ANGLES_TIME_STAMP.packing=8;
structs.tagDOUBLE_ANGLES_TIME_STAMP.members=struct('a', 'double',
'e', 'double', 'r', 'double', 'time', 'double');
structs.tagDOUBLE_MATRIX_TIME_STAMP.packing=8;
structs.tagDOUBLE_MATRIX_TIME_STAMP.members=struct('error0', ' double
s[3][3]', 'time', 'double');
structs.tagDOUBLE_QUATERNIONS_TIME_STAMP.packing=8;
structs.tagDOUBLE_QUATERNIONS_TIME_STAMP.members=struct('error0', '
double q[4]', 'time', 'double');
structs.tagDOUBLE_POSITION_ANGLES_TIME_STAMP.packing=8;
structs.tagDOUBLE_POSITION_ANGLES_TIME_STAMP.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'a', 'double', 'e', 'double',
'r', 'double', 'time', 'double');
structs.tagDOUBLE_POSITION_MATRIX_STAMP_RECORD.packing=8;
structs.tagDOUBLE_POSITION_MATRIX_STAMP_RECORD.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'error0', ' double s[3][3]',
'time', 'double');
structs.tagDOUBLE_POSITION_QUATERNION_STAMP_RECORD.packing=8;
structs.tagDOUBLE_POSITION_QUATERNION_STAMP_RECORD.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'error0', ' double q[4]',
'time', 'double');
structs.tagDOUBLE_POSITION_TIME_Q.packing=8;
structs.tagDOUBLE_POSITION_TIME_Q.members=struct('x', 'double', 'y',
'double', 'z', 'double', 'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_ANGLES_TIME_Q.packing=8;
structs.tagDOUBLE_ANGLES_TIME_Q.members=struct('a', 'double', 'e',
'double', 'r', 'double', 'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_MATRIX_TIME_Q.packing=8;
structs.tagDOUBLE_MATRIX_TIME_Q.members=struct('error0', ' double
s[3][3]', 'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_QUATERNIONS_TIME_Q.packing=8;
structs.tagDOUBLE_QUATERNIONS_TIME_Q.members=struct('error0', '
double q[4]', 'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_POSITION_ANGLES_TIME_Q.packing=8;
structs.tagDOUBLE_POSITION_ANGLES_TIME_Q.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'a', 'double', 'e', 'double',
'r', 'double', 'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_POSITION_MATRIX_TIME_Q_RECORD.packing=8;
structs.tagDOUBLE_POSITION_MATRIX_TIME_Q_RECORD.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'error0', ' double s[3][3]',
'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_POSITION_QUATERNION_TIME_Q_RECORD.packing=8;
structs.tagDOUBLE_POSITION_QUATERNION_TIME_Q_RECORD.members=struct('x'
, 'double', 'y', 'double', 'z', 'double', 'error0', ' double q[4]',
'time', 'double', 'quality', 'uint16');
structs.tagSHORT_ALL_RECORD.packing=8;
structs.tagSHORT_ALL_RECORD.members=struct('x', 'int16', 'y',
'int16', 'z', 'int16', 'a', 'int16', 'e', 'int16', 'r', 'int16',
'error0', ' short s[3][3]', 'error1', ' short q[4]');
structs.tagDOUBLE_ALL_RECORD.packing=8;
structs.tagDOUBLE_ALL_RECORD.members=struct('x', 'double', 'y',
'double', 'z', 'double', 'a', 'double', 'e', 'double', 'r', 'double',
'error0', ' double s[3][3]', 'error1', ' double q[4]');
structs.tagDOUBLE_ALL_TIME_STAMP_RECORD.packing=8;
structs.tagDOUBLE_ALL_TIME_STAMP_RECORD.members=struct('x', 'double',
'y', 'double', 'z', 'double', 'a', 'double', 'e', 'double', 'r',
'double', 'error0', ' double s[3][3]', 'error1', ' double q[4]',
'time', 'double');
structs.tagDOUBLE_ALL_TIME_STAMP_Q_RECORD.packing=8;
structs.tagDOUBLE_ALL_TIME_STAMP_Q_RECORD.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'a', 'double', 'e', 'double',
'r', 'double', 'error0', ' double s[3][3]', 'error1', ' double q[4]',
'time', 'double', 'quality', 'uint16');
structs.tagDOUBLE_ALL_TIME_STAMP_Q_RAW_RECORD.packing=8;
structs.tagDOUBLE_ALL_TIME_STAMP_Q_RAW_RECORD.members=struct('x',
'double', 'y', 'double', 'z', 'double', 'a', 'double', 'e', 'double',
'r', 'double', 'error0', ' double s[3][3]', 'error1', ' double q[4]',
'time', 'double', 'quality', 'uint16', 'error2', ' double
raw[3][3]');
enuminfo.AGC_MODE_TYPE=struct('TRANSMITTER_AND_SENSOR_AGC',0,'SENSOR_A
GC_ONLY',1);
enuminfo.DATA_FORMAT_TYPE=struct('NO_FORMAT_SELECTED',0,'SHORT_POSITIO
N',1,'SHORT_ANGLES',2,'SHORT_MATRIX',3,'SHORT_QUATERNIONS',4,'SHORT_PO
SITION_ANGLES',5,'SHORT_POSITION_MATRIX',6,'SHORT_POSITION_QUATERNION'
,7,'DOUBLE_POSITION',8,'DOUBLE_ANGLES',9,'DOUBLE_MATRIX',10,'DOUBLE_QU
ATERNIONS',11,'DOUBLE_POSITION_ANGLES',12,'DOUBLE_POSITION_MATRIX',13,
'DOUBLE_POSITION_QUATERNION',14,'DOUBLE_POSITION_TIME_STAMP',15,'DOUBL
E_ANGLES_TIME_STAMP',16,'DOUBLE_MATRIX_TIME_STAMP',17,'DOUBLE_QUATERNI
ONS_TIME_STAMP',18,'DOUBLE_POSITION_ANGLES_TIME_STAMP',19,'DOUBLE_POSI
TION_MATRIX_TIME_STAMP',20,'DOUBLE_POSITION_QUATERNION_TIME_STAMP',21,
'DOUBLE_POSITION_TIME_Q',22,'DOUBLE_ANGLES_TIME_Q',23,'DOUBLE_MATRIX_T
IME_Q',24,'DOUBLE_QUATERNIONS_TIME_Q',25,'DOUBLE_POSITION_ANGLES_TIME_
Q',26,'DOUBLE_POSITION_MATRIX_TIME_Q',27,'DOUBLE_POSITION_QUATERNION_T
IME_Q',28,'SHORT_ALL',29,'DOUBLE_ALL',30,'DOUBLE_ALL_TIME_STAMP',31,'D
OUBLE_ALL_TIME_STAMP_Q',32,'DOUBLE_ALL_TIME_STAMP_Q_RAW',33,'MAXIMUM_F
ORMAT_CODE',34);
enuminfo.DEVICE_TYPES=struct('STANDARD_SENSOR',0,'TYPE_800_SENSOR',1,'
STANDARD_TRANSMITTER',2,'MINIBIRD_TRANSMITTER',3,'SMALL_TRANSMITTER',4
,'TYPE_500_SENSOR',5,'TYPE_180_SENSOR',6,'UNKNOWN_SENSOR',7,'UNKNOWN_T
RANSMITTER',8);
enuminfo.SYSTEM_PARAMETER_TYPE=struct('SELECT_TRANSMITTER',0,'POWER_LI
NE_FREQUENCY',1,'AGC_MODE',2,'MEASUREMENT_RATE',3,'MAXIMUM_RANGE',4,'M
ETRIC',5,'END_OF_LIST',6);
enuminfo.MESSAGE_TYPE=struct('SIMPLE_MESSAGE',0,'VERBOSE_MESSAGE',1);
enuminfo.BIRD_ERROR_CODES=struct('BIRD_ERROR_SUCCESS',0,'BIRD_ERROR_PC
B_HARDWARE_FAILURE',1,'BIRD_ERROR_TRANSMITTER_EEPROM_FAILURE',2,'BIRD_
ERROR_SENSOR_SATURATION_START',3,'BIRD_ERROR_ATTACHED_DEVICE_FAILURE',
4,'BIRD_ERROR_CONFIGURATION_DATA_FAILURE',5,'BIRD_ERROR_ILLEGAL_COMMAN
D_PARAMETER',6,'BIRD_ERROR_PARAMETER_OUT_OF_RANGE',7,'BIRD_ERROR_NO_RE
SPONSE',8,'BIRD_ERROR_COMMAND_TIME_OUT',9,'BIRD_ERROR_INCORRECT_PARAME
TER_SIZE',10,'BIRD_ERROR_INVALID_VENDOR_ID',11,'BIRD_ERROR_OPENING_DRI
VER',12,'BIRD_ERROR_INCORRECT_DRIVER_VERSION',13,'BIRD_ERROR_NO_DEVICE
S_FOUND',14,'BIRD_ERROR_ACCESSING_PCI_CONFIG',15,'BIRD_ERROR_INVALID_D
EVICE_ID',16,'BIRD_ERROR_FAILED_LOCKING_DEVICE',17,'BIRD_ERROR_BOARD_M
ISSING_ITEMS',18,'BIRD_ERROR_NOTHING_ATTACHED',19,'BIRD_ERROR_SYSTEM_P
ROBLEM',20,'BIRD_ERROR_INVALID_SERIAL_NUMBER',21,'BIRD_ERROR_DUPLICATE
_SERIAL_NUMBER',22,'BIRD_ERROR_FORMAT_NOT_SELECTED',23,'BIRD_ERROR_COM
MAND_NOT_IMPLEMENTED',24,'BIRD_ERROR_INCORRECT_BOARD_DEFAULT',25,'BIRD
_ERROR_INCORRECT_RESPONSE',26,'BIRD_ERROR_NO_TRANSMITTER_RUNNING',27,'
BIRD_ERROR_INCORRECT_RECORD_SIZE',28,'BIRD_ERROR_TRANSMITTER_OVERCURRE
NT',29,'BIRD_ERROR_TRANSMITTER_OPEN_CIRCUIT',30,'BIRD_ERROR_SENSOR_EEP
ROM_FAILURE',31,'BIRD_ERROR_SENSOR_DISCONNECTED',32,'BIRD_ERROR_SENSOR
_REATTACHED',33,'BIRD_ERROR_NEW_SENSOR_ATTACHED',34,'BIRD_ERROR_UNDOCU
MENTED',35,'BIRD_ERROR_TRANSMITTER_REATTACHED',36,'BIRD_ERROR_WATCHDOG
',37,'BIRD_ERROR_CPU_TIMEOUT_START',38,'BIRD_ERROR_PCB_RAM_FAILURE',39
,'BIRD_ERROR_INTERFACE',40,'BIRD_ERROR_PCB_EPROM_FAILURE',41,'BIRD_ERR
OR_SYSTEM_STACK_OVERFLOW',42,'BIRD_ERROR_QUEUE_OVERRUN',43,'BIRD_ERROR
_PCB_EEPROM_FAILURE',44,'BIRD_ERROR_SENSOR_SATURATION_END',45,'BIRD_ER
ROR_NEW_TRANSMITTER_ATTACHED',46,'BIRD_ERROR_SYSTEM_UNINITIALIZED',47,
'BIRD_ERROR_12V_SUPPLY_FAILURE',48,'BIRD_ERROR_CPU_TIMEOUT_END',49,'BI
RD_ERROR_INCORRECT_PLD',50,'BIRD_ERROR_NO_TRANSMITTER_ATTACHED',51,'BI
RD_ERROR_NO_SENSOR_ATTACHED',52,'BIRD_ERROR_SENSOR_BAD',53,'BIRD_ERROR
_SENSOR_SATURATED',54,'BIRD_ERROR_CPU_TIMEOUT',55,'BIRD_ERROR_UNABLE_T
O_CREATE_FILE',56,'BIRD_ERROR_UNABLE_TO_OPEN_FILE',57,'BIRD_ERROR_MISS
ING_CONFIGURATION_ITEM',58,'BIRD_ERROR_MISMATCHED_DATA',59,'BIRD_ERROR
_CONFIG_INTERNAL',60,'BIRD_ERROR_UNRECOGNIZED_MODEL_STRING',61,'BIRD_E
RROR_INCORRECT_SENSOR',62,'BIRD_ERROR_INCORRECT_TRANSMITTER',63,'BIRD_
ERROR_MAXIMUM_VALUE',64);
enuminfo.BOARD_PARAMETER_TYPE=struct('SERIAL_NUMBER_PCB',0,'END_OF_PCB
_LIST',1);
enuminfo.SENSOR_PARAMETER_TYPE=struct('DATA_FORMAT',0,'ANGLE_ALIGN',1,
'HEMISPHERE',2,'FILTER_AC_WIDE_NOTCH',3,'FILTER_AC_NARROW_NOTCH',4,'FI
LTER_DC_ADAPTIVE',5,'FILTER_ALPHA_PARAMETERS',6,'FILTER_LARGE_CHANGE',
7,'QUALITY',8,'SERIAL_NUMBER_RX',9,'END_OF_RX_LIST',10);
enuminfo.HEMISPHERE_TYPE=struct('FRONT',0,'BACK',1,'TOP',2,'BOTTOM',3,
'LEFT',4,'RIGHT',5);
enuminfo.BOARD_TYPES=struct('PCIBIRDII',0,'PCIBIRD_STD1',1,'PCIBIRD_ST
D2',2,'PCIBIRD_8mm1',3,'PCIBIRD_8mm2',4,'PCIBIRD_2mm1',5,'PCIBIRD_2mm2
',6,'PCIBIRD_UNKNOWN',7);
enuminfo.TRANSMITTER_PARAMETER_TYPE=struct('SERIAL_NUMBER_TX',0,'REFER
ENCE_FRAME',1,'XYZ_REFERENCE_FRAME',2,'END_OF_TX_LIST',3);
enuminfo.FILTER_OPTION=struct('NO_FILTER',0,'DEFAULT_FLOCK_FILTER',1);

methodinfo=fcns;
.

Relevant Pages

  • [PATCH 1/2] Char: nozomi, Lindent the code
    ... +static const int nzdebug = 0; ... u8 port; ...
    (Linux-Kernel)
  • Re: access violation
    ... I didn't find any access violation on running your code in VC 6.0 compiler. ... typedef struct tagTIMESTAMP_STRUCT ... unsigned int fraction; ... > unsigned char u8; ...
    (microsoft.public.vc.language)
  • Re: Pointer
    ... > typedef struct { ... > unsigned int fitness; ... The general practice in C is not to use global variables, i.e. head, ...
    (comp.lang.c)
  • Re: Colon (:) syntax in defining fields in a struct
    ... of signed int, unsigned int or _Bool are portable. ... Dig the even newer still, yet more improved, sig! ... "Ain't I'm a dog?" ...
    (comp.lang.c)
  • Re: [PATCH] advansys: use request_firmware
    ... +Found in hex form in kernel source. ... +AscMemWordCopyPtrToLram(PortAddr iop_base, ushort s_addr, ... -static int AdvLoadMicrocode(AdvPortAddr iop_base, unsigned char *buf, int size, ... new file mode 100644 ...
    (Linux-Kernel)