exploringBB::SPIDevice Class Reference

Generic SPI Device class that can be used to connect to any type of SPI device and read or write to its registers. More...

#include <SPIDevice.h>

Inheritance diagram for exploringBB::SPIDevice:

Collaboration diagram for exploringBB::SPIDevice:

Public Types
enum	SPIMODE { MODE0 = 0, MODE1 = 1, MODE2 = 2, MODE3 = 3 }
	The SPI Mode. More...

Public Member Functions
	SPIDevice (unsigned int bus, unsigned int device)
virtual int	open ()
virtual unsigned char	readRegister (unsigned int registerAddress)
virtual unsigned char *	readRegisters (unsigned int number, unsigned int fromAddress=0)
virtual int	writeRegister (unsigned int registerAddress, unsigned char value)
virtual void	debugDumpRegisters (unsigned int number=0xff)
virtual int	write (unsigned char value)
virtual int	write (unsigned char value[], int length)
virtual int	setSpeed (uint32_t speed)
virtual int	setMode (SPIDevice::SPIMODE mode)
virtual int	setBitsPerWord (uint8_t bits)
virtual void	close ()
virtual	~SPIDevice ()
virtual int	transfer (unsigned char read[], unsigned char write[], int length)
Public Member Functions inherited from exploringBB::BusDevice
	BusDevice (unsigned int bus, unsigned int device)
virtual	~BusDevice ()

Additional Inherited Members
Protected Attributes inherited from exploringBB::BusDevice
unsigned int	bus
unsigned int	device
int	file

Detailed Description

Generic SPI Device class that can be used to connect to any type of SPI device and read or write to its registers.

Member Enumeration Documentation

enum exploringBB::SPIDevice::SPIMODE

The SPI Mode.

Enumerator
MODE0	Low at idle, capture on rising clock edge.
MODE1	Low at idle, capture on falling clock edge.
MODE2	High at idle, capture on falling clock edge.
MODE3	High at idle, capture on rising clock edge.

                    {
                MODE0 = 0,   
                MODE1 = 1,   
                MODE2 = 2,   
                MODE3 = 3    
        };

Constructor & Destructor Documentation

exploringBB::SPIDevice::SPIDevice	(	unsigned int	bus,
		unsigned int	device
	)

The constructor for the SPIDevice that sets up and opens the SPI connection. The destructor will close the SPI file connection.

Parameters

bus	The SPI bus number X (first digit after spidevX.Y)
device	The device on the bus Y (second digit after spidevX.Y)

                                                         :
        BusDevice(bus,device) {
        stringstream s;
        s << SPI_PATH << bus << "." << device;
        this->filename = string(s.str());
        this->mode = SPIDevice::MODE3;
        this->bits = 8;
        this->speed = 500000;
        this->delay = 0;
        this->open();
}

exploringBB::SPIDevice::~SPIDevice ( )

virtual

The destructor closes the SPI bus device

                      {
        this->close();
}

Member Function Documentation

void exploringBB::SPIDevice::close ( )

virtual

Close the SPI device

Implements exploringBB::BusDevice.

                     {
        ::close(this->file);
        this->file = -1;
}

void exploringBB::SPIDevice::debugDumpRegisters ( unsigned int  number = 0xff )

virtual

A simple method to dump the registers to the standard output – useful for debugging

Parameters

number

the number of registers to dump

Implements exploringBB::BusDevice.

                                                     {
        cout << "SPI Mode: " << this->mode << endl;
        cout << "Bits per word: " << (int)this->bits << endl;
        cout << "Max speed: " << this->speed << endl;
        cout << "Dumping Registers for Debug Purposes:" << endl;
        unsigned char *registers = this->readRegisters(number);
        for(int i=0; i<(int)number; i++){
                cout << HEX(*(registers+i)) << " ";
                if (i%16==15) cout << endl;
        }
        cout << dec;
}

int exploringBB::SPIDevice::open ( )

virtual

This method opens the file connection to the SPI device.

Returns

0 on a successful open of the file

Implements exploringBB::BusDevice.

                   {
        //cout << "Opening the file: " << filename.c_str() << endl;
        if ((this->file = ::open(filename.c_str(), O_RDWR))<0){
                perror("SPI: Can't open device.");
                return -1;
        }
        if (this->setMode(this->mode)==-1) return -1;
        if (this->setSpeed(this->speed)==-1) return -1;
        if (this->setBitsPerWord(this->bits)==-1) return -1;
        return 0;
}

unsigned char exploringBB::SPIDevice::readRegister ( unsigned int  registerAddress )

virtual

A method to read a single register at the SPI address

Parameters

registerAddress

the address of the register from the device datasheet

Returns

the character that is returned from the address

Implements exploringBB::BusDevice.

                                                                 {
        unsigned char send[2], receive[2];
        memset(send, 0, sizeof send);
        memset(receive, 0, sizeof receive);
        send[0] = (unsigned char) (0x80 | registerAddress);
        this->transfer(send, receive, 2);
        //cout << "The value that was received is: " << (int) receive[1] << endl;
        return receive[1];
}

unsigned char * exploringBB::SPIDevice::readRegisters ( unsigned int  number, unsigned int  fromAddress = 0  )

virtual

A method to read a number of registers as a data array

Parameters

number	the number of registers to read
fromAddress	the starting address of the block of data

Returns

the data array that is returned (memory allocated by the method)

Implements exploringBB::BusDevice.

                                                                                    {
        unsigned char* data = new unsigned char[number];
        unsigned char send[number+1], receive[number+1];
        memset(send, 0, sizeof send);
        send[0] =  (unsigned char) (0x80 | 0x40 | fromAddress); //set read bit and MB bit
        this->transfer(send, receive, number+1);
        memcpy(data, receive+1, number);  //ignore the first (address) byte in the array returned
        return data;
}

int exploringBB::SPIDevice::setBitsPerWord ( uint8_t  bits )

virtual

Set the number of bits per word of the SPI bus

Parameters

bits	the number of bits per word

                                         {
        this->bits = bits;
        if (ioctl(this->file, SPI_IOC_WR_BITS_PER_WORD, &this->bits)==-1){
                perror("SPI: Can't set bits per word.");
                return -1;
        }
        if (ioctl(this->file, SPI_IOC_RD_BITS_PER_WORD, &this->bits)==-1){
                perror("SPI: Can't get bits per word.");
                return -1;
        }
        return 0;
}

int exploringBB::SPIDevice::setMode ( SPIDevice::SPIMODE  mode )

virtual

Set the mode of the SPI bus

Parameters

mode	the enumerated SPI mode

                                           {
        this->mode = mode;
        if (ioctl(this->file, SPI_IOC_WR_MODE, &this->mode)==-1){
                perror("SPI: Can't set SPI mode.");
                return -1;
        }
        if (ioctl(this->file, SPI_IOC_RD_MODE, &this->mode)==-1){
                perror("SPI: Can't get SPI mode.");
                return -1;
        }
        return 0;
}

int exploringBB::SPIDevice::setSpeed ( uint32_t  speed )

virtual

Set the speed of the SPI bus

Parameters

speed

the speed in Hz

                                     {
        this->speed = speed;
        if (ioctl(this->file, SPI_IOC_WR_MAX_SPEED_HZ, &this->speed)==-1){
                perror("SPI: Can't set max speed HZ");
                return -1;
        }
        if (ioctl(this->file, SPI_IOC_RD_MAX_SPEED_HZ, &this->speed)==-1){
                perror("SPI: Can't get max speed HZ.");
                return -1;
        }
        return 0;
}

int exploringBB::SPIDevice::transfer ( unsigned char  send[], unsigned char  receive[], int  length  )

virtual

Generic method to transfer data to and from the SPI device. It is used by the following methods to read and write registers.

Parameters

send	The array of data to send to the SPI device
receive	The array of data to receive from the SPI device
length	The length of the array to send

Returns

-1 on failure

                                                                                {
        struct spi_ioc_transfer transfer;
        transfer.tx_buf = (unsigned long) send;
        transfer.rx_buf = (unsigned long) receive;
        transfer.len = length;
        transfer.speed_hz = this->speed;
        transfer.bits_per_word = this->bits;
        transfer.delay_usecs = this->delay;
        int status = ioctl(this->file, SPI_IOC_MESSAGE(1), &transfer);
        if (status < 0) {
                perror("SPI: SPI_IOC_MESSAGE Failed");
                return -1;
        }
        return status;
}

int exploringBB::SPIDevice::write ( unsigned char  value )

virtual

A write method that writes a single character to the SPI bus

Parameters

value

the value to write to the bus

Returns

returns 0 if successful

Implements exploringBB::BusDevice.

                                       {
        unsigned char null_return = 0x00;
        //printf("[%02x]", value);
        this->transfer(&value, &null_return, 1);
        return 0;
}

int exploringBB::SPIDevice::write ( unsigned char  value[], int  length  )

virtual

A write method that writes a block of data of the length to the bus.

Parameters

value	the array of data to write to the device
length	the length of the data array

Returns

returns 0 if successful

                                                     {
        unsigned char null_return = 0x00;
        this->transfer(value, &null_return, length);
        return 0;
}

int exploringBB::SPIDevice::writeRegister ( unsigned int  registerAddress, unsigned char  value  )

virtual

Writes a value to a defined register address (check the datasheet for the device)

Parameters

registerAddress	the address of the register to write to
value	the value to write to the register

Returns

returns 0 if successful

Implements exploringBB::BusDevice.

                                                                             {
        unsigned char send[2], receive[2];
        memset(receive, 0, sizeof receive);
        send[0] = (unsigned char) registerAddress;
        send[1] = value;
        //cout << "The value that was written is: " << (int) send[1] << endl;
        this->transfer(send, receive, 2);
        return 0;
}

---

The documentation for this class was generated from the following files:

• /home/molloyd/exploringBB/library/bus/SPIDevice.h
• /home/molloyd/exploringBB/library/bus/SPIDevice.cpp