520 lines
14 KiB
C
520 lines
14 KiB
C
/*
|
|
* 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 <atomic.h>
|
|
#include <gpio.h>
|
|
#include <nanohubPacket.h>
|
|
#include <plat/exti.h>
|
|
#include <plat/gpio.h>
|
|
#include <platform.h>
|
|
#include <plat/syscfg.h>
|
|
#include <sensors.h>
|
|
#include <seos.h>
|
|
#include <i2c.h>
|
|
#include <timer.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <variant/variant.h>
|
|
#include <variant/sensType.h>
|
|
|
|
#define HTS221_APP_ID APP_ID_MAKE(NANOHUB_VENDOR_STMICRO, 2)
|
|
|
|
/* Sensor defs */
|
|
#define HTS221_WAI_REG_ADDR 0x0F
|
|
#define HTS221_WAI_REG_VAL 0xBC
|
|
|
|
#define HTS221_AV_CONF 0x10
|
|
|
|
#define HTS221_CTRL_REG1 0x20
|
|
#define HTS221_POWER_ON 0x80
|
|
#define HTS221_POWER_OFF 0x00
|
|
#define HTS221_BDU_ON 0x04
|
|
#define HTS221_ODR_ONE_SHOT 0x00
|
|
#define HTS221_ODR_1_HZ 0x01
|
|
#define HTS221_ODR_7_HZ 0x02
|
|
#define HTS221_ODR_12_5_HZ 0x03
|
|
|
|
#define HTS221_CTRL_REG2 0x21
|
|
#define HTS221_REBOOT 0x80
|
|
|
|
#define HTS221_CTRL_REG3 0x22
|
|
#define HTS221_STATUS_REG 0x27
|
|
|
|
#define HTS221_HUMIDITY_OUTL_REG_ADDR 0x28
|
|
#define HTS221_TEMP_OUTL_REG_ADDR 0x2A
|
|
|
|
#define HTS221_CALIB_DATA 0x30
|
|
#define HTS221_CALIB_DATA_LEN 16
|
|
|
|
struct hts221_calib_data {
|
|
uint8_t h0_x2;
|
|
uint8_t h1_x2;
|
|
uint8_t unused[4];
|
|
uint8_t h0_t0_l;
|
|
uint8_t h0_t0_h;
|
|
uint8_t unused_2[2];
|
|
uint8_t h1_t0_l;
|
|
uint8_t h1_t0_h;
|
|
uint8_t unused_3[4];
|
|
};
|
|
|
|
#define INFO_PRINT(fmt, ...) \
|
|
do { \
|
|
osLog(LOG_INFO, "%s " fmt, "[HTS221]", ##__VA_ARGS__); \
|
|
} while (0);
|
|
|
|
#define DEBUG_PRINT(fmt, ...) \
|
|
do { \
|
|
if (HTS221_DBG_ENABLED) { \
|
|
osLog(LOG_DEBUG, "%s " fmt, "[HTS221]", ##__VA_ARGS__); \
|
|
} \
|
|
} while (0);
|
|
|
|
#define ERROR_PRINT(fmt, ...) \
|
|
do { \
|
|
osLog(LOG_ERROR, "%s " fmt, "[HTS221]", ##__VA_ARGS__); \
|
|
} while (0);
|
|
|
|
/* DO NOT MODIFY, just to avoid compiler error if not defined using FLAGS */
|
|
#ifndef HTS221_DBG_ENABLED
|
|
#define HTS221_DBG_ENABLED 0
|
|
#endif /* HTS221_DBG_ENABLED */
|
|
|
|
enum hts221SensorEvents
|
|
{
|
|
EVT_COMM_DONE = EVT_APP_START + 1,
|
|
EVT_INT1_RAISED,
|
|
EVT_SENSOR_HUMIDITY_TIMER,
|
|
};
|
|
|
|
enum hts221SensorState {
|
|
SENSOR_BOOT,
|
|
SENSOR_VERIFY_ID,
|
|
SENSOR_INIT,
|
|
SENSOR_HUMIDITY_POWER_UP,
|
|
SENSOR_HUMIDITY_POWER_DOWN,
|
|
SENSOR_READ_SAMPLES,
|
|
};
|
|
|
|
#ifndef HTS221_I2C_BUS_ID
|
|
#error "HTS221_I2C_BUS_ID is not defined; please define in variant.h"
|
|
#endif
|
|
|
|
#ifndef HTS221_I2C_SPEED
|
|
#error "HTS221_I2C_SPEED is not defined; please define in variant.h"
|
|
#endif
|
|
|
|
#ifndef HTS221_I2C_ADDR
|
|
#error "HTS221_I2C_ADDR is not defined; please define in variant.h"
|
|
#endif
|
|
|
|
enum hts221SensorIndex {
|
|
HUMIDITY = 0,
|
|
NUM_OF_SENSOR,
|
|
};
|
|
|
|
struct hts221Sensor {
|
|
uint32_t handle;
|
|
};
|
|
|
|
#define HTS221_MAX_PENDING_I2C_REQUESTS 4
|
|
#define HTS221_MAX_I2C_TRANSFER_SIZE HTS221_CALIB_DATA_LEN
|
|
|
|
struct I2cTransfer
|
|
{
|
|
size_t tx;
|
|
size_t rx;
|
|
int err;
|
|
uint8_t txrxBuf[HTS221_MAX_I2C_TRANSFER_SIZE];
|
|
uint8_t state;
|
|
bool inUse;
|
|
};
|
|
|
|
/* Task structure */
|
|
struct hts221Task {
|
|
uint32_t tid;
|
|
|
|
/* timer */
|
|
uint32_t humidityTimerHandle;
|
|
|
|
/* sensor flags */
|
|
bool humidityOn;
|
|
bool humidityReading;
|
|
bool humidityWantRead;
|
|
|
|
/* calib data */
|
|
int8_t y0_H;
|
|
int8_t y1_H;
|
|
int16_t x0_H;
|
|
int16_t x1_H;
|
|
|
|
struct I2cTransfer transfers[HTS221_MAX_PENDING_I2C_REQUESTS];
|
|
|
|
/* Communication functions */
|
|
bool (*comm_tx)(uint8_t addr, uint8_t data, uint32_t delay, uint8_t state);
|
|
bool (*comm_rx)(uint8_t addr, uint16_t len, uint32_t delay, uint8_t state);
|
|
|
|
/* sensors */
|
|
struct hts221Sensor sensors[NUM_OF_SENSOR];
|
|
};
|
|
|
|
static struct hts221Task mTask;
|
|
|
|
static inline float hts221_humidity_percent(int16_t hum)
|
|
{
|
|
float percentage = (float) ((mTask.y1_H - mTask.y0_H) * hum + \
|
|
((mTask.x1_H * mTask.y0_H) - (mTask.x0_H * mTask.y1_H))) / \
|
|
(mTask.x1_H - mTask.x0_H);
|
|
|
|
return((percentage > 100) ? 100 : percentage);
|
|
}
|
|
|
|
/*
|
|
* 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(mTask.transfers); i++) {
|
|
if (!mTask.transfers[i].inUse) {
|
|
mTask.transfers[i].inUse = true;
|
|
mTask.transfers[i].state = state;
|
|
return &mTask.transfers[i];
|
|
}
|
|
}
|
|
|
|
ERROR_PRINT("Ran out of i2c buffers!");
|
|
return NULL;
|
|
}
|
|
|
|
static inline void releaseXfer(struct I2cTransfer *xfer)
|
|
{
|
|
xfer->inUse = false;
|
|
}
|
|
|
|
|
|
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_COMM_DONE, cookie, NULL, mTask.tid);
|
|
if (err != 0)
|
|
ERROR_PRINT("i2c error (tx: %d, rx: %d, err: %d)\n", tx, rx, err);
|
|
}
|
|
|
|
static bool i2c_read(uint8_t addr, uint16_t len, uint32_t delay, uint8_t state)
|
|
{
|
|
struct I2cTransfer *xfer = allocXfer(state);
|
|
int ret = -1;
|
|
|
|
if (xfer != NULL) {
|
|
if (len > HTS221_MAX_I2C_TRANSFER_SIZE) {
|
|
DEBUG_PRINT("i2c_read: len too big (len: %d)\n", len);
|
|
releaseXfer(xfer);
|
|
return false;
|
|
}
|
|
|
|
xfer->txrxBuf[0] = 0x80 | addr;
|
|
if ((ret = i2cMasterTxRx(HTS221_I2C_BUS_ID, HTS221_I2C_ADDR,
|
|
xfer->txrxBuf, 1, xfer->txrxBuf, len, i2cCallback, xfer)) < 0) {
|
|
DEBUG_PRINT("i2c_read: i2cMasterTxRx operation failed (ret: %d)\n", ret);
|
|
releaseXfer(xfer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return (ret == -1) ? false : true;
|
|
}
|
|
|
|
static bool i2c_write(uint8_t addr, uint8_t data, uint32_t delay, uint8_t state)
|
|
{
|
|
struct I2cTransfer *xfer = allocXfer(state);
|
|
int ret = -1;
|
|
|
|
if (xfer != NULL) {
|
|
xfer->txrxBuf[0] = addr;
|
|
xfer->txrxBuf[1] = data;
|
|
if ((ret = i2cMasterTx(HTS221_I2C_BUS_ID, HTS221_I2C_ADDR, xfer->txrxBuf, 2, i2cCallback, xfer)) < 0) {
|
|
releaseXfer(xfer);
|
|
DEBUG_PRINT("i2c_write: i2cMasterTx operation failed (ret: %d)\n", ret);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return (ret == -1) ? false : true;
|
|
}
|
|
|
|
/* Sensor Info */
|
|
static void sensorHumidityTimerCallback(uint32_t timerId, void *data)
|
|
{
|
|
osEnqueuePrivateEvt(EVT_SENSOR_HUMIDITY_TIMER, data, NULL, mTask.tid);
|
|
}
|
|
|
|
#define DEC_INFO(name, type, axis, inter, samples, rates) \
|
|
.sensorName = name, \
|
|
.sensorType = type, \
|
|
.numAxis = axis, \
|
|
.interrupt = inter, \
|
|
.minSamples = samples, \
|
|
.supportedRates = rates
|
|
|
|
static uint32_t hts221Rates[] = {
|
|
SENSOR_HZ(1.0f),
|
|
SENSOR_HZ(7.0f),
|
|
SENSOR_HZ(12.5f),
|
|
0
|
|
};
|
|
|
|
/* should match "supported rates in length" and be the timer length for that rate in nanosecs */
|
|
static const uint64_t hts221RatesRateVals[] =
|
|
{
|
|
1 * 1000000000ULL, /* 1 Hz */
|
|
1000000000ULL / 7, /* 7 Hz */
|
|
2000000000ULL / 25, /* 12.5 Hz */
|
|
};
|
|
|
|
|
|
static const struct SensorInfo hts221SensorInfo[NUM_OF_SENSOR] =
|
|
{
|
|
{ DEC_INFO("Humidity", SENS_TYPE_HUMIDITY, NUM_AXIS_EMBEDDED, NANOHUB_INT_NONWAKEUP,
|
|
300, hts221Rates) },
|
|
};
|
|
|
|
/* Sensor Operations */
|
|
static bool humidityPower(bool on, void *cookie)
|
|
{
|
|
bool oldMode = mTask.humidityOn;
|
|
bool newMode = on;
|
|
uint32_t state = on ? SENSOR_HUMIDITY_POWER_UP : SENSOR_HUMIDITY_POWER_DOWN;
|
|
bool ret = true;
|
|
|
|
INFO_PRINT("humidityPower %s\n", on ? "enable" : "disable");
|
|
|
|
if (!on && mTask.humidityTimerHandle) {
|
|
timTimerCancel(mTask.humidityTimerHandle);
|
|
mTask.humidityTimerHandle = 0;
|
|
mTask.humidityReading = false;
|
|
}
|
|
|
|
if (oldMode != newMode) {
|
|
if (on)
|
|
ret = mTask.comm_tx(HTS221_CTRL_REG1, HTS221_POWER_ON | HTS221_ODR_12_5_HZ, 0, state);
|
|
else
|
|
ret = mTask.comm_tx(HTS221_CTRL_REG1, HTS221_POWER_OFF, 0, state);
|
|
} else
|
|
sensorSignalInternalEvt(mTask.sensors[HUMIDITY].handle,
|
|
SENSOR_INTERNAL_EVT_POWER_STATE_CHG, on, 0);
|
|
|
|
if (!ret) {
|
|
DEBUG_PRINT("humidityPower comm_tx failed\n");
|
|
return(false);
|
|
}
|
|
|
|
mTask.humidityReading = false;
|
|
mTask.humidityOn = on;
|
|
return true;
|
|
}
|
|
|
|
static bool humidityFwUpload(void *cookie)
|
|
{
|
|
return sensorSignalInternalEvt(mTask.sensors[HUMIDITY].handle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
|
|
}
|
|
|
|
static bool humiditySetRate(uint32_t rate, uint64_t latency, void *cookie)
|
|
{
|
|
INFO_PRINT("humiditySetRate %lu Hz - %llu ns\n", rate, latency);
|
|
|
|
if (mTask.humidityTimerHandle)
|
|
timTimerCancel(mTask.humidityTimerHandle);
|
|
|
|
mTask.humidityTimerHandle = timTimerSet(sensorTimerLookupCommon(hts221Rates,
|
|
hts221RatesRateVals, rate), 0, 50, sensorHumidityTimerCallback, NULL, false);
|
|
|
|
return sensorSignalInternalEvt(mTask.sensors[HUMIDITY].handle,
|
|
SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);
|
|
}
|
|
|
|
static bool humidityFlush(void *cookie)
|
|
{
|
|
return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_HUMIDITY), SENSOR_DATA_EVENT_FLUSH, NULL);
|
|
}
|
|
|
|
#define DEC_OPS(power, firmware, rate, flush, cal, cfg) \
|
|
.sensorPower = power, \
|
|
.sensorFirmwareUpload = firmware, \
|
|
.sensorSetRate = rate, \
|
|
.sensorFlush = flush, \
|
|
.sensorCalibrate = cal, \
|
|
.sensorCfgData = cfg
|
|
|
|
static const struct SensorOps hts221SensorOps[NUM_OF_SENSOR] =
|
|
{
|
|
{ DEC_OPS(humidityPower, humidityFwUpload, humiditySetRate, humidityFlush, NULL, NULL) },
|
|
};
|
|
|
|
static void hts221_save_calib_data(uint8_t *buf)
|
|
{
|
|
struct hts221_calib_data *calib = (struct hts221_calib_data *) buf;
|
|
|
|
mTask.y0_H = (int8_t) (calib->h0_x2 / 2);
|
|
mTask.y1_H = (int8_t) (calib->h1_x2 / 2);
|
|
mTask.x0_H = (int16_t) (calib->h0_t0_h << 8) |
|
|
calib->h0_t0_l;
|
|
mTask.x1_H = (int16_t) (calib->h1_t0_h << 8) |
|
|
calib->h1_t0_l;
|
|
DEBUG_PRINT("y0_H: %d - y1_H: %d\n", mTask.y0_H, mTask.y1_H);
|
|
DEBUG_PRINT("x0_H: %d - x1_H: %d\n", mTask.x0_H, mTask.x1_H);
|
|
}
|
|
|
|
static uint8_t *humidity_samples;
|
|
static int handleCommDoneEvt(const void* evtData)
|
|
{
|
|
uint8_t i;
|
|
int16_t humidity_val;
|
|
union EmbeddedDataPoint sample;
|
|
struct I2cTransfer *xfer = (struct I2cTransfer *)evtData;
|
|
|
|
switch (xfer->state) {
|
|
case SENSOR_BOOT:
|
|
hts221_save_calib_data(xfer->txrxBuf);
|
|
if (!mTask.comm_rx(HTS221_WAI_REG_ADDR, 1, 1, SENSOR_VERIFY_ID)) {
|
|
DEBUG_PRINT("Not able to read WAI\n");
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case SENSOR_VERIFY_ID:
|
|
/* Check the sensor ID */
|
|
if (xfer->err != 0 || xfer->txrxBuf[0] != HTS221_WAI_REG_VAL) {
|
|
DEBUG_PRINT("WAI returned is: %02x\n", xfer->txrxBuf[0]);
|
|
break;
|
|
}
|
|
|
|
INFO_PRINT( "Device ID is correct! (%02x)\n", xfer->txrxBuf[0]);
|
|
for (i = 0; i < NUM_OF_SENSOR; i++)
|
|
sensorRegisterInitComplete(mTask.sensors[i].handle);
|
|
|
|
break;
|
|
|
|
case SENSOR_INIT:
|
|
for (i = 0; i < NUM_OF_SENSOR; i++)
|
|
sensorRegisterInitComplete(mTask.sensors[i].handle);
|
|
break;
|
|
|
|
case SENSOR_HUMIDITY_POWER_UP:
|
|
sensorSignalInternalEvt(mTask.sensors[HUMIDITY].handle,
|
|
SENSOR_INTERNAL_EVT_POWER_STATE_CHG, true, 0);
|
|
break;
|
|
|
|
case SENSOR_HUMIDITY_POWER_DOWN:
|
|
sensorSignalInternalEvt(mTask.sensors[HUMIDITY].handle,
|
|
SENSOR_INTERNAL_EVT_POWER_STATE_CHG, false, 0);
|
|
break;
|
|
|
|
case SENSOR_READ_SAMPLES:
|
|
if (mTask.humidityOn && mTask.humidityWantRead) {
|
|
mTask.humidityWantRead = false;
|
|
humidity_samples = xfer->txrxBuf;
|
|
|
|
humidity_val = (int16_t)(((humidity_samples[1] << 8) & 0xff00) | humidity_samples[0]);
|
|
DEBUG_PRINT("humidity raw data %d\n", humidity_val);
|
|
|
|
mTask.humidityReading = false;
|
|
sample.fdata = hts221_humidity_percent(humidity_val);
|
|
osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_HUMIDITY), sample.vptr, NULL);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
releaseXfer(xfer);
|
|
return (0);
|
|
}
|
|
|
|
static void handleEvent(uint32_t evtType, const void* evtData)
|
|
{
|
|
switch (evtType) {
|
|
case EVT_APP_START:
|
|
INFO_PRINT( "EVT_APP_START\n");
|
|
osEventUnsubscribe(mTask.tid, EVT_APP_START);
|
|
|
|
mTask.comm_rx(HTS221_CALIB_DATA, sizeof(struct hts221_calib_data), 0, SENSOR_BOOT);
|
|
break;
|
|
|
|
case EVT_COMM_DONE:
|
|
handleCommDoneEvt(evtData);
|
|
break;
|
|
|
|
case EVT_SENSOR_HUMIDITY_TIMER:
|
|
mTask.humidityWantRead = true;
|
|
|
|
/* Start sampling for a value */
|
|
if (!mTask.humidityReading) {
|
|
mTask.humidityReading = true;
|
|
|
|
mTask.comm_rx(HTS221_HUMIDITY_OUTL_REG_ADDR, 2, 1, SENSOR_READ_SAMPLES);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
static bool startTask(uint32_t task_id)
|
|
{
|
|
uint8_t i;
|
|
|
|
mTask.tid = task_id;
|
|
|
|
INFO_PRINT( "started\n");
|
|
|
|
mTask.humidityOn = false;
|
|
mTask.humidityReading = false;
|
|
|
|
/* Init the communication part */
|
|
i2cMasterRequest(HTS221_I2C_BUS_ID, HTS221_I2C_SPEED);
|
|
|
|
mTask.comm_tx = i2c_write;
|
|
mTask.comm_rx = i2c_read;
|
|
|
|
for (i = 0; i < NUM_OF_SENSOR; i++) {
|
|
mTask.sensors[i].handle =
|
|
sensorRegister(&hts221SensorInfo[i], &hts221SensorOps[i], NULL, false);
|
|
}
|
|
|
|
osEventSubscribe(mTask.tid, EVT_APP_START);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void endTask(void)
|
|
{
|
|
INFO_PRINT( "ended\n");
|
|
}
|
|
|
|
INTERNAL_APP_INIT(HTS221_APP_ID, 0, startTask, endTask, handleEvent);
|