From 2cbe251e1b726c2fc5347dffd25cd4f9102012ed Mon Sep 17 00:00:00 2001 From: Tat-Chee Wan (USM) Date: Tue, 1 Mar 2011 12:12:49 +0800 Subject: added fantom module for python --- FantomModule/fantom/iFile.h | 280 ++++++++++++++ FantomModule/fantom/iFileIterator.h | 133 +++++++ FantomModule/fantom/iModule.h | 154 ++++++++ FantomModule/fantom/iModuleIterator.h | 123 +++++++ FantomModule/fantom/iNXT.h | 666 ++++++++++++++++++++++++++++++++++ FantomModule/fantom/iNXTIterator.h | 120 ++++++ FantomModule/fantom/platform.h | 94 +++++ FantomModule/fantom/tStatus.h | 458 +++++++++++++++++++++++ 8 files changed, 2028 insertions(+) create mode 100644 FantomModule/fantom/iFile.h create mode 100644 FantomModule/fantom/iFileIterator.h create mode 100644 FantomModule/fantom/iModule.h create mode 100644 FantomModule/fantom/iModuleIterator.h create mode 100644 FantomModule/fantom/iNXT.h create mode 100644 FantomModule/fantom/iNXTIterator.h create mode 100644 FantomModule/fantom/platform.h create mode 100644 FantomModule/fantom/tStatus.h (limited to 'FantomModule/fantom') diff --git a/FantomModule/fantom/iFile.h b/FantomModule/fantom/iFile.h new file mode 100644 index 0000000..d9884f9 --- /dev/null +++ b/FantomModule/fantom/iFile.h @@ -0,0 +1,280 @@ +/*! + \file iFile.h + \brief Interface for a file on a LEGO MINDSTORMS NXT. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iFile.h + Originated: 12 May 2005 +*/ + +#ifndef ___fantom_iFile_h___ +#define ___fantom_iFile_h___ + +// includes... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + + +// defines... + + +namespace nFANTOM100 +{ + // forward declarations... + + // typedefs... + + // classes... + + /*! + \class iFile + \brief Interface to a file on a LEGO MINDSTORMS NXT. + */ + class iFile + { + friend class tNXT; + + // methods + protected: + + //! Destructor + virtual ~iFile() = 0; + + public: + + //! Retrieves the name of this file. + /*! + \param fileName Populated with the name of this file. The file name character array + must be able to accomodate a NULL-terminated, 15.3 formatted module name. That + is, it must have a capacity of 20 bytes. + */ + virtual void getName( ViChar fileName[] ) const = 0; + + //! Retrieves the total size of this file in bytes. + /*! + The returned size is undefined if the specified status is fatal. + + \param status Status chaining object. + \return The total size of this file in bytes. + */ + virtual ViUInt32 getSize( tStatus& status ) = 0; + + //! Retrieves the remaining available size, in bytes, in this file. + /*! + This number is only helpful for data logging files, which can contain variable + amounts of data. + The returned size is undefined if the specified status is fatal. + + \param status Status chaining object. + \return The remaining available size, in bytes, in this file. + */ + virtual ViUInt32 getAvailableSize( tStatus& status ) = 0; + + + //! Opens this file for reading. + /*! + Opens, for reading, the file that corresponds to this object on the associated NXT. + The file is not opened if the specified status is fatal. + + \param status Status chaining object. + */ + virtual void openForRead( tStatus& status ) = 0; + + + //! Open this file for writing. + /*! + Opens, for writing, the file that corresponds to this object on the associated NXT. + If this file doesn't exist on the NXT, it is created. If this file does exist on + the NXT, an error is generated. + The file is not opened if the specified status is fatal. + + \param sizeInBytes Size of the data, in bytes, that will be written to this file. + \param status Status chaining object. + */ + virtual void openForWrite( ViUInt32 sizeInBytes, tStatus& status ) = 0; + + + //! Open this file for linear (contiguous) writing. + /*! + Opens, for linear (contiguous) writing, the file that corresponds to this object on + the associated NXT. If this file doesn't exist on the NXT, it is created. If this + file does exist on the NXT, an error is generated. + The file is not opened if the specified status is fatal. + + \param sizeInBytes Size of the data, in bytes, that will be written to the file. + \param status Status chaining object. + */ + virtual void openForLinearWrite( ViUInt32 sizeInBytes, tStatus& status ) = 0; + + + //! Open this data file for writing. + /*! + Opens, for writing, the data file that corresponds to this object on the associated + NXT. This data file differs from normal files in that a data file can be closed + before the entire file has been written. If this file doesn't exist on the NXT, + it is created. If this file does exist on the NXT, an error is generated. + The file is not opened if the specified status is fatal. + + \param sizeInBytes Size of the data, in bytes, that may be written to the file. + \param status Status chaining object. + */ + virtual void openForDataWrite( ViUInt32 sizeInBytes, tStatus& status ) = 0; + + + //! Open this data file for appending additional data. + /*! + Opens, for appending additional data, the data file that corresponds to this object + on the associated NXT. If this file doesn't exist on the NXT, the behavior is + undefined. If this file does exist on the NXT, the data that is written is + appended to the end of the exiting data. + The file is not opened if the specified status is fatal. + + \param status Status chaining object. + */ + virtual void openForDataAppend( tStatus& status ) = 0; + + + //! Closes this file. + /*! + Closes the file that corresponds to this object on the associated NXT. + The file is not closed if the specified status is fatal. + + \param status Status chaining object. + */ + virtual void close( tStatus& status ) = 0; + + + //! Reads from this file + /*! + Reads the specified number of bytes from this file into the specified buffer. No data + is read if the specified status is fatal. The ownership of the buffer is not + transferred to this file object. + + \param bufferPtr A pointer to the buffer that will be populated with the data that is + read. The capacity of the specified buffer must be at least the specified number + of bytes. + \param numberOfBytes Number of bytes to read. + \param status Status chaining object. + \return The number of bytes actually read from this file. + + \pre This file must have been opened for reading with the iFile::openForRead method. + \post The specified buffer may be deallocated. + */ + virtual ViUInt32 read( ViPBuf bufferPtr, ViUInt32 numberOfBytes, tStatus& status ) = 0; + + + //! Writes to this file + /*! + Writes the specified number of bytes from the specified buffer to this file. No data + is written if the specified status is fatal. The ownership of the buffer is not + transferred to this file object. + + \param bufferPtr A pointer to the buffer that contains the data that will be written. + The capacity of the specified buffer must be at least the specified number of + bytes. + \param numberOfBytes Number of bytes to write to this file. + \param status Status chaining object. + \return The number of bytes actually written to this file. + + \pre This file must have previously been opened for writing. + \post The specified buffer may be deallocated. + */ + virtual ViUInt32 write( const ViByte bufferPtr[], ViUInt32 numberOfBytes, + tStatus& status ) = 0; + + + //! Removes this file + /*! + Removes the file that corresponds to this object on the associated NXT. + The file is not removed if the specified status is fatal. + + \param status Status chaining object. + */ + virtual void remove( tStatus& status ) = 0; + + }; + + + // constants... + const ViUInt8 kProtocolFilenameLength = 19; // 15 basename + 1 dot + 3 extension = 19 + +} // namespace nFANTOM100 + + + // declarations for globally-scoped globals... + + // typedefs... + typedef ViObject nFANTOM100_iFile; + + // prototypes... + extern "C" + { + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_getName( + nFANTOM100_iFile filePtr, + ViChar fileName[], + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iFile_getSize( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iFile_getAvailableSize( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_openForRead( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_openForWrite( + nFANTOM100_iFile filePtr, + ViUInt32 sizeInBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_openForLinearWrite( + nFANTOM100_iFile filePtr, + ViUInt32 sizeInBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_openForDataWrite( + nFANTOM100_iFile filePtr, + ViUInt32 sizeInBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_openForDataAppend( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_close( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_read( + nFANTOM100_iFile filePtr, + ViPBuf bufferPtr, + ViUInt32 numberOfBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_write( + nFANTOM100_iFile filePtr, + const ViByte bufferPtr[], + ViUInt32 numberOfBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFile_remove( + nFANTOM100_iFile filePtr, + ViStatus* status ); + + } + +#endif // ___fantom_iFile_h___ diff --git a/FantomModule/fantom/iFileIterator.h b/FantomModule/fantom/iFileIterator.h new file mode 100644 index 0000000..5803be8 --- /dev/null +++ b/FantomModule/fantom/iFileIterator.h @@ -0,0 +1,133 @@ +/*! + \file iFileIterator.h + \brief Interface for an iterator for files on a LEGO MINDSTORMS NXT. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iFileIterator.h + Originated: 12 May 2005 +*/ + +#ifndef ___fantom_iFileIterator_h___ +#define ___fantom_iFileIterator_h___ + + +// includes... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_iFile_h___ + #include "iFile.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + + +// defines... + + +namespace nFANTOM100 +{ + // forward declarations... + + // typedefs... + + // classes... + + /*! + \class iFileIterator + \brief Interface to an iterator for files on a LEGO MINDSTORMS NXT. + */ + class iFileIterator + { + friend class tNXT; + + // methods + protected: + + //! Destructor + virtual ~iFileIterator() = 0; + + public: + + //! Creates a file object for the file referenced by this iterator. + /*! + Creates file object for the file referenced by this iterator. An object is not + created if the specified status is fatal or if this iterator refers to the end of + the list. The returned file object should be destroyed using the + iNXT::destroyFile method. + + \param status Status chaining object. + \return A pointer to the iFile object that was created. + */ + virtual iFile* getFile( tStatus& status ) = 0; + + //! Advances this iterator. + /*! + Advances this iterator to the next file that matches the previously specified file + name pattern. If no more files match, this iterator is advanced to the end of the + list. + The iterator is not advanced if the specified status is fatal. + If this iterator is already at the end of the list, a fatal status will be generated. + + \param status Status chaining object. + */ + virtual void advance( tStatus& status ) = 0; + + //! Retrieves the name of the file to which this iterator refers. + /*! + \param fileName Populated with the name of the file to which this iterator refers. + The file name character array must be able to accomodate a NULL-terminated, 15.3 + formatted file name. This is, it must have a capacity of 20 bytes. + \param status Status chaining object. + */ + virtual void getName( ViChar fileName[], tStatus& status ) = 0; + + //! Retrieves the total size, in bytes, of the file to which this iterator refers. + /*! + \param status Status chaining object. + \return The total size of the file in bytes. + */ + virtual ViUInt32 getSize( tStatus& status ) = 0; + + }; + + + // constants... + +} // namespace nFANTOM100 + + + // declarations for globally-scoped globals... + + // typedefs + typedef ViObject nFANTOM100_iFileIterator; + + extern "C" + { + nFANTOM100_kExport nFANTOM100_iFile _VI_FUNCC nFANTOM100_iFileIterator_getFile( + nFANTOM100_iFileIterator iteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFileIterator_advance( + nFANTOM100_iFileIterator iteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iFileIterator_getName( + nFANTOM100_iFileIterator iteratorPtr, + ViChar filename[], + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iFileIterator_getSize( + nFANTOM100_iFileIterator iteratorPtr, + ViStatus* status ); + } + +#endif // ___fantom_iFileIterator_h___ diff --git a/FantomModule/fantom/iModule.h b/FantomModule/fantom/iModule.h new file mode 100644 index 0000000..1f03849 --- /dev/null +++ b/FantomModule/fantom/iModule.h @@ -0,0 +1,154 @@ +/*! + \file iModule.h + \brief Interface for a firmware module on a LEGO MINDSTORMS NXT. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iModule.h + Originated: 8 Aug 2005 +*/ + +#ifndef ___fantom_iModule_h___ +#define ___fantom_iModule_h___ + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + + +// defines... + + +namespace nFANTOM100 +{ + + /*! + \class iModule + \brief Interface to a firmware module on a LEGO MINDSTORMS NXT. + */ + class iModule + { + friend class tNXT; + + // methods + protected: + + //! Destructor + virtual ~iModule() = 0; + + public: + + //! Retrieves the name of this module. + /*! + \param moduleName Populated with the name of this module. The module name character + array must be able to accomodate a NULL-terminated, 15.3 formatted module name. + That is, it must have a capacity of 20 bytes. + */ + virtual void getName( ViChar moduleName[] ) const = 0; + + //! Retrieves the internal module ID of this module. + /*! + \return The internal module ID of this module. + */ + virtual ViUInt32 getModuleID( void ) const = 0; + + //! Retrieves the size in bytes of this module. + /*! + \return The size in bytes of this module. + */ + virtual ViUInt32 getModuleSize( void ) const = 0; + + //! Retrieves the size in bytes of the I/O map associated with this module. + /*! + \return The size in bytes of the I/O map associated with this module. + */ + virtual ViUInt32 getModuleIOMapSize( void ) const = 0; + + //! Reads a portion of this module's I/O map. + /*! + Reads the data located at [I/O map address] + [specified offset in bytes] into the + specified data buffer. The read will attempt to copy the specified number of + bytes. No read occurs if the specified status is fatal. The ownership of data + buffer is not transferred to this module object. + + \param offsetInBytes The index of the byte in the I/O map at which to start the read. + \param numberOfBytes The number of bytes that should be read from the I/O map. + \param dataBufferPtr A pointer to the data buffer that will be populated with the + data that is read. The capacity of the specified data buffer must be at least the + specified number of bytes. + \param status Status chaining object. + \return The number of bytes actually read from the I/O map. + + \post The specified data buffer may be deallocated. + */ + virtual ViUInt32 readIOMap( ViUInt32 offsetInBytes, ViUInt32 numberOfBytes, + ViPBuf dataBufferPtr, tStatus& status ) = 0; + + //! Writes a portion of this module's I/O map. + /*! + Writes the specified data into this module's I/O map. The write starts at [I/O map + address] + [specified offset in bytes] and stops after the specified number of + bytes have been written. No write occurs if the specified status is fatal. The + ownership of data buffer is not transferred to this module object. + + \param offsetInBytes The index of the byte in the I/O map at which to start the write. + \param numberOfBytes The number of bytes to write into the I/O map. + \param dataBufferPtr A pointer to the data buffer that contains the data that will be + written. The capacity of the specified data buffer must be at least the specified + number of bytes. + \param status Status chaining object. + \return The number of bytes actually written into the I/O map. + + \post The specified data buffer may be deallocated. + */ + virtual ViUInt32 writeIOMap( ViUInt32 offsetInBytes, ViUInt32 numberOfBytes, + const ViByte dataBufferPtr[], tStatus& status ) = 0; + + }; + +}; // nFANTOM100 + +typedef ViObject nFANTOM100_iModule; + +extern "C" +{ + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iModule_getName( + nFANTOM100_iModule modulePtr, + ViChar moduleName[], + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iModule_getModuleID( + nFANTOM100_iModule modulePtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iModule_getModuleSize( + nFANTOM100_iModule modulePtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iModule_getIOMapSize( + nFANTOM100_iModule modulePtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iModule_readIOMap( + nFANTOM100_iModule modulePtr, + ViUInt32 offset, + ViUInt32 numberBytesToRead, + ViPBuf dataBuffer, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iModule_writeIOMap( + nFANTOM100_iModule modulePtr, + ViUInt32 offset, + ViUInt32 numberBytesToWrite, + const ViByte dataBuffer[], + ViStatus* status ); +} + +#endif // ___fantom_iModule_h___ diff --git a/FantomModule/fantom/iModuleIterator.h b/FantomModule/fantom/iModuleIterator.h new file mode 100644 index 0000000..402bf1a --- /dev/null +++ b/FantomModule/fantom/iModuleIterator.h @@ -0,0 +1,123 @@ +/*! + \file iModuleIterator.h + \brief Interface for an iterator for firmware modules on a LEGO MINDSTORMS NXT. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iModuleIterator.h + Originated: 8 Aug 2005 +*/ + +#ifndef ___fantom_iModuleIterator_h___ +#define ___fantom_iModuleIterator_h___ + + +// includes... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_iModule_h___ + #include "iModule.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + + +// defines... + + +namespace nFANTOM100 +{ + // forward declarations... + + // typedefs... + + // classes... + + /*! + \class iModuleIterator + \brief Interface to an iterator for firmware modules on a LEGO MINDSTORMS NXT. + */ + class iModuleIterator + { + friend class tNXT; + + // methods + protected: + + //! Destructor + virtual ~iModuleIterator() = 0; + + public: + + //! Creates a module object for the module referenced by this iterator. + /*! + Creates a module object for the module referenced by this iterator. An object is not + created if the specified status is fatal or if this iterator refers to the end of + the list. The returned module object should be destroyed using the + iNXT::destroyModule method. + + \param status Status chaining object. + \return A pointer to the iModule object that was created. + */ + virtual iModule* getModule( tStatus& status ) = 0; + + //! Advances this iterator. + /*! + Advances this iterator to the next module that matches the previously specified + module name pattern. If no more modules match, this iterator is advanced to the + end of the list. + The iterator is not advanced if the specified status is fatal. + If this iterator is already at the end of the list, a fatal status will be generated. + + \param status Status chaining object. + */ + virtual void advance( tStatus& status ) = 0; + + //! Retrieves the name of the module to which this iterator refers. + /*! + \param moduleName Populated with the name of the module to which this iterator + refers. The module name character array must be able to accomodate a + NULL-terminated, 15.3 formatted module name. This is, it must have a capacity of + 20 bytes. + \param status Status chaining object. + */ + virtual void getName( ViChar moduleName[], tStatus& status ) = 0; + + }; + + + // constants... + +} // namespace nFANTOM100 + + + // declarations for globally-scoped globals... + + // typedefs + typedef ViObject nFANTOM100_iModuleIterator; + + extern "C" + { + nFANTOM100_kExport nFANTOM100_iModule _VI_FUNCC nFANTOM100_iModuleIterator_getModule( + nFANTOM100_iModuleIterator iteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iModuleIterator_advance( + nFANTOM100_iModuleIterator iteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iModuleIterator_getName( + nFANTOM100_iModuleIterator iteratorPtr, + ViChar moduleName[], + ViStatus* status ); + } + +#endif // ___fantom_iModuleIterator_h___ diff --git a/FantomModule/fantom/iNXT.h b/FantomModule/fantom/iNXT.h new file mode 100644 index 0000000..ba61db8 --- /dev/null +++ b/FantomModule/fantom/iNXT.h @@ -0,0 +1,666 @@ +/*! + \file iNXT.h + \brief Interface for a LEGO MINDSTORMS NXT and declaration of its factory. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iNXT.h + Originated: 12 May 2005 +*/ + +#ifndef ___fantom_iNXT_h___ +#define ___fantom_iNXT_h___ + + +// includes... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_iFile_h___ + #include "iFile.h" +#endif + +#ifndef ___fantom_iFileIterator_h___ + #include "iFileIterator.h" +#endif + +#ifndef ___fantom_iModule_h___ + #include "iModule.h" +#endif + +#ifndef ___fantom_iModuleIterator_h___ + #include "iModuleIterator.h" +#endif + +#ifndef ___fantom_iNXTIterator_h___ + #include "iNXTIterator.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + +// defines... + + +namespace nFANTOM100 +{ + // forward declarations... + + // typedefs... + + // classes... + + /*! + \class iNXT + \brief Interface to a LEGO MINDSTORMS NXT. + */ + class iNXT + { + // methods + protected: + + //! Destructor + virtual ~iNXT() = 0; + + public: + + //! Enumeration of buffer types on the NXT + enum tBuffer + { + // The buffer associated with the standard port. + kBufferStandard, + + // The buffer associated with the high-speed port. + kBufferHighSpeed + }; + + //! Creates a file object for the file with the specified name on this NXT. + /*! + Invoking this method does not actually create a file on the NXT. Rather, this method + creates a file object which may be used to open a file on this NXT, for reading or + writing, or may be used to delete a file on the NXT. + A file is not created if the specified status is fatal. + The returned file object should be destroyed using the iNXT::destroyFile method. + + \param fileName Name of the file. The file name must conform to the 15.3 naming + convention and be NULL-terminated. + \param status Status chaining object. + \return A pointer to the iFile object that was created. + */ + virtual iFile* createFile( ViConstString fileName, tStatus& status ) = 0; + + + //! Destroys the specified file object. + /*! + Invoking this method does not actually delete a file on the NXT. Rather, this method + destroys a file object which may have been used to open a file on this NXT for + reading or writing, or may have been used to delete a file on the NXT. + + \param filePtr Pointer to the file object to destroy. + */ + virtual void destroyFile( iFile* filePtr ) = 0; + + + //! Creates an iterator to the files on this NXT. + /*! + The iterator traverses those files on this NXT that match the specified file name + pattern. + The iterator is not created if the specified status is fatal. + The returned file iterator object should be destroyed using the + iNXT::destroyFileIterator method. + + \param fileNamePattern The file name pattern against which to match when iterating + over the files on this NXT. The file name pattern may contain wildcards. The + wildcards may be used in the following manner: *.* (all files on this NXT); + fileBaseName.* (all files on this NXT with the specified base name regardless of + extension); *.fileExtension (all files on this NXT with the specified extension, + regardless of basename); fileBaseName.fileExtension (the file on this NXT with the + specified base name and extension). + \param status Status chaining object. + \return A pointer to the iFileIterator object that was created. + */ + virtual iFileIterator* createFileIterator( ViConstString fileNamePattern, + tStatus& status ) = 0; + + + //! Destroys the specified file iterator. + /*! + \param fileIteratorPtr A pointer to the file iterator to destroy. + */ + virtual void destroyFileIterator( iFileIterator* fileIteratorPtr ) = 0; + + //! Creates a module object for the module with the specified name on this NXT. + /*! + Invoking this method does not actually create a module on the NXT. Rather, this + method creates a module object which may be used to access an I/O map on this NXT. + A module is not created if the specified status is fatal. + The returned module object should be destroyed using the iNXT::destroyModule method. + + \param moduleName The name of the module. The module name must conform to the 15.3 + naming convention and be NULL-terminated. + \param moduleID The NXT-internal ID of the module. + \param moduleSizeInBytes The number of bytes the module occupies. + \param ioMapSizeInBytes The number of bytes the module's I/O map occupies. + \param status Status chaining object. + \return A pointer to the iModule object that was created. + */ + virtual iModule* createModule( ViConstString moduleName, ViUInt32 moduleID, + ViUInt32 moduleSizeInBytes, ViUInt32 ioMapSizeInBytes, tStatus& status ) = 0; + + //! Destroys the specified module object. + /*! + Invoking this method does not actually delete a module on this NXT. Rather, this + method destroys a module object which may have been used to access an I/O map on + this NXT. + + \param modulePtr Pointer to the module object to destroy. + */ + virtual void destroyModule( iModule* modulePtr ) = 0; + + + //! Creates an iterator to the modules on this NXT. + /*! + The iterator traverses those modules on this NXT that match the specified module name + pattern. + The iterator is not created if the specified status is fatal. + The returned module iterator object should be destroyed using the + iNXT::destroyModuleIterator method. + + \param moduleNamePattern The module name pattern against which to match. The module + name pattern may contain wildcards. Since extensions are implicit in the case of + modules, a wildcard may only be used for the module name, as in "*.mod". + \param status Status chaining object. + \return A pointer to an iModuleIterator object that was created. + */ + virtual iModuleIterator* createModuleIterator( ViConstString moduleNamePattern, + tStatus& status ) = 0; + + + //! Destroys the specified module iterator. + /*! + \param moduleIteratorPtr A pointer to the module iterator object to destroy. + */ + virtual void destroyModuleIterator( iModuleIterator* moduleIteratorPtr ) = 0; + + //! Retrieves the firmware version of this NXT. + /*! + Returns the protocol and firmware versions installed on this NXT. + The current version of this driver supports a protocol major version number of 1 and a + firmware major version number of 1. If either of these major version numbers is a + value other than 1, the driver will not attempt to communicate to the NXT. + The returned versions are undefined if the specified status is fatal. + + \param protocolVersionMajorRef Reference to parameter that will be populated with the + major protocol version. + \param protocolVersionMinorRef Reference to parameter that will be populated with the + minor protocol version. + \param firmwareVersionMajorRef Reference to parameter that will be populated with the + major firmware verison. + \param firmwareVersionMinorRef Reference to parameter that will be populated with the + minor firmware verison. + \param status Status chaining object. + */ + virtual void getFirmwareVersion( ViUInt8& protocolVersionMajorRef, + ViUInt8& protocolVersionMinorRef, ViUInt8& firmwareVersionMajorRef, + ViUInt8& firmwareVersionMinorRef, tStatus& status ) = 0; + + + //! Sends the specified direct command to this NXT. + /*! + For more information on direct commands, refer to the LEGO MINDSTORMS NXT Direct + commands document. + The command is not sent if the specified status is fatal. + The command buffer must be non-NULL and the command buffer size in bytes must be + non-zero. + If require response is set to true, the response buffer must be non-NULL and the + response buffer size in bytes must be non-zero. + If require response is set to false, the response buffer must be NULL and the + response buffer size in bytes must be zero. + Both of the buffer size parameters must be small enough to fit in one packet for + whichever bus the NXT is connected over (USB or Bluetooth). This means the + maximum length for a direct command over USB is 63 bytes; over Bluetooth, 65,533 + bytes. + If any of these requirements are violated, VI_ERROR_USER_BUF will be returned. + + \param requireResponse Boolean flag indicating if a response is required. + \param commandBufferPtr Buffer containing the direct command to send to the NXT. + \param commandBufferSizeInBytes Number of bytes in the command buffer. + \param responseBufferPtr Buffer that will be populated with the response to the direct + command. + \param responseBufferSizeInBytes Capacity of the response buffer in bytes. + \param status Status chaining object. + \return Number of bytes written to the response buffer. + */ + virtual ViUInt32 sendDirectCommand( ViBoolean requireResponse, const ViByte commandBufferPtr[], + ViUInt32 commandBufferSizeInBytes, ViPBuf responseBufferPtr, + ViUInt32 responseBufferSizeInBytes, tStatus& status ) = 0; + + //! Downloads firmware to this NXT. + /*! + The NXT must already be in firmware-download mode. + + \param firmwareBufferPtr The buffer containing the new firmware binary image. + \param firmwareBufferSizeInBytes The number of bytes in the new firmware image. + \param status Status chaining object. + */ + virtual void downloadFirmware( const ViByte firmwareBufferPtr[], + ViUInt32 firmwareBufferSizeInBytes, tStatus& status ) = 0; + + + //! Writes, in a generic fashion, to this NXT. + /*! + Writes a command directly to this NXT. In general, this method isn't used and, + instead, the sendDirectCommand and other more specific methods are invoked when + communication to the NXT. + The write doesn not occur if the specified status is fatal. + + \param bufferPtr A pointer to the buffer that contains the command that will be + written. + \param numberOfBytes Size of the buffer. + \param status Status chaining object. + \return The number of bytes actually written to the NXT. + */ + virtual ViUInt32 write( const ViByte bufferPtr[], ViUInt32 numberOfBytes, + tStatus& status ) = 0; + + //! Reads, in a generic fashion, from this NXT. + /*! + Reads a response directly from this NXT. In general, this method isn't used and, + instead, the sendDirectCommand and other more specific methods are invoked when + communication to the NXT. + The command is not sent if the specified status is fatal. + + \param bufferPtr A pointer to the buffer that will be populated with the response. + \param numberOfBytes Number of bytes expected to be read from this NXT. + \param status Status chaining object. + \return The number of bytes actually read from this NXT. + */ + virtual ViUInt32 read ( ViPBuf bufferPtr, ViUInt32 numberOfBytes, tStatus& status ) = 0; + + //! Reboots this NXT into firmware-download mode. + /*! + This is required before invoking the downloadFirmware method. + The reboot does not occur is the specified status is fatal. + + \param status Status chaining object. + */ + virtual void bootIntoFirmwareDownloadMode( tStatus& status ) = 0; + + //! Sets the name of this NXT. + /*! + The specified name will be displayed on the NXT, show up during Bluetooth scans, and + returned when the getDeviceInfo method is called. + + \param newName The name for the NXT. The name can be at most 15 characters. However, + the NXT can only display 8 characters. The string must be NULL terminated. + \param status Status chaining object. + */ + virtual void setName( ViConstString newName, tStatus& status ) = 0; + + //! Retrieves basic information about this NXT. + /*! + Retrieves the name of this NXT, its Bluetooth address, the Bluetooth signal strength, + and the number of bytes available. + Information retrieval is not done if specified status is fatal. + + \param name Populated with the name of this NXT. The name character array must be + able to accomodate a NULL-terminated 15 character name. That is, it must have a + capacity of 16 bytes. + \param bluetoothAddress Populated with this NXT's Bluetooth address. The bluetooth + address array must have a capacity of six bytes. + \param signalStrength Populated with strength of the signal for this NXT's four + Bluetooth conenctions. The signal strength array must have a capacity of four + bytes. + \param availableFlash Populated with the amount of memory in bytes that is not + occupied by firmware or user files. + \param status Status chaining object. + */ + virtual void getDeviceInfo( ViChar name[], ViByte bluetoothAddress[], + ViUInt8 signalStrength[], ViUInt32 &availableFlash, tStatus& status ) = 0; + + //! Erases all files from this NXT, leaving only the firmware. + /*! + All programs, sounds, and data logs are erased. + The erasure does not occur if specified status is fatal. + + \param status Status chaining object. + */ + virtual void eraseUserFlash( tStatus& status ) = 0; + + //! Polls the data buffer on this NXT for the number of bytes available to be read. + /* + The data buffer is not polled if the specified status is fatal. + + \param bufferSelector The buffer from which to read. + \param status Status chaining object. + \return The number of bytes in the buffer available to be read. + */ + virtual ViUInt32 pollAvailableLength( tBuffer bufferSelector, tStatus& status ) = 0; + + //! Reads data from the data buffer on this NXT. + /*! + Data is not read if the specified status is fatal. + + \param dataBuffer Populated with the data that is read from the specified buffer. + \param bufferSelector The buffer from which to read. + \param numberOfBytesToRead The number of bytes to read from the data buffer. + \param status Status chaining object. + \return The number of bytes actually read from the data buffer. + */ + virtual ViUInt32 readBufferData( ViPBuf dataBuffer, tBuffer bufferSelector, + ViUInt32 numberOfBytesToRead, tStatus& status ) = 0; + + //! Retrieves the resource string for this NXT's session. + /* + An example resource string could look like the one of the following: + BTH::LEGOBrick::00:16:53:04:05:06::5 + BTH::LEGOBrick::00:16:53:04:05:06::1 + BTH::Brick2::00:16:53:44:FF:66 + USB0::0x0694::0x0002::0016535127BA::RAW + + \param resourceString Populated with the resource string. The resource string must + have a capacity of 256 bytes. + \param status Status chaining object. + */ + virtual void getResourceString( ViChar resourceString[], tStatus& status ) = 0; + + //! Resets the Bluetooth module on this NXT to its factory settings. + /* + \param status Status chaining object. + */ + virtual void bluetoothFactoryReset( tStatus& status ) = 0; + + //! Creates an NXT object + /*! + Creates an NXT object representing the specified NXT. + The NXT object is not created if the specified status is fatal. + The returned NXT object should be destroyed using the iNXT::destroyNXT method. + + \param resourceString A string identifying which resource should be opened. A list + of possible strings can be obtained using an iNXTIterator (refer to the + createNXTIterator method). + \param status Status chaining object. + \param checkFirmwareVersion A boolean flag that specifies whether version validation + should occur (defaults to true). + \return A pointer to the iNXT object that was created. + */ + nFANTOM100_kExport static iNXT* _VI_FUNCC createNXT( ViConstString resourceString, + tStatus& status, ViBoolean checkFirmwareVersion = true ); + + //! Destroys an NXT object + /*! + \param nxtPtr A pointer to the NXT object to destroy; may be NULL + */ + nFANTOM100_kExport static void _VI_FUNCC destroyNXT( iNXT* nxtPtr ); + + //! Creates an NXT iterator. + /*! + The NXT iterator can be used to find all NXTs that are connected (USB) or in range + (Bluetooth). + The NXT iterator is not created if the specified status is fatal. + The returned NXT iterator object should be destroyed using the + iNXT::destroyNXTIterator method. + + \param searchBluetooth A boolean flag that specifies if the iterator should traverse + NXTs via Bluetooth. + \param bluetoothSearchTimeoutInSeconds The minimum number of seconds that should be + spent waiting for Bluetooth devices to respond. + \param status Status chaining object. + \return A pointer to the iNXTIterator object that was created. + */ + nFANTOM100_kExport static iNXTIterator* _VI_FUNCC createNXTIterator( + ViBoolean searchBluetooth, ViUInt32 bluetoothSearchTimeoutInSeconds, + tStatus& status ); + + //! Destroys an NXT iterator object. + /* + \param iterPtr A pointer to the iNXTIterator object to destroy. + */ + nFANTOM100_kExport static void _VI_FUNCC destroyNXTIterator( iNXTIterator* iterPtr ); + + //! Pairs with an NXT via Bluetooth. + /*! + Programmatically pairs the specified NXT to this computer and, on Windows, creates a + virtual serial port to use for communication with that NXT. However, clients + should not depend on the creation of this virtual serial port. + The pairing is not done if the specified status is fatal. + + \param resourceName The resource string that specifies the NXT with which to pair. + \param passkey A string containing the passkey the computer should exchange with the + device. The passkey cannot be longer than 15 characters and must be + NULL-terminated. + \param pairedResourceName A Bluetooth resource string representing the paired device. + On Windows, the specified resourceName is suffixed with the COM port; On Mac OS X, + the RFCOMM channel identifier. The resource string must have a capacity of 256 + bytes. + \param status Status chaining object. + */ + nFANTOM100_kExport static void _VI_FUNCC pairBluetooth( ViConstString resourceName, + ViConstString passkey, ViChar pairedResourceName[], tStatus& status ); + + //! Unpairs with an NXT via Bluetooth. + /*! + Programmatically destroys the Bluetooth pairing that was previously established + between this computer and the specified NXT. On Mac OS X, this method has no + effect and doesn't generate a fatal status. + The unpairing is not done if the specified status is fatal. + + \param resourceName The resource string that specifies the NXT with which to unpair. + \param status Status chaining object. + */ + nFANTOM100_kExport static void _VI_FUNCC unpairBluetooth( ViConstString resourceName, + tStatus& status ); + + //! Determines if the NXT associated with the specified resource string is paired. + /*! + The determination is not done if the specified status is fatal. + + \param resourceName A resource string that specifies the NXT for which to check its + pairing status. + \param status Status chaining object. + \return VI_TRUE if the NXT is paired with this computer (or if it is connected via + USB); VI_FALSE otherwise. + */ + nFANTOM100_kExport static ViBoolean _VI_FUNCC isPaired( ViConstString resourceName, + tStatus& status ); + + //! Finds the NXT that is currently in firmware-download mode. + /*! + Note that only a single NXT may be in firmware-download mode at a time. + + \param resourceName Populated with the resource string. The resource string must + have a capacity of 256 bytes. + \param status Status chaining object. + */ + nFANTOM100_kExport static void findDeviceInFirmwareDownloadMode( ViChar resourceName[], + tStatus& status ); + + + private: + + }; + + // constants... + +} // namespace nFANTOM100 + + + // declarations for globally-scoped globals... + + // typedefs... + typedef ViObject nFANTOM100_iNXT; + + // prototypes... + extern "C" + { + + nFANTOM100_kExport nFANTOM100_iNXTIterator _VI_FUNCC nFANTOM100_createNXTIterator( + ViBoolean searchBluetooth, + ViUInt32 bluetoothSearchTimeoutInSeconds, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_destroyNXTIterator( + nFANTOM100_iNXTIterator iterPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_pairBluetooth( + ViConstString resourceName, + ViConstString passkey, + ViChar pairedResourceName[], + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_unpairBluetooth( + ViConstString resourceName, + ViStatus* status ); + + nFANTOM100_kExport ViBoolean _VI_FUNCC nFANTOM100_isPaired( + ViConstString resourceName, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iNXT _VI_FUNCC nFANTOM100_createNXT( + ViConstString resourceString, + ViStatus* status, + ViBoolean checkFirmwareVersion ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_destroyNXT( + nFANTOM100_iNXT nxtPtr, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iFile _VI_FUNCC nFANTOM100_iNXT_createFile( + nFANTOM100_iNXT nxtPtr, + ViConstString fileName, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_destroyFile( + nFANTOM100_iNXT nxtPtr, + nFANTOM100_iFile filePtr, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iFileIterator _VI_FUNCC nFANTOM100_iNXT_createFileIterator( + nFANTOM100_iNXT nxtPtr, + ViConstString fileNamePattern, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_destroyFileIterator( + nFANTOM100_iNXT nxtPtr, + nFANTOM100_iFileIterator fileIteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iModule _VI_FUNCC nFANTOM100_iNXT_createModule( + nFANTOM100_iNXT nxtPtr, + ViConstString moduleName, + ViUInt32 moduleID, + ViUInt32 moduleSize, + ViUInt32 ioMapSizeInBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_destroyModule( + nFANTOM100_iNXT nxtPtr, + nFANTOM100_iModule modulePtr, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iModuleIterator _VI_FUNCC nFANTOM100_iNXT_createModuleIterator( + nFANTOM100_iNXT nxtPtr, + ViConstString moduleNamePattern, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_destroyModuleIterator( + nFANTOM100_iNXT nxtPtr, + nFANTOM100_iModuleIterator moduleIteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_getFirmwareVersion( + nFANTOM100_iNXT nxtPtr, + ViUInt8* protocolVersionMajorPtr, + ViUInt8* protocolVersionMinorPtr, + ViUInt8* firmwareVersionMajorPtr, + ViUInt8* firmwareVersionMinorPtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iNXT_sendDirectCommand( + nFANTOM100_iNXT nxtPtr, + ViBoolean requireResponse, + const ViByte commandBufferPtr[], + ViUInt32 commandBufferSizeInBytes, + ViPBuf responseBufferPtr, + ViUInt32 responseBufferSizeInBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_findDeviceInFirmwareDownloadMode( + ViChar resourceString[], + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_downloadFirmware( + nFANTOM100_iNXT nxtPtr, + const ViByte firmwareBufferPtr[], + ViUInt32 firmwareBufferSize, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iNXT_write( + nFANTOM100_iNXT nxtPtr, + const ViByte bufferPtr[], + ViUInt32 numberOfBytes, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iNXT_read( + nFANTOM100_iNXT nxtPtr, + ViPBuf bufferPtr, + ViUInt32 numberOfBytes, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_bootIntoFirmwareDownloadMode( + ViConstString resouceName, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_setName( + nFANTOM100_iNXT nxtPtr, + ViConstString newName, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_getDeviceInfo( + nFANTOM100_iNXT nxtPtr, + ViChar name[], + ViByte bluetoothAddress[], + ViUInt8 signalStrength[], + ViUInt32* availableFlash, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_eraseUserFlash( + nFANTOM100_iNXT nxtPtr, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iNXT_pollAvailableLength( + nFANTOM100_iNXT nxtPtr, + ViUInt32 bufferIndex, + ViStatus* status ); + + nFANTOM100_kExport ViUInt32 _VI_FUNCC nFANTOM100_iNXT_readBufferData( + nFANTOM100_iNXT nxtPtr, + ViPBuf dataBuffer, + ViUInt32 bufferIndex, + ViUInt32 numberOfBytesToRead, + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_getResourceString( + nFANTOM100_iNXT nxtPtr, + ViChar resourceString[], + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXT_bluetoothFactoryReset( + nFANTOM100_iNXT nxtPtr, + ViStatus* status ); + + + } // extern "C" + + +// inline functions and function macros... + + +#endif // ___fantom_iNXT_h___ diff --git a/FantomModule/fantom/iNXTIterator.h b/FantomModule/fantom/iNXTIterator.h new file mode 100644 index 0000000..6f43537 --- /dev/null +++ b/FantomModule/fantom/iNXTIterator.h @@ -0,0 +1,120 @@ +/*! + \file iNXTIterator.h + \brief Interface used for searching for LEGO MINDSTORMS NXTs. +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: iNXTIterator.h + Originated: 17 Oct 2005 +*/ + +#ifndef ___fantom_iNXTIterator_h___ +#define ___fantom_iNXTIterator_h___ + + +// includes... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#ifndef ___fantom_tStatus_h___ + #include "tStatus.h" +#endif + + +// defines... + + +namespace nFANTOM100 +{ + // forward declarations... + class iNXT; + + // typedefs... + + // classes... + + /*! + \class iNXTIterator + \brief Interface to an iterator for LEGO MINDSTORMS NXTs. + */ + class iNXTIterator + { + friend class iNXT; + + // methods + protected: + + //! Destructor + virtual ~iNXTIterator() = 0; + + public: + + //! Retrieves the name of the NXT to which this iterator refers. + /* + \param resourceName Populated with the name of the NXT to which this iterator + currently refers. The resource name character array must have a capacity of 256 + bytes. + \param status Status chaining object. + */ + virtual void getName( ViChar resourceName[], tStatus& status ) const = 0; + + //! Advances this iterator. + /*! + Advances this iterator to the next NXT that was found. If no more NXTs are found, + this iterator is advanced to the end of the list. + The iterator is not advanced if the specified status is fatal. + If this iterator is already at the end of the list, a fatal status will be generated. + + \param status Status chaining object. + */ + virtual void advance( tStatus& status ) = 0; + + //! Creates an NXT object for the NXT referenced by this iterator. + /* + Creates an NXT object for the NXT referenced by this iterator. An object is not + created if the specified status is fatal or if this iterator refers to the end of + the list. The returned iNXT object should be destroyed using the iNXT::destroyNXT + method. + + \param status Status chaining object. + \return A pointer to the iNXT object that was created. + */ + virtual iNXT* getNXT( tStatus& status ) = 0; + }; + + + // constants... + +} // namespace nFANTOM100 + + + // declarations for globally-scoped globals... + + // typedefs + typedef ViObject nFANTOM100_iNXTIterator; + + // we must duplicate this typedef for the getNXT C wrapper + typedef ViObject nFANTOM100_iNXT; + + extern "C" + { + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXTIterator_getName( + nFANTOM100_iNXTIterator iteratorPtr, + ViChar resourceName[], + ViStatus* status ); + + nFANTOM100_kExport void _VI_FUNCC nFANTOM100_iNXTIterator_advance( + nFANTOM100_iNXTIterator iteratorPtr, + ViStatus* status ); + + nFANTOM100_kExport nFANTOM100_iNXT _VI_FUNCC nFANTOM100_iNXTIterator_getNXT( + nFANTOM100_iNXTIterator iteratorPtr, + ViStatus* status ); + } + +#endif // ___fantom_iNXTIterator_h___ diff --git a/FantomModule/fantom/platform.h b/FantomModule/fantom/platform.h new file mode 100644 index 0000000..7455796 --- /dev/null +++ b/FantomModule/fantom/platform.h @@ -0,0 +1,94 @@ +/*! + \file platform.h + \brief This file contains platform-related defines. +*/ +/* + © Copyright 2005, + National Instruments Corporation. + All rights reserved. + + File: platform.h + Originated: 23 June 2005 +*/ + + +#ifndef ___fantom_platform_h___ +#define ___fantom_platform_h___ + +#ifndef __VISATYPE_HEADER__ + #include "visatype.h" +#endif + + +#define nFANTOM100_kOSMacOSX 0 +#define nFANTOM100_kOSWin32 0 + +#define nFANTOM100_kProcessorI386 0 +#define nFANTOM100_kProcessorPPC 0 + +#define nFANTOM100_kCompilerMSVC 0 +#define nFANTOM100_kCompilerApple 0 + + +#if (( defined( __GNUG__ ) || defined( __GNUC__ )) && defined( __APPLE__ )) + + #undef nFANTOM100_kOSMacOSX + #define nFANTOM100_kOSMacOSX 1 + + #undef nFANTOM100_kCompilerApple + #define nFANTOM100_kCompilerApple ( __GNUC__ * 10000 \ + + __GNUC_MINOR__ * 100 \ + + __GNUC_PATCHLEVEL__ ) + + #if ( defined( __ppc__ )) + #undef nFANTOM100_kProcessorPPC + #define nFANTOM100_kProcessorPPC 1 + + #define nFANTOM100_kBigEndian 1 + #define nFANTOM100_kLittleEndian 0 + #elif ( defined( __i386__ )) + #undef nFANTOM100_kProcessorI386 + #define nFANTOM100_kProcessorI386 1 + + #define nFANTOM100_kBigEndian 0 + #define nFANTOM100_kLittleEndian 1 + #else + #error Unknown processor. + #endif + + #ifdef nFANTOM100_kExportSymbols + #define nFANTOM100_kExport __attribute__ ((section ("__TEXT,__export"))) + #else + #define nFANTOM100_kExport + #endif + + +#elif ( defined( _MSC_VER ) && ( defined( _M_IX86 ) || defined( _M_I86 ))) + + #undef nFANTOM100_kOSWin32 + #define nFANTOM100_kOSWin32 1 + + #undef nFANTOM100_kCompilerMSVC + #define nFANTOM100_kCompilerMSVC _MSC_VER + + #undef nFANTOM100_kProcessorI386 + #define nFANTOM100_kProcessorI386 1 + + #ifdef nFANTOM100_kExportSymbols + #define nFANTOM100_kExport __declspec(dllexport) + #else + #define nFANTOM100_kExport __declspec(dllimport) + #endif + + #define nFANTOM100_kBigEndian 0 + #define nFANTOM100_kLittleEndian 1 + +#else + + #error Unknown platform. + +#endif + + +#endif // ___fantom_platform_h___ + diff --git a/FantomModule/fantom/tStatus.h b/FantomModule/fantom/tStatus.h new file mode 100644 index 0000000..7622c63 --- /dev/null +++ b/FantomModule/fantom/tStatus.h @@ -0,0 +1,458 @@ +/*! + \file tStatus.h + \brief Status code class +*/ +/* + © Copyright 2005-2006, + National Instruments Corporation. + All rights reserved. + + File: tStatus.h + Originated: 10 March 2005 +*/ + +#ifndef ___fantom_tStatus_h___ +#define ___fantom_tStatus_h___ + +// includes ... + +#ifndef ___fantom_platform_h___ + #include "platform.h" +#endif + +#include + + +// defines... + +#define nFANTOM_mLocation __FILE__, __LINE__ + +#define nFANTOM_ForceToWarning(s) (((s) >= 0 ) ? (s) : -(s)) +#define nFANTOM_ForceToFatal(s) (((s) <= 0 ) ? (s) : -(s)) + +/*! + \brief The namespace for Fantom 1.0. +*/ +namespace nFANTOM100 +{ + // forward declarations... + + // typedefs... + + // classes... + const ViInt32 kStatusOffset = -142000; // 0xFFFDD550 + const ViStatus kStatusSuccess = VI_SUCCESS; + + /*! + \brief Enumeration of Fantom-specific status codes. NI-VISA status codes may also be + returned. These are documented in the NI-VISA Programmer Reference Manual which is + available from . + */ + enum tFANTOMStatus + { + kStatusFirst = (kStatusOffset + 0), + + //! Error: Bluetooth pairing operation failed. + //! Warning: You have already paired with that Bluetooth device. + kStatusPairingFailed = (kStatusOffset + -5), // 0x54B + + //! Error: Bluetooth search failed. + kStatusBluetoothSearchFailed = (kStatusOffset + -6), // 0x54A + + //! Error: System library not found. + kStatusSystemLibraryNotFound = (kStatusOffset + -7), // 0x549 + + //! Error: Bluetooth unpairing operation failed. + kStatusUnpairingFailed = (kStatusOffset + -8), // 0x548 + + //! Error: Invalid filename specified. + kStatusInvalidFilename = (kStatusOffset + -9), // 0x547 + + //! Error: Invalid iterator dereference. (No object to get.) + kStatusInvalidIteratorDereference = (kStatusOffset + -10), // 0x546 + + //! Error: Resource locking operation failed. + kStatusLockOperationFailed = (kStatusOffset + -11), // 0x545 + + //! Error: Could not determine the requested size. + kStatusSizeUnknown = (kStatusOffset + -12), // 0x544 + + //! Error: Cannot open two objects at once. + kStatusDuplicateOpen = (kStatusOffset + -13), // 0x543 + + //! Error: File is empty. + //! Warning: The requested file is empty. + kStatusEmptyFile = (kStatusOffset + -14), // 0x542 + + //! Error: Firmware download failed. + kStatusFirmwareDownloadFailed = (kStatusOffset + -15), // 0x541 + + //! Error: Could not locate virtual serial port. + kStatusPortNotFound = (kStatusOffset + -16), // 0x540 + + //! Error: No more items found. + kStatusNoMoreItemsFound = (kStatusOffset + -17), // 0x53F + + //! Error: Too many unconfigured devices. + kStatusTooManyUnconfiguredDevices = (kStatusOffset + -18), // 0x53E + + //! Error: Command mismatch in firmware response. + kStatusCommandMismatch = (kStatusOffset + -19), // 0x53D + + //! Error: Illegal operation. + kStatusIllegalOperation = (kStatusOffset + -20), // 0x53C + + //! Error: Could not update local Bluetooth cache with new name. + //! Warning: Could not update local Bluetooth cache with new name. + kStatusBluetoothCacheUpdateFailed = (kStatusOffset + -21), // 0x53B + + //! Error: Selected device is not an NXT. + kStatusNonNXTDeviceSelected = (kStatusOffset + -22), // 0x53A + + //! Error: Communication error. Retry the operation. + kStatusRetryConnection = (kStatusOffset + -23), // 0x539 + + //! Error: Could not connect to NXT. Turn the NXT off and then back on before continuing. + kStatusPowerCycleNXT = (kStatusOffset + -24), // 0x538 + + //! Error: This feature is not yet implemented. + kStatusFeatureNotImplemented = (kStatusOffset + -99), // 0x4ED + + //! Error: Firmware reported an illegal handle. + kStatusFWIllegalHandle = (kStatusOffset + -189), // 0x493 + + //! Error: Firmware reported an illegal file name. + kStatusFWIllegalFileName = (kStatusOffset + -190), // 0x492 + + //! Error: Firmware reported an out of bounds reference. + kStatusFWOutOfBounds = (kStatusOffset + -191), // 0x491 + + //! Error: Firmware could not find module. + kStatusFWModuleNotFound = (kStatusOffset + -192), // 0x490 + + //! Error: Firmware reported that the file already exists. + kStatusFWFileExists = (kStatusOffset + -193), // 0x48F + + //! Error: Firmware reported that the file is full. + kStatusFWFileIsFull = (kStatusOffset + -194), // 0x48E + + //! Error: Firmware reported the append operation is not possible. + kStatusFWAppendNotPossible = (kStatusOffset + -195), // 0x48D + + //! Error: Firmware has no write buffers available. + kStatusFWNoWriteBuffers = (kStatusOffset + -196), // 0x48C + + //! Error: Firmware reported that file is busy. + kStatusFWFileIsBusy = (kStatusOffset + -197), // 0x48B + + //! Error: Firmware reported the undefined error. + kStatusFWUndefinedError = (kStatusOffset + -198), // 0x48A + + //! Error: Firmware reported that no linear space is available. + kStatusFWNoLinearSpace = (kStatusOffset + -199), // 0x489 + + //! Error: Firmware reported that handle has already been closed. + kStatusFWHandleAlreadyClosed = (kStatusOffset + -200), // 0x488 + + //! Error: Firmware could not find file. + kStatusFWFileNotFound = (kStatusOffset + -201), // 0x487 + + //! Error: Firmware reported that the requested file is not linear. + kStatusFWNotLinearFile = (kStatusOffset + -202), // 0x486 + + //! Error: Firmware reached the end of the file. + kStatusFWEndOfFile = (kStatusOffset + -203), // 0x485 + + //! Error: Firmware expected an end of file. + kStatusFWEndOfFileExpected = (kStatusOffset + -204), // 0x484 + + //! Error: Firmware cannot handle more files. + kStatusFWNoMoreFiles = (kStatusOffset + -205), // 0x483 + + //! Error: Firmware reported the NXT is out of space. + kStatusFWNoSpace = (kStatusOffset + -206), // 0x482 + + //! Error: Firmware could not create a handle. + kStatusFWNoMoreHandles = (kStatusOffset + -207), // 0x481 + + //! Error: Firmware reported an unknown error code. + kStatusFWUnknownErrorCode = (kStatusOffset + -208), // 0x480 + + kStatusLast = (kStatusOffset + -999) + }; + + /*! + \brief Class that contains a status code and the file name and line number where that + status code was generated. + */ + class tStatus + { + public: + + // methods + + //! constructor + /*! + Creates a tStatus object intialized to success. + + \post The status code is set to VI_SUCCESS. + */ + inline tStatus( void ) : + _code( VI_SUCCESS ), + _lineNumber( 0 ) + { + _fileName[0] = '\0'; + } + + + //! copy constructor + /*! + Copies the code, line number, and file name from the specified tStatus object. + + \param status The status object to copy. + */ + inline tStatus( const tStatus& status ) : + _code( status._code ), + _lineNumber( status._lineNumber ) + { + ::strcpy( _fileName, "" ); + ::strncat( _fileName, status._fileName, kMaxFileNameLength - 1 ); + } + + + //! constructor with code, filename, and line number + /*! + Creates a tStatus object initialized to the specified code, file name, and line number. + Note that the nFANTOM_mLocation macro can be used to pass the fileName and lineNumber + parameters. + + \param code A status code. + \param fileName The name of the file in which the status code was generated. + \param lineNumber The line number in the file at which the status code was generated. + */ + inline tStatus( ViStatus code, const char* fileName, ViUInt32 lineNumber ) : + _code( code ), + _lineNumber( lineNumber ) + { + ::strcpy( _fileName, "" ); + ::strncat( _fileName, reinterpret_cast( fileName ), kMaxFileNameLength - 1 ); + } + + + //! destructor + inline ~tStatus() + { + } + + + //! Returns the status code for this status object. + /*! + \return The status code for this status object. + */ + inline ViStatus getCode( void ) const + { + return _code; + } + + + //! Returns the file name in which the status code, for this status object, was generated. + /*! + \return The file name in which the status code, for this status object, was generated. + */ + inline const char* getFileName( void ) const + { + return _fileName; + } + + + //! Returns the line number at which the status code, for this status object, was + // generated. + /*! + \return The line number at which the status code, for this status object, was + generated. + */ + inline ViUInt32 getLineNumber( void ) const + { + return _lineNumber; + } + + + //! Sets the status code, file name, and line number for this status object, if + // appropriate. + /*! + Stores the specified status code, file name, and line number in this status object if + this status object contains a successful status code or if this status object + contains a warning status code and the specified status code is fatal. A fatal + status code is denoted by a negative value. A successful status code is denoted + by VI_SUCCESS. + + \param code A status code. + \param fileName The name of the file in which the status code was generated. + \param lineNumber The line number in the file at which the status code was generated. + */ + inline void setCode( ViStatus code, const char* fileName, ViUInt32 lineNumber ) + { + if(( isSuccess() && code != VI_SUCCESS ) || ( isNotFatal() && code < VI_SUCCESS )) + { + _code = code; + _lineNumber = lineNumber; + ::strcpy( _fileName, "" ); + ::strncat( _fileName, fileName, kMaxFileNameLength - 1 ); + } + } + + + //! Assigns the specified status object to this status object, if appropriate. + /*! + Stores the status code, file name, and line number of the specified status object in + this status object if this status object contains a successful status code or if + this status object contains a warning status code and the status code of the + speciied status object is fatal. A fatal status code is denoted by a negative + value. A successful status code is denoted by VI_SUCCESS. + + \param status The status object to assign. + */ + inline void assign( const tStatus& status ) + { + setCode( status.getCode(), status.getFileName(), status.getLineNumber()); + } + + + //! Clears the status code for this status object. + /*! + \post status The code is set to VI_SUCCESS. + */ + inline void clear( void ) + { + _code = VI_SUCCESS; + _lineNumber = 0; + _fileName[0] = '\0'; + } + + + //! Returns true if this status object contains a status code that is fatal. + /*! + A status code with a negative value is considered fatal. + + \return true if this status object contains a status code that is + fatal; false otherwise. + */ + inline bool isFatal( void ) const + { + return ( _code < VI_SUCCESS ); + } + + //! Returns true if this status object contains a status code that is not fatal. + /*! + Any status code with a non-negative (including zero) value is considered non-fatal. + + \return true if this status object contains a non-fatal status code; + false otherwise. + */ + inline bool isNotFatal( void ) const + { + return !isFatal(); + } + + + //! Returns true if this status object contains a status code that is a warning. + /*! + A status code with a non-zero, positive value is considered a warning. + + \return true if this status object contains a status code that is a warning; false + otherwise. + */ + inline bool isWarning( void ) const + { + return ( _code > VI_SUCCESS ); + } + + + //! Returns true if this status object contains the status code for success. + /*! + A value of VI_SUCCESS represents success. + + \return true if this status object contains the status code for success; false + otherwise. + */ + inline bool isSuccess( void ) const + { + return ( _code == VI_SUCCESS ); + } + + private: + + // declared private to prevent assignment + tStatus& operator=(const tStatus& rhs); + + enum + { + kMaxFileNameLength = 101 + }; + + ViStatus _code; + ViChar _fileName[ kMaxFileNameLength ]; + ViUInt32 _lineNumber; + }; + + + // declarations for globally-scoped globals... + inline ViStatus convertStatus( ViUInt8 firmwareStatus ) + { + ViStatus status; + switch (firmwareStatus) + { + // each of these cases corresponds to a unique status code returned by the firmware + case 0x00 : status = kStatusSuccess; + break; + case 0x81 : status = kStatusFWNoMoreHandles; // No more available handles + break; + case 0x82 : status = kStatusFWNoSpace; // No space + break; + case 0x83 : status = kStatusFWNoMoreFiles; // No more files + break; + case 0x84 : status = kStatusFWEndOfFileExpected; // End of file expected + break; + case 0x85 : status = kStatusFWEndOfFile; // End of file reached + break; + case 0x86 : status = kStatusFWNotLinearFile; // Not a linear file + break; + case 0x87 : status = kStatusFWFileNotFound; // File not found + break; + case 0x88 : status = kStatusFWHandleAlreadyClosed; // Handle is already closed + break; + case 0x89 : status = kStatusFWNoLinearSpace; // No linear space available + break; + case 0x8A : status = kStatusFWUndefinedError; // Undefined error + break; + case 0x8B : status = kStatusFWFileIsBusy; // File is busy + break; + case 0x8C : status = kStatusFWNoWriteBuffers; // No write buffers available + break; + case 0x8D : status = kStatusFWAppendNotPossible; // Append not possible + break; + case 0x8E : status = kStatusFWFileIsFull; // File is full + break; + case 0x8F : status = kStatusFWFileExists; // File already exists + break; + case 0x90 : status = kStatusFWModuleNotFound; // Module not found + break; + case 0x91 : status = kStatusFWOutOfBounds; // Out of module I/O map boundary + break; + case 0x92 : status = kStatusFWIllegalFileName; // Illegal file name + break; + case 0x93 : status = kStatusFWIllegalHandle; // Illegal handle + break; + default : + status = kStatusFWUnknownErrorCode; + } + return status; + } + + // prototypes... + +} // namespace nFANTOM100 + +// inline functions and function macros... + +#endif // ___fantom_tStatus_h___ -- cgit v1.2.3