firmware/os/drivers/st_hts221/hts221.c - device/google/contexthub - Git at Google

 /*
  * 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);
	/*
	* 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);