/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <seos.h>
#include <i2c.h>
#include <timer.h>
#include <sensors.h>
#include <heap.h>
#include <hostIntf.h>
#include <nanohubPacket.h>
#include <eventnums.h>
#include <util.h>
#define AMS_TMD2772_APP_VERSION 3
#define DRIVER_NAME "AMS: "
#define I2C_BUS_ID 0
#define I2C_SPEED 400000
#define I2C_ADDR 0x39
#define AMS_TMD2772_ID 0x39
#define AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT 0xa0
#define AMS_TMD2772_REG_ENABLE (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x00)
#define AMS_TMD2772_REG_ATIME (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x01)
#define AMS_TMD2772_REG_PTIME (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x02)
#define AMS_TMD2772_REG_WTIME (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x03)
#define AMS_TMD2772_REG_AILTL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x04)
#define AMS_TMD2772_REG_AILTH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x05)
#define AMS_TMD2772_REG_AIHTL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x06)
#define AMS_TMD2772_REG_AIHTH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x07)
#define AMS_TMD2772_REG_PILTL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x08)
#define AMS_TMD2772_REG_PILTH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x09)
#define AMS_TMD2772_REG_PIHTL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0a)
#define AMS_TMD2772_REG_PIHTH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0b)
#define AMS_TMD2772_REG_PERS (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0c)
#define AMS_TMD2772_REG_CONFIG (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0d)
#define AMS_TMD2772_REG_PPULSE (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0e)
#define AMS_TMD2772_REG_CONTROL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x0f)
#define AMS_TMD2772_REG_ID (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x12)
#define AMS_TMD2772_REG_STATUS (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x13)
#define AMS_TMD2772_REG_C0DATA (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x14)
#define AMS_TMD2772_REG_C0DATAH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x15)
#define AMS_TMD2772_REG_C1DATA (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x16)
#define AMS_TMD2772_REG_C1DATAH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x17)
#define AMS_TMD2772_REG_PDATAL (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x18)
#define AMS_TMD2772_REG_PDATAH (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x19)
#define AMS_TMD2772_REG_POFFSET (AMS_TMD2772_CMD_TYPE_AUTO_INCREMENT | 0x1E)
#define AMS_TMD2772_ATIME_SETTING 0xdb
#define AMS_TMD2772_ATIME_MS ((256 - AMS_TMD2772_ATIME_SETTING) * 2.73) // in milliseconds
#define AMS_TMD2772_PTIME_SETTING 0xff
#define AMS_TMD2772_PTIME_MS ((256 - AMS_TMD2772_PTIME_SETTING) * 2.73) // in milliseconds
#define AMS_TMD2772_WTIME_SETTING_ALS_ON 0xdd // (256 - 221) * 2.73 ms = 95.55 ms
#define AMS_TMD2772_WTIME_SETTING_ALS_OFF 0xb8 // (256 - 184) * 2.73 ms = 196.56 ms
#define AMS_TMD2772_PPULSE_SETTING 8
#define AMS_TMD2772_CAL_DEFAULT_OFFSET 0
#define AMS_TMD2772_CAL_MAX_OFFSET 500
/* AMS_TMD2772_REG_ENABLE */
#define POWER_ON_BIT (1 << 0)
#define ALS_ENABLE_BIT (1 << 1)
#define PROX_ENABLE_BIT (1 << 2)
#define WAIT_ENABLE_BIT (1 << 3)
/* AMS_TMD2772_REG_STATUS */
#define PROX_INT_BIT (1 << 5)
#define ALS_INT_BIT (1 << 4)
#define PROX_VALID_BIT (1 << 1)
#define ALS_VALID_BIT (1 << 0)
#define AMS_TMD2772_REPORT_NEAR_VALUE 0.0f // centimeters
#define AMS_TMD2772_REPORT_FAR_VALUE 5.0f // centimeters
#define AMS_TMD2772_THRESHOLD_ASSERT_NEAR 300 // in PS units
#define AMS_TMD2772_THRESHOLD_DEASSERT_NEAR 150 // in PS units
#define AMS_TMD2772_ALS_MAX_CHANNEL_COUNT 37888 // in raw data
#define AMS_TMD2772_ALS_MAX_REPORT_VALUE 10000 // in lux
#define AMS_TMD2772_ALS_INVALID UINT32_MAX
/* Used when SENSOR_RATE_ONCHANGE is requested */
#define AMS_TMD2772_DEFAULT_RATE SENSOR_HZ(5)
#define AMS_TMD2772_MAX_PENDING_I2C_REQUESTS 4
#define AMS_TMD2772_MAX_I2C_TRANSFER_SIZE 16
/* Private driver events */
enum SensorEvents
{
EVT_SENSOR_I2C = EVT_APP_START + 1,
EVT_SENSOR_ALS_TIMER,
EVT_SENSOR_PROX_TIMER,
};
/* I2C state machine */
enum SensorState
{
SENSOR_STATE_VERIFY_ID,
SENSOR_STATE_INIT,
SENSOR_STATE_CALIBRATE_RESET,
SENSOR_STATE_CALIBRATE_START,
SENSOR_STATE_CALIBRATE_ENABLING,
SENSOR_STATE_CALIBRATE_POLLING_STATUS,
SENSOR_STATE_CALIBRATE_AWAITING_SAMPLE,
SENSOR_STATE_CALIBRATE_DISABLING,
SENSOR_STATE_ENABLING_ALS,
SENSOR_STATE_ENABLING_PROX,
SENSOR_STATE_DISABLING_ALS,
SENSOR_STATE_DISABLING_PROX,
SENSOR_STATE_IDLE,
SENSOR_STATE_SAMPLING,
};
enum ProxState
{
PROX_STATE_INIT,
PROX_STATE_NEAR,
PROX_STATE_FAR,
};
struct I2cTransfer
{
size_t tx;
size_t rx;
int err;
union {
uint8_t bytes[AMS_TMD2772_MAX_I2C_TRANSFER_SIZE];
struct {
uint8_t status;
uint16_t als[2];
uint16_t prox;
} __attribute__((packed)) sample;
struct {
uint16_t prox;
} calibration;
} txrxBuf;
uint8_t state;
bool inUse;
};
struct SensorData
{
uint32_t tid;
uint32_t alsHandle;
uint32_t proxHandle;
uint32_t alsTimerHandle;
uint32_t proxTimerHandle;
uint32_t calibrationSampleTotal;
struct I2cTransfer transfers[AMS_TMD2772_MAX_PENDING_I2C_REQUESTS];
union EmbeddedDataPoint lastAlsSample;
uint8_t calibrationSampleCount;
uint8_t proxState; // enum ProxState
bool alsOn;
bool alsReading;
bool proxOn;
bool proxReading;
};
static struct SensorData mData;
/* TODO: check rates are supported */
static const uint32_t supportedRates[] =
{
SENSOR_HZ(0.1),
SENSOR_HZ(1),
SENSOR_HZ(4),
SENSOR_HZ(5),
SENSOR_RATE_ONCHANGE,
0
};
static const uint64_t rateTimerVals[] = //should match "supported rates in length" and be the timer length for that rate in nanosecs
{
10 * 1000000000ULL,
1 * 1000000000ULL,
1000000000ULL / 4,
1000000000ULL / 5,
};
/*
* Helper functions
*/
static void i2cCallback(void *cookie, size_t tx, size_t rx, int err)
{
struct I2cTransfer *xfer = cookie;
xfer->tx = tx;
xfer->rx = rx;
xfer->err = err;
osEnqueuePrivateEvt(EVT_SENSOR_I2C, cookie, NULL, mData.tid);
if (err != 0)
osLog(LOG_INFO, DRIVER_NAME "i2c error (tx: %d, rx: %d, err: %d)\n", tx, rx, err);
}
// Allocate a buffer and mark it as in use with the given state, or return NULL
// if no buffers available. Must *not* be called from interrupt context.
static struct I2cTransfer *allocXfer(uint8_t state)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(mData.transfers); i++) {
if (!mData.transfers[i].inUse) {
mData.transfers[i].inUse = true;
mData.transfers[i].state = state;
return &mData.transfers[i];
}
}
osLog(LOG_ERROR, DRIVER_NAME "Ran out of i2c buffers!");
return NULL;
}
// Helper function to write a one byte register. Returns true if we got a
// successful return value from i2cMasterTx().
static bool writeRegister(uint8_t reg, uint8_t value, uint8_t state)
{
struct I2cTransfer *xfer = allocXfer(state);
int ret = -1;
if (xfer != NULL) {
xfer->txrxBuf.bytes[0] = reg;
xfer->txrxBuf.bytes[1] = value;
ret = i2cMasterTx(I2C_BUS_ID, I2C_ADDR, xfer->txrxBuf.bytes, 2, i2cCallback, xfer);
}
return (ret == 0);
}
static void alsTimerCallback(uint32_t timerId, void *cookie)
{
osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, cookie, NULL, mData.tid);
}
static void proxTimerCallback(uint32_t timerId, void *cookie)
{
osEnqueuePrivateEvt(EVT_SENSOR_PROX_TIMER, cookie, NULL, mData.tid);
}
static inline float getLuxFromAlsData(uint16_t als0, uint16_t als1)
{
float cpl = 1.0f / AMS_TMD2772_ATIME_MS;
float GA;
if ((als0 * 10) < (als1 * 21)) {
// A light
GA = 0.274f;
} else if (((als0 * 10) >= (als1 * 21)) && ((als0 * 10) <= (als1 * 43)) && (als0 > 300)) {
// D65
GA = 0.592f;
} else {
// cool white
GA = 1.97f;
}
float lux1 = GA * 207 * (als0 - (1.799 * als1)) * cpl;
float lux2 = GA * 207 * ((0.188f * als0) - (0.303 * als1)) * cpl;
if ((als0 >= AMS_TMD2772_ALS_MAX_CHANNEL_COUNT) ||
(als1 >= AMS_TMD2772_ALS_MAX_CHANNEL_COUNT)) {
return AMS_TMD2772_ALS_MAX_REPORT_VALUE;
} else if ((lux1 > lux2) && (lux1 > 0.0f)) {
return lux1 > AMS_TMD2772_ALS_MAX_REPORT_VALUE ? AMS_TMD2772_ALS_MAX_REPORT_VALUE : lux1;
} else if (lux2 > 0.0f) {
return lux2 > AMS_TMD2772_ALS_MAX_REPORT_VALUE ? AMS_TMD2772_ALS_MAX_REPORT_VALUE : lux2;
} else {
return 0.0f;
}
}
static void setMode(bool alsOn, bool proxOn, uint8_t state)
{
struct I2cTransfer *xfer;
xfer = allocXfer(state);
if (xfer != NULL) {
xfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_ENABLE;
xfer->txrxBuf.bytes[1] = POWER_ON_BIT | WAIT_ENABLE_BIT |
(alsOn ? ALS_ENABLE_BIT : 0) | (proxOn ? PROX_ENABLE_BIT : 0);
xfer->txrxBuf.bytes[2] = AMS_TMD2772_ATIME_SETTING;
xfer->txrxBuf.bytes[3] = AMS_TMD2772_PTIME_SETTING;
xfer->txrxBuf.bytes[4] = alsOn ? AMS_TMD2772_WTIME_SETTING_ALS_ON : AMS_TMD2772_WTIME_SETTING_ALS_OFF;
i2cMasterTx(I2C_BUS_ID, I2C_ADDR, xfer->txrxBuf.bytes, 5, i2cCallback, xfer);
}
}
static bool sensorPowerAls(bool on, void *cookie)
{
osLog(LOG_INFO, DRIVER_NAME "sensorPowerAls: %d\n", on);
if (mData.alsTimerHandle) {
timTimerCancel(mData.alsTimerHandle);
mData.alsTimerHandle = 0;
mData.alsReading = false;
}
mData.lastAlsSample.idata = AMS_TMD2772_ALS_INVALID;
mData.alsOn = on;
setMode(on, mData.proxOn, (on ? SENSOR_STATE_ENABLING_ALS : SENSOR_STATE_DISABLING_ALS));
return true;
}
static bool sensorFirmwareAls(void *cookie)
{
sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
return true;
}
static bool sensorRateAls(uint32_t rate, uint64_t latency, void *cookie)
{
if (rate == SENSOR_RATE_ONCHANGE) {
rate = AMS_TMD2772_DEFAULT_RATE;
}
osLog(LOG_INFO, DRIVER_NAME "sensorRateAls: %ld/%lld\n", rate, latency);
if (mData.alsTimerHandle)
timTimerCancel(mData.alsTimerHandle);
mData.alsTimerHandle = timTimerSet(sensorTimerLookupCommon(supportedRates, rateTimerVals, rate), 0, 50, alsTimerCallback, NULL, false);
osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, NULL, NULL, mData.tid);
sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);
return true;
}
static bool sensorFlushAls(void *cookie)
{
return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), SENSOR_DATA_EVENT_FLUSH, NULL);
}
static bool sendLastSampleAls(void *cookie, uint32_t tid) {
bool result = true;
// If we don't end up doing anything here, the expectation is that we are powering up/haven't got the
// first sample yet, so a broadcast event will go out soon with the first sample
if (mData.lastAlsSample.idata != AMS_TMD2772_ALS_INVALID) {
result = osEnqueuePrivateEvt(sensorGetMyEventType(SENS_TYPE_ALS), mData.lastAlsSample.vptr, NULL, tid);
}
return result;
}
static bool sensorPowerProx(bool on, void *cookie)
{
osLog(LOG_INFO, DRIVER_NAME "sensorPowerProx: %d\n", on);
if (mData.proxTimerHandle) {
timTimerCancel(mData.proxTimerHandle);
mData.proxTimerHandle = 0;
mData.proxReading = false;
}
mData.proxState = PROX_STATE_INIT;
mData.proxOn = on;
setMode(mData.alsOn, on, (on ? SENSOR_STATE_ENABLING_PROX : SENSOR_STATE_DISABLING_PROX));
return true;
}
static bool sensorFirmwareProx(void *cookie)
{
sensorSignalInternalEvt(mData.proxHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
return true;
}
static bool sensorRateProx(uint32_t rate, uint64_t latency, void *cookie)
{
if (rate == SENSOR_RATE_ONCHANGE) {
rate = AMS_TMD2772_DEFAULT_RATE;
}
osLog(LOG_INFO, DRIVER_NAME "sensorRateProx: %ld/%lld\n", rate, latency);
if (mData.proxTimerHandle)
timTimerCancel(mData.proxTimerHandle);
mData.proxTimerHandle = timTimerSet(sensorTimerLookupCommon(supportedRates, rateTimerVals, rate), 0, 50, proxTimerCallback, NULL, false);
osEnqueuePrivateEvt(EVT_SENSOR_PROX_TIMER, NULL, NULL, mData.tid);
sensorSignalInternalEvt(mData.proxHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);
return true;
}
static bool sensorFlushProx(void *cookie)
{
return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_PROX), SENSOR_DATA_EVENT_FLUSH, NULL);
}
static bool sendLastSampleProx(void *cookie, uint32_t tid) {
union EmbeddedDataPoint sample;
bool result = true;
// See note in sendLastSampleAls
if (mData.proxState != PROX_STATE_INIT) {
sample.fdata = (mData.proxState == PROX_STATE_NEAR) ?
AMS_TMD2772_REPORT_NEAR_VALUE : AMS_TMD2772_REPORT_FAR_VALUE;
result = osEnqueuePrivateEvt(sensorGetMyEventType(SENS_TYPE_PROX), sample.vptr, NULL, tid);
}
return result;
}
static const struct SensorInfo sensorInfoAls =
{
.sensorName = "ALS",
.supportedRates = supportedRates,
.sensorType = SENS_TYPE_ALS,
.numAxis = NUM_AXIS_EMBEDDED,
.interrupt = NANOHUB_INT_NONWAKEUP,
.minSamples = 20
};
static const struct SensorOps sensorOpsAls =
{
.sensorPower = sensorPowerAls,
.sensorFirmwareUpload = sensorFirmwareAls,
.sensorSetRate = sensorRateAls,
.sensorFlush = sensorFlushAls,
.sensorTriggerOndemand = NULL,
.sensorCalibrate = NULL,
.sensorSendOneDirectEvt = sendLastSampleAls
};
static const struct SensorInfo sensorInfoProx =
{
.sensorName = "Proximity",
.supportedRates = supportedRates,
.sensorType = SENS_TYPE_PROX,
.numAxis = NUM_AXIS_EMBEDDED,
.interrupt = NANOHUB_INT_WAKEUP,
.minSamples = 300
};
static const struct SensorOps sensorOpsProx =
{
.sensorPower = sensorPowerProx,
.sensorFirmwareUpload = sensorFirmwareProx,
.sensorSetRate = sensorRateProx,
.sensorFlush = sensorFlushProx,
.sensorTriggerOndemand = NULL,
.sensorCalibrate = NULL,
.sensorSendOneDirectEvt = sendLastSampleProx
};
/*
* Sensor i2c state machine
*/
static void handle_calibration_event(struct I2cTransfer *xfer) {
struct I2cTransfer *nextXfer;
switch (xfer->state) {
case SENSOR_STATE_CALIBRATE_RESET:
mData.calibrationSampleCount = 0;
mData.calibrationSampleTotal = 0;
/* Intentional fall-through */
case SENSOR_STATE_CALIBRATE_START:
writeRegister(AMS_TMD2772_REG_ENABLE, POWER_ON_BIT | PROX_ENABLE_BIT, SENSOR_STATE_CALIBRATE_ENABLING);
break;
case SENSOR_STATE_CALIBRATE_ENABLING:
nextXfer = allocXfer(SENSOR_STATE_CALIBRATE_POLLING_STATUS);
if (nextXfer != NULL) {
nextXfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_STATUS;
i2cMasterTxRx(I2C_BUS_ID, I2C_ADDR, nextXfer->txrxBuf.bytes, 1, nextXfer->txrxBuf.bytes, 1, i2cCallback, nextXfer);
}
break;
case SENSOR_STATE_CALIBRATE_POLLING_STATUS:
if (xfer->txrxBuf.bytes[0] & PROX_INT_BIT) {
/* Done */
nextXfer = allocXfer(SENSOR_STATE_CALIBRATE_AWAITING_SAMPLE);
if (nextXfer != NULL) {
nextXfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_PDATAL;
i2cMasterTxRx(I2C_BUS_ID, I2C_ADDR, nextXfer->txrxBuf.bytes, 1, nextXfer->txrxBuf.bytes, 2, i2cCallback, nextXfer);
}
} else {
/* Poll again; go back to previous state */
xfer->state = SENSOR_STATE_CALIBRATE_ENABLING;
handle_calibration_event(xfer);
}
break;
case SENSOR_STATE_CALIBRATE_AWAITING_SAMPLE:
mData.calibrationSampleCount++;
mData.calibrationSampleTotal += xfer->txrxBuf.calibration.prox;
writeRegister(AMS_TMD2772_REG_ENABLE, 0x00, SENSOR_STATE_CALIBRATE_DISABLING);
break;
case SENSOR_STATE_CALIBRATE_DISABLING:
if (mData.calibrationSampleCount >= 20) {
/* Done, calculate calibration */
uint16_t average = mData.calibrationSampleTotal / mData.calibrationSampleCount;
uint16_t crosstalk = (average > 0x7f) ? 0x7f : average;
writeRegister(AMS_TMD2772_REG_POFFSET, crosstalk, SENSOR_STATE_IDLE);
} else {
/* Get another sample; go back to earlier state */
xfer->state = SENSOR_STATE_CALIBRATE_START;
handle_calibration_event(xfer);
}
break;
default:
break;
}
}
static void handle_i2c_event(struct I2cTransfer *xfer)
{
union EmbeddedDataPoint sample;
bool sendData;
struct I2cTransfer *nextXfer;
switch (xfer->state) {
case SENSOR_STATE_VERIFY_ID:
/* Check the sensor ID */
if (xfer->err != 0 || xfer->txrxBuf.bytes[0] != AMS_TMD2772_ID) {
osLog(LOG_INFO, DRIVER_NAME "not detected\n");
sensorUnregister(mData.alsHandle);
sensorUnregister(mData.proxHandle);
break;
}
nextXfer = allocXfer(SENSOR_STATE_INIT);
if (nextXfer != NULL) {
/* Start address */
nextXfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_ENABLE;
/* ENABLE */
nextXfer->txrxBuf.bytes[1] = 0x00;
/* ATIME */
nextXfer->txrxBuf.bytes[2] = AMS_TMD2772_ATIME_SETTING;
/* PTIME */
nextXfer->txrxBuf.bytes[3] = AMS_TMD2772_PTIME_SETTING;
/* WTIME */
nextXfer->txrxBuf.bytes[4] = 0xFF;
i2cMasterTx(I2C_BUS_ID, I2C_ADDR, nextXfer->txrxBuf.bytes, 5, i2cCallback, nextXfer);
}
break;
case SENSOR_STATE_INIT:
nextXfer = allocXfer(SENSOR_STATE_IDLE);
if (nextXfer != NULL) {
/* Start address */
nextXfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_PERS;
/* PERS */
nextXfer->txrxBuf.bytes[1] = 0x00;
/* CONFIG */
nextXfer->txrxBuf.bytes[2] = 0x00;
/* PPULSE */
nextXfer->txrxBuf.bytes[3] = AMS_TMD2772_PPULSE_SETTING;
/* CONTROL */
nextXfer->txrxBuf.bytes[4] = 0x20;
i2cMasterTx(I2C_BUS_ID, I2C_ADDR, nextXfer->txrxBuf.bytes, 5, i2cCallback, nextXfer);
}
break;
case SENSOR_STATE_IDLE:
sensorRegisterInitComplete(mData.alsHandle);
sensorRegisterInitComplete(mData.proxHandle);
break;
case SENSOR_STATE_ENABLING_ALS:
sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, true, 0);
break;
case SENSOR_STATE_ENABLING_PROX:
sensorSignalInternalEvt(mData.proxHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, true, 0);
break;
case SENSOR_STATE_DISABLING_ALS:
sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, false, 0);
break;
case SENSOR_STATE_DISABLING_PROX:
sensorSignalInternalEvt(mData.proxHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, false, 0);
break;
case SENSOR_STATE_SAMPLING:
#if 0
osLog(LOG_INFO, DRIVER_NAME "sample ready: status=%02x prox=%u als0=%u als1=%u\n",
xfer->txrxBuf.sample.status, xfer->txrxBuf.sample.prox,
xfer->txrxBuf.sample.als[0], xfer->txrxBuf.sample.als[1]);
#endif
if (mData.alsOn && mData.alsReading &&
(xfer->txrxBuf.sample.status & ALS_VALID_BIT)) {
/* Create event */
sample.fdata = getLuxFromAlsData(xfer->txrxBuf.sample.als[0],
xfer->txrxBuf.sample.als[1]);
if (mData.lastAlsSample.idata != sample.idata) {
osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), sample.vptr, NULL);
mData.lastAlsSample.fdata = sample.fdata;
}
}
if (mData.proxOn && mData.proxReading &&
(xfer->txrxBuf.sample.status & PROX_VALID_BIT)) {
/* Create event */
sendData = true;
if (mData.proxState == PROX_STATE_INIT) {
if (xfer->txrxBuf.sample.prox > AMS_TMD2772_THRESHOLD_ASSERT_NEAR) {
sample.fdata = AMS_TMD2772_REPORT_NEAR_VALUE;
mData.proxState = PROX_STATE_NEAR;
} else {
sample.fdata = AMS_TMD2772_REPORT_FAR_VALUE;
mData.proxState = PROX_STATE_FAR;
}
} else {
if (mData.proxState == PROX_STATE_NEAR &&
xfer->txrxBuf.sample.prox < AMS_TMD2772_THRESHOLD_DEASSERT_NEAR) {
sample.fdata = AMS_TMD2772_REPORT_FAR_VALUE;
mData.proxState = PROX_STATE_FAR;
} else if (mData.proxState == PROX_STATE_FAR &&
xfer->txrxBuf.sample.prox > AMS_TMD2772_THRESHOLD_ASSERT_NEAR) {
sample.fdata = AMS_TMD2772_REPORT_NEAR_VALUE;
mData.proxState = PROX_STATE_NEAR;
} else {
sendData = false;
}
}
if (sendData)
osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_PROX), sample.vptr, NULL);
}
mData.alsReading = false;
mData.proxReading = false;
break;
default:
handle_calibration_event(xfer);
break;
}
xfer->inUse = false;
}
/*
* Main driver entry points
*/
static bool init_app(uint32_t myTid)
{
/* Set up driver private data */
mData.tid = myTid;
mData.alsOn = false;
mData.alsReading = false;
mData.proxOn = false;
mData.proxReading = false;
mData.lastAlsSample.idata = AMS_TMD2772_ALS_INVALID;
mData.proxState = PROX_STATE_INIT;
/* Register sensors */
mData.alsHandle = sensorRegister(&sensorInfoAls, &sensorOpsAls, NULL, false);
mData.proxHandle = sensorRegister(&sensorInfoProx, &sensorOpsProx, NULL, false);
osEventSubscribe(myTid, EVT_APP_START);
return true;
}
static void end_app(void)
{
sensorUnregister(mData.alsHandle);
sensorUnregister(mData.proxHandle);
i2cMasterRelease(I2C_BUS_ID);
}
static void handle_event(uint32_t evtType, const void* evtData)
{
struct I2cTransfer *xfer;
switch (evtType) {
case EVT_APP_START:
osEventUnsubscribe(mData.tid, EVT_APP_START);
i2cMasterRequest(I2C_BUS_ID, I2C_SPEED);
/* TODO: reset chip first */
xfer = allocXfer(SENSOR_STATE_VERIFY_ID);
if (xfer != NULL) {
xfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_ID;
i2cMasterTxRx(I2C_BUS_ID, I2C_ADDR, xfer->txrxBuf.bytes, 1, xfer->txrxBuf.bytes, 1, i2cCallback, xfer);
}
break;
case EVT_SENSOR_I2C:
handle_i2c_event((struct I2cTransfer *)evtData);
break;
case EVT_SENSOR_ALS_TIMER:
case EVT_SENSOR_PROX_TIMER:
/* Start sampling for a value */
if (!mData.alsReading && !mData.proxReading) {
xfer = allocXfer(SENSOR_STATE_SAMPLING);
if (xfer != NULL) {
xfer->txrxBuf.bytes[0] = AMS_TMD2772_REG_STATUS;
i2cMasterTxRx(I2C_BUS_ID, I2C_ADDR, xfer->txrxBuf.bytes, 1, xfer->txrxBuf.bytes, 7, i2cCallback, xfer);
}
}
if (evtType == EVT_SENSOR_ALS_TIMER)
mData.alsReading = true;
else
mData.proxReading = true;
break;
}
}
INTERNAL_APP_INIT(APP_ID_MAKE(NANOHUB_VENDOR_GOOGLE, 9), AMS_TMD2772_APP_VERSION, init_app, end_app, handle_event);