root/ds1624/ds1624.cpp

extern "C" {
    #include <Wire/Wire.h>
}

#include "ds1624.h"

DS1624::DS1624()
{
#ifdef WIRE_LIB_SCAN_MOD
    /*if (!Wire.isStarted())*/ Wire.begin();
#else
    Wire.begin();
#endif
}

DS1624 TEMP = DS1624();

void DS1624::Init(void)
{
    Wire.beginTransmission(DS1624_ADDR);
    Wire.send(DS1624_CONFIG_ADDR);
    Wire.send(DS1624_CONFIGS);
    Wire.endTransmission();
    
    delay(5);
    
    if (DS1624_CONFIGS == DS1624_CONFIG_CONT) {
        startConversion();
    }
}

void DS1624::startConversion(void)
{
    Wire.beginTransmission(DS1624_ADDR);
    Wire.send(DS1624_SMPL_START);
    Wire.endTransmission();
    
#ifdef DS1624_HANDLE_BOOT_DELAY
    delay(1000);
#endif
}

void DS1624::stopConversion(void)
{
    Wire.beginTransmission(DS1624_ADDR);
    Wire.send(DS1624_SMPL_STOP);
    Wire.endTransmission();
}

uint16_t DS1624::readTemp(void)
{
    uint16_t res = 0;
    Wire.beginTransmission(DS1624_ADDR);
    Wire.send(DS1624_READ_TEMP);
    Wire.endTransmission();
    
    delay(5);
    
    Wire.requestFrom(DS1624_ADDR, 2);
    
    while (!Wire.available());
    
    res = (uint8_t) (Wire.receive())<<8;
    
    while (!Wire.available());
    
    res |= (uint8_t) Wire.receive();
    
    return res;
}

#ifdef DS1624_USE_EEPROM
void DS1624::writeData(uint8_t *data)
{
    writeData(data, DS1624_EEPROM_SIZE, 0);
}

void DS1624::writeData(uint8_t *data, uint8_t dataLength)
{
    writeData(data, dataLength, 0);
}

void DS1624::writeData(uint8_t *data, uint8_t dataLength, uint8_t memoryPosition)
{
    // We can only write one page at a time!
    if (memoryPosition%DS1624_EEPROM_PAGE != 0) return;
    
    // Make sure we don't overlap
    if (dataLength == 0 || dataLength > (DS1624_EEPROM_SIZE - memoryPosition)) return;
    
    uint8_t buffer[DS1624_EEPROM_PAGE];
    uint8_t pagePosition    = 0;
    uint8_t pageSize        = 0;
    uint8_t buffLen         = 0;
    
    stopConversion();
    
    for (uint16_t pageStart = 0; pageStart < dataLength; pageStart+=DS1624_EEPROM_PAGE)
    {   
        if (pageStart+DS1624_EEPROM_PAGE < dataLength || dataLength%DS1624_EEPROM_PAGE == 0)
            pageSize    = DS1624_EEPROM_PAGE;
        else
            pageSize    = dataLength%DS1624_EEPROM_PAGE;
        
        pagePosition = 0;
        while (pagePosition < pageSize)
        {
            buffer[pagePosition]    = data[pageStart+pagePosition];
            
            pagePosition++;
        }
        
        writePage(buffer, pageSize, (memoryPosition + pageStart));
        
    }
    
    startConversion();
    
    return;
}

void DS1624::writePage(uint8_t *data, uint8_t dataLength, uint8_t pagePosition)
{
    if (dataLength == 0 || dataLength > DS1624_EEPROM_PAGE) return;
    
    Wire.beginTransmission(DS1624_ADDR);
    Wire.send(DS1624_ACCESS_MEM);
    Wire.send(pagePosition);
    
    Wire.send(data, dataLength);
    
    Wire.endTransmission();
    
    // Wait for the DS1624 to finish writing the eeprom
    delay(50);
}

void DS1624::readData(uint8_t *data)
{
    return readData(data, DS1624_EEPROM_SIZE, 0);
}

void DS1624::readData(uint8_t *data, uint8_t dataLength)
{
    return readData(data, dataLength, 0);
}

void DS1624::readData(uint8_t *data, uint8_t dataLength, uint8_t memoryPosition)
{
    // Make sure we don't overlap
    if (dataLength == 0 || dataLength > (DS1624_EEPROM_SIZE - memoryPosition)) return;
    
    uint8_t pagePosition;
    for (uint16_t pagePosition = 0; pagePosition < dataLength; pagePosition++)
    {
        // Send the access memory command along with the starting position
        Wire.beginTransmission(DS1624_ADDR);
        Wire.send(DS1624_ACCESS_MEM);
        Wire.send((int)(memoryPosition + pagePosition));
        Wire.endTransmission();
        
        // Wait for the DS1624 to set the position pointer
        delay(5);
        
        Wire.requestFrom(DS1624_ADDR, 1);
        
        while (!Wire.available());
        
        data[pagePosition] = Wire.receive();
    }
    
    return;
}
#endif