eeprom.h

Go to the documentation of this file.

#ifndef LIBPROPELLER_EEPROM_H_
#define LIBPROPELLER_EEPROM_H_

#include "libpropeller/i2c/i2c_base.h"

class EEPROM {
public:

    void Init(const int scl = 28, const int sda = 29) {
        base_.Init(scl, sda);
    }

    bool Put(const unsigned short address, const char byte) {
        char bytes[] = {byte};
        return Put(address, bytes, 1);
    }

    bool Put(unsigned short address, char bytes [], int size) {
        //The lower seven bits define an EEPROM page, so we need a bit of magic to make
        //sure that if we go over the boundary, we start a new page.

        int bytesWritten = 0;
        while (bytesWritten < size) {
            if (PollForAcknowledge() == false) {
                return false;
            }
            base_.SendByte((address >> 8) & 0xFF); //High address byte
            base_.SendByte(address & 0xFF); //Low address byte
            do {
                base_.SendByte(bytes[bytesWritten]); //Payload  
                bytesWritten++;
                address++;
            } while ((address & 0b1111111) != 0 && bytesWritten < size); //detect rollover

            base_.Stop();
        }

        return true;
    }

    bool PutNumber(const unsigned short address, const int bytes, const int length) {

        char temp[4];
        //Even if length is < 4, do them all (easier than a loop). Only the used ones will be written.
        temp[3] = (((unsigned) bytes) & 0xFF000000) >> 24;
        temp[2] = (((unsigned) bytes) & 0xFF0000) >> 16;
        temp[1] = (((unsigned) bytes) & 0xFF00) >> 8;
        temp[0] = (((unsigned) bytes) & 0xFF) >> 0;
        return Put(address, temp, length);
    }

    int Get(unsigned short address) {
        char byte[1];
        int result = Get(address, byte, 1);
        if (result < 0) {
            return result;
        } else {
            return byte[0];
        }
    }

    int Get(unsigned short address, char bytes [], const int length) {
        int bytesRead = 0;
        while (bytesRead < length) {
            if (PollForAcknowledge() == false) {
                return -1;
            }
            base_.SendByte((address >> 8) & 0xFF); //High address byte
            base_.SendByte(address & 0xFF); //Low address byte
            base_.Start();
            base_.SendByte(kI2CAddress | 0x01); //device EEPROM read (w/ read bit set)


            while (((address + 1) & 0b1111111) != 0
                    && bytesRead + 1 < length) {
                bytes[bytesRead] = base_.ReadByte(true);
                bytesRead++;
                address++;
            }

            bytes[bytesRead] = base_.ReadByte(false);
            bytesRead++;
            address++;

            base_.Stop();
        }

        return 0;

    }

    int GetNumber(unsigned short address, int length) {
        char temp[4];
        Get(address, temp, length);
        int result = 0;

        /*
        // Commented out because of the compiler loop bug.
        for (int i = length - 1; i >= 0; --i) {
            //debug->Put(" Get_C ");
            result = (result << 8) | temp[i];
        }*/

        if (length >= 4) {
            result = (result << 8) | temp[3];
        }
        if (length >= 3) {
            result = (result << 8) | temp[2];
        }
        if (length >= 2) {
            result = (result << 8) | temp[1];
        }
        if (length >= 1) {
            result = (result << 8) | temp[0];
        }

        return result;
    }

private:

    bool PollForAcknowledge() {
        base_.Start();
        int counter = 0;
        while (base_.SendByte(kI2CAddress) == false) { //device EEPROM write
            if (++counter == 100) { //timeout
                return false;
            }
            base_.Stop();
            base_.Start();
        }
        return true;
    }

    I2CBase base_;
    static const unsigned char kI2CAddress = 0b10100000;

};

#endif // LIBPROPELLER_EEPROM_H_