C:/Documents and Settings/Owner/My Documents/My Code/NXT++/files/include/comm.h

Go to the documentation of this file.

// File: comm.h
//
// Copyright (c) 2007 by XXX
// -------------------------------------------------------------------------
// DESCRIPTION
// Header file containing OS specific function. 
//
// HISTORY
// Date         By who         Description
// -------------------------------------------------------------------------
// 04/26/2007   maddock     Header comments
// 05/12/2007   phyizal     Added fantom file support
// 05/16/2007   phyizal     Removed fantom function call 

#include <stdlib.h>
#include <string.h>
#include <vector>
#include <iostream>
#include "fantom/iNXT.h"
#include "fantom/iNXTIterator.h"
#include "fantom/tStatus.h"

//Error codes.
//TODO: Make them more comprehensive based on status code from NXT.
//       Also provide a method to translate numeric error code to more
//       user friendly error string.

enum ErrorCode
{               
        UnsupportedType = -1,
        IteratorFailed = -2,
        InvalidFileIterator = -3,
        IteratorAdvanceFailed = -4,
        InvalidFileHandler = -5,
        FileOpenFailed = -6,            
        WriteNotEnabled = -7,
        FileNotOpen = -8,               
        ReadFailed = -9,
        WriteFailed = -10,
        FileCloseFailed = -11,          
        WriteBufferIllegalSize = -12,
};

struct NXTFile
{
        NXTFile() : file(NULL) , name(NULL)
        {
                size = 0;
                asize = 0;
                isOpen = false;
                isWriteable = false;
        }

        NXTFile(nFANTOM100::iFile* f): name((char*) malloc(20))
        {
      file = f;

          if (f == NULL) return;

          f->getName(name);

          nFANTOM100::tStatus status;

          size = f->getSize(status);
          asize = f->getAvailableSize(status);

          if (status.isFatal())
                  size = -1;

          isOpen = false;
          isWriteable =false;
        }

        char * name;
        int size;
        int asize;
        int mode;

        bool isOpen;
        bool isWriteable;

        //Won't be use in case of linux
        nFANTOM100::iFile* file; 
        bool isValid(); 
        int open(int mode, int size=100);
        int remove();
        int read(char* buff, int size);
        int write(char* buff, int size);
        int close();
};

struct NXTFileIterator
{
        NXTFileIterator() : iter(NULL)
        {
        }

        NXTFileIterator(nFANTOM100::iFileIterator *i)
        {
                iter = i;
        }

        nFANTOM100::iFileIterator *iter;
        bool isValid();
        int next();
        int close();
        int getFile(NXTFile& file);
        int getCurrFileSize();
        const char* getCurrFileName();
        
};

struct NXTModule
{
        NXTModule() : internalModule(NULL)
        {
        }

        NXTModule(nFANTOM100::iModule *m)
        {
                internalModule = m;
        }

        nFANTOM100::iModule *internalModule;
        int getName(std::string &name);
        int getModuleID(int &id);
        int getModuleSize(int &size);
        int getIOMapSize(int &size);
        int readIOMap(ViPByte buffer, int offset, int number_of_bytes);
        int writeIOMap(const ViPByte, int offset, int number_of_bytes);

};

struct NXTModuleIterator
{
        NXTModuleIterator() : internalIter(NULL)
        {
        }

        NXTModuleIterator(nFANTOM100::iModuleIterator *i)
        {
                internalIter = i;
        }

        nFANTOM100::iModuleIterator *internalIter;
        int next();
        int getModule(NXTModule &module);
        int getName(std::string &s);
};

namespace Comm
{
        void SearchBT(std::vector<std::string> *names);

        class NXTComm {
        public:
                // global variable
                nFANTOM100::tStatus status;
                nFANTOM100::iNXTIterator* nxtIteratorPtr;
                nFANTOM100::iNXT* nxtPtr;
                //For fetching list of files
                nFANTOM100::iFileIterator* fileIteratorPtr;

                NXTComm() {
                        nxtIteratorPtr = NULL;
                        nxtPtr = NULL;
                        fileIteratorPtr = NULL;
                }


                bool Open();

                bool OpenBT();

                bool OpenBT(char * name);
                void Close();

                void SendDirectCommand(ViBoolean response, ViByte * dc_buf, int dc_buf_size, ViByte *re_buf, int re_buf_size);
                double GetProtocolVersion();
                double GetFirmwareVersion();
                std::string GetName();
                bool SetName(char* name);
                double GetAvailableFlash();
                NXTFile GetNXTFile(std::string filename, bool &isFatal);
                NXTFileIterator GetFileIterator(std::string pattern, bool &isFatal);
                void destroyFileIterator(NXTFileIterator &iter);
                void destroyFile(NXTFile &file);
                NXTModuleIterator GetModuleIterator(std::string pattern, int &statusCode);
                void destroyModuleIterator(NXTModuleIterator &iter);
                NXTModule GetModule(std::string moduleName, int moduleID, int moduleSize, int ioMapSize, int &statCode);
                void destroyModule(NXTModule &module);
        };
};