APDS9300.c

Go to the documentation of this file.

/****************************************************************************
 * Copyright (C) 2015 Sensorian
 *                                                                          *
 * This file is part of Sensorian.                                          *
 *                                                                          *
 *   Sensorian is free software: you can redistribute it and/or modify it   *
 *   under the terms of the GNU Lesser General Public License as published  *
 *   by the Free Software Foundation, either version 3 of the License, or   *
 *   (at your option) any later version.                                    *
 *                                                                          *
 *   Sensorian is distributed in the hope that it will be useful,           *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU Lesser General Public License for more details.                    *
 *                                                                          *
 *   You should have received a copy of the GNU Lesser General Public       *
 *   License along with Sensorian.                                          *
 *   If not, see <http://www.gnu.org/licenses/>.                            *
 ****************************************************************************/

#include "APDS9300.h"
#include "i2c.h"
#include "math.h"

#pragma GCC diagnostic ignored "-pedantic"


unsigned char AL_Initialize(void)
{    
    char control = APDS9300_ReadByte(CONTROL|CMD_CLEAR_INT|CMD_WORD);       
    AL_PowerState(POWER_ON);                                                //Power on sensor   
    return control;
}

void AL_PowerState(powerState state)
{
    unsigned char cmd  = (unsigned char) state;
    APDS9300_WriteByte(COMMAND|CMD_CLEAR_INT|CONTROL);         //Clear interrupts 
    APDS9300_WriteByte(cmd);                                   //Power on/off the sensors by writing to control reg
}

unsigned char AL_ChipID(void)
{
    unsigned char partID = 0x00;
    partID = APDS9300_ReadByte(COMMAND|ID);
    return partID;
}

unsigned int AL_ReadChannel(channel chan)
{
    unsigned int channelValue = 0;
    switch(chan)
    {
        case CH0:
            APDS9300_WriteByte(COMMAND|CMD_CLEAR_INT|CMD_WORD|DATA0LOW);
            channelValue = APDS9300_ReadWord();
            break;
        case CH1:
            APDS9300_WriteByte(COMMAND|CMD_CLEAR_INT|CMD_WORD|DATA1LOW);
            channelValue = APDS9300_ReadWord();
            break;
        default:
            channelValue = 0;
        break;
    }
    return channelValue;
}

float AL_Lux(unsigned int ch0, unsigned int ch1)
{
    float k = ch1/ch0;
    float Lux=0;

    if((k>=0)&& (k<=0.52))
        Lux=(0.0315*ch0)-(0.0593*ch0*pow(k,1.4));
    else if((k>0.52)&& (k<=0.65))
        Lux=(0.0229*ch0)-(0.0291*ch1);
    else if((k>0.65)&& (k<=0.80))
        Lux=(0.0157*ch0)-(0.0180*ch1);
    else if((k>0.80)&& (k<=1.30))
        Lux=(0.00338*ch0)-(0.00260*ch1);
    else 
        Lux=0;
    return Lux;
}

unsigned char AL_SetGain(gain val)
{
    unsigned char value = 0;
    switch(val)
    {
        case GAIN_1:
            value  = APDS9300_ReadByte(COMMAND|TIMING);       //Write to TIMING register
            value &= 0b11101111;
            APDS9300_WriteByte(COMMAND|TIMING);       //Write to TIMING register
            APDS9300_WriteByte(value);
            break;
        case GAIN_16:
            APDS9300_WriteByte(COMMAND|TIMING);     //Write to TIMING register
            APDS9300_WriteByte(GAIN);
            break;
        default:
            APDS9300_WriteByte(COMMAND|TIMING);
            APDS9300_WriteByte(GAIN);
    }
    return val;
}

void AL_SetSamplingTime(sampTime_t sampling_time)
{
    APDS9300_WriteByte(COMMAND|TIMING);
    APDS9300_WriteByte(sampling_time);
}

void AL_SetIntLowThreshold(unsigned int lowthreshvalue)
{
     APDS9300_WriteWord(COMMAND | THRESHLOWLOW| CMD_WORD,lowthreshvalue); 
}

void AL_SetIntHighThreshold(unsigned int highthreshvalue)
{
    APDS9300_WriteWord(COMMAND|THRESHHIGHLOW| CMD_WORD,highthreshvalue);
}

void AL_Clear_Interrupt(void)
{
    APDS9300_WriteByte(COMMAND|CMD_CLEAR_INT);          //Set clear bit to 1
}

void AL_ConfigureInterrupt(unsigned char enable, unsigned char persistence)
{
    if(enable)
    {
        APDS9300_WriteByte(COMMAND|INTERRUPT|INTERR_ENA);
        APDS9300_WriteByte(persistence);
    }
    else
    {
        APDS9300_WriteByte(COMMAND|INTERRUPT);
        APDS9300_WriteByte(INTERR_DISMASK);
    }
}



void APDS9300_WriteByte(unsigned char data)
{
    I2C_WriteByte(data);            //Sets a specific register to a certain value
}

void APDS9300_WriteRegister(unsigned char reg, unsigned char data)
{
    I2C_WriteByteRegister(reg,data);            //Writes data on the specific register
}

void APDS9300_WriteWord(unsigned char reg, unsigned int data)
{
    unsigned char buffer[2];
    buffer[1] = (unsigned char) (data >> 8);            //MSB
    buffer[0] = (unsigned char) (data && 0xff);         //LSB
    I2C_WriteWordRegister(reg,buffer);
}

char APDS9300_ReadByte(char reg)
{
    return I2C_ReadByteRegister(reg);
}

unsigned int APDS9300_ReadWordReg(char reg)
{   unsigned int val = I2C_ReadWordRegisterRS(reg);
    return val;
}

unsigned int APDS9300_ReadWord(void)
{
    char buff[2] = {0x00,0x00};
    bcm2835_i2c_read(buff,2);

    return (buff[1] << 8)|buff[0];
}