/home/mooz/bin/arduino-0009/lib/targets/libraries/uDRIVE-uSD-G1/uDRIVE_uSD_G1.h

Go to the documentation of this file.

#ifndef _uDRIVE_uSD_G1_h_
#define _uDRIVE_uSD_G1_h_

#include <inttypes.h>

namespace _4Dsystems
{
#define ACK 0x06

#define NACK 0x15

#define INITIALIZE_MODULE   0x55

#define VERSION 0x56

#define EXTENDED 0x40

#define INITIALIZE_DISK 0x69

#define SET_MEMORY_ADDRESS 0x41

#define READ_SECTOR_BLOCK_DATA 0x52

#define WRITE_SECTOR_BLOCK_DATA 0x57

#define READ_SINGLE_BYTE 0x72

#define WRITE_SINGLE_BYTE 0x77

// Let's hope they'll release a new firmware handling fat16...

enum Error
{
        OK = 0,            
        COMMAND_ERROR,     
        UNITIALIZED_ERROR, 
        INVALID_DATA       
};

template <typename SerialInterface>
class uDRIVE_uSD_G1
{
        private:
                uint8_t _state; 
                SerialInterface* _serial; 
                inline int8_t ValidateCommand()
                {
                        int8_t ret;
                        /* Wait for ack */
                        while( ! _serial->available() )
                        {
                                delay(10);
                        }
                        ret = _serial->read();

                        /* Was the command understood ? */
                        if(ret != ACK)
                        {
                                return COMMAND_ERROR;
                        }
                
                        return OK;
                }
                
                inline void _read(uint8_t *iPtr, size_t nElements)
                {
                        while(nElements--)
                        {
                                while( ! _serial->available() )
                                {
                                        delay(10);
                                }
                                *iPtr++ = _serial->read();
                        }

                }
                                        
        public: 
                uDRIVE_uSD_G1() :
                        _state(0),
                        _serial(NULL)
                {}
                ~uDRIVE_uSD_G1() {}
                
                int8_t Initialize(SerialInterface* iSerial)
                {
                        int8_t ret;
        
                        _state      = 0;
                        _serial     = iSerial;

                        _serial->print((uint8_t)INITIALIZE_MODULE);
                        
                        ret = ValidateCommand();
                        if(ret != OK)
                        {
                                return ret;
                        }

                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)INITIALIZE_DISK);

                        ret = ValidateCommand();
                        if(ret != OK)
                        {
                                return ret;
                        }

                        _state = 1;
                        return OK;
                }
                
                int8_t ReadSectorBlock(const uint32_t& iAddress, uint8_t* iData)
                {
                        uint8_t ret;
                        uint16_t byteCount;
                        
                        /* Sanity check */
                        if(iData == NULL)
                        {
                                return INVALID_DATA;
                        }
                        
                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }
                        
                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)READ_SECTOR_BLOCK_DATA);
                        _serial->print((uint8_t)((iAddress >> 16) & 0xff));
                        _serial->print((uint8_t)((iAddress >>  8) & 0xff));
                        _serial->print((uint8_t)((iAddress      ) & 0xff));
                                
                        /* Read 512 bytes! (Let's hope the array is large enough) */
                        _read(iData, 512);
                                        
                        return OK;
                }

                int8_t WriteSectorBlock(const uint32_t& iAddress, uint8_t* iData)
                {
                        uint16_t byteCount;

                        /* Sanity check */
                        if(iData == NULL)
                        {
                                return INVALID_DATA;
                        }
                        
                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }
                        
                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)WRITE_SECTOR_BLOCK_DATA);
                        _serial->print((uint8_t)((iAddress >> 16) & 0xff));
                        _serial->print((uint8_t)((iAddress >>  8) & 0xff));
                        _serial->print((uint8_t)((iAddress      ) & 0xff));
                        
                                        
                        /* Write 512 bytes! (Let's hope the array is large enough) */
                        for(byteCount=0; byteCount<512; ++byteCount, ++iData)
                        {
                                _serial->print(*iData);
                        }
                        
                        return ValidateCommand();
                }
                                        
                int8_t SetMemoryAddress(const uint32_t& iAddress)
                {
                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }
                        
                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)SET_MEMORY_ADDRESS);
                        _serial->print((uint8_t)((iAddress >> 24) & 0xff));
                        _serial->print((uint8_t)((iAddress >> 16) & 0xff));
                        _serial->print((uint8_t)((iAddress >>  8) & 0xff));
                        _serial->print((uint8_t)((iAddress      ) & 0xff));
                        
                        return ValidateCommand();
                }

                int8_t ReadSingleByte (uint8_t& iByte)
                {
                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }
                        
                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)READ_SINGLE_BYTE);
                        
                        /* TODO : check if a ACK/NACK is sent */
                        
                        while( ! _serial->available() )
                        {
                                delay(10);
                        }
                        
                        iByte = _serial->read();
                        
                        return OK;
                }
                
                int8_t WriteSingleByte(const uint8_t& iByte)
                {
                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }
                        
                        _serial->print((uint8_t)EXTENDED);
                        _serial->print((uint8_t)WRITE_SINGLE_BYTE);
                                        
                        _serial->print(iByte);
                        
                        return ValidateCommand();
                }
                
                
                union DeviceInfo
                {
                        struct
                        {
                                uint8_t device_type;
                                uint8_t hardware_rev;
                                uint8_t PmmC_rev;
                                uint8_t reserved1;
                                uint8_t reserved2;
                        };
                        uint8_t _data[5];
                };
                
                int8_t RequestDeviceInfo(DeviceInfo& iInfo)
                {
                        int8_t ret;

                        /* Check state */
                        if(!_state)
                        {
                                return UNITIALIZED_ERROR;
                        }

                        _serial->print((uint8_t)VERSION);
                        _read(iInfo._data, 5);
                
                        return OK;
                }
}; // class uDRIVE_uSD_G1
}; // namespace _4Dsystems

#endif // _uDRIVE_uSD_G1_h_

---