/**
* main
*
* The main function for the project. This function initializes the os, calls
* init_tasks to initialize tasks (and possibly other objects), then starts the
* OS. We should not return from os start.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
sysinit();
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
stats_init(STATS_HDR(g_stats_gpio_toggle),
STATS_SIZE_INIT_PARMS(g_stats_gpio_toggle, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(gpio_stats));
stats_register("gpio_toggle", STATS_HDR(g_stats_gpio_toggle));
conf_load();
log_reboot(HARD_REBOOT);
init_tasks();
os_start();
/* os start should never return. If it does, this should be an error */
assert(0);
return rc;
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this color sensor
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
tcs34725_init(struct os_dev *dev, void *arg)
{
struct tcs34725 *tcs34725;
struct sensor *sensor;
int rc;
if (!arg || !dev) {
rc = SYS_ENODEV;
goto err;
}
tcs34725 = (struct tcs34725 *) dev;
tcs34725->cfg.mask = SENSOR_TYPE_ALL;
sensor = &tcs34725->sensor;
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_tcs34725stats),
STATS_SIZE_INIT_PARMS(g_tcs34725stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(tcs34725_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register("tcs34725", STATS_HDR(g_tcs34725stats));
SYSINIT_PANIC_ASSERT(rc == 0);
rc = sensor_init(sensor, dev);
if (rc != 0) {
goto err;
}
/* Add the color sensor driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_COLOR,
(struct sensor_driver *) &g_tcs34725_sensor_driver);
if (rc != 0) {
goto err;
}
/* Set the interface */
rc = sensor_set_interface(sensor, arg);
if (rc) {
goto err;
}
rc = sensor_mgr_register(sensor);
if (rc != 0) {
goto err;
}
rc = sensor_set_type_mask(sensor, tcs34725->cfg.mask);
if (rc) {
goto err;
}
return (0);
err:
return (rc);
}
/**
* main
*
* The main task for the project. This function initializes the packages, calls
* init_tasks to initialize additional tasks (and possibly other objects),
* then starts serving events from default event queue.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
sysinit();
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
stats_init(STATS_HDR(g_stats_gpio_toggle),
STATS_SIZE_INIT_PARMS(g_stats_gpio_toggle, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(gpio_stats));
stats_register("gpio_toggle", STATS_HDR(g_stats_gpio_toggle));
conf_load();
reboot_start(hal_reset_cause());
init_tasks();
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
/* Never exit */
return rc;
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this accellerometer
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
bno055_init(struct os_dev *dev, void *arg)
{
struct bno055 *bno055;
struct sensor *sensor;
int rc;
bno055 = (struct bno055 *) dev;
rc = bno055_default_cfg(&bno055->cfg);
if (rc) {
goto err;
}
#if MYNEWT_VAL(BNO055_LOG)
log_register("bno055", &_log, &log_console_handler, NULL, LOG_SYSLEVEL);
#endif
sensor = &bno055->sensor;
#if MYNEWT_VAL(BNO055_STATS)
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_bno055stats),
STATS_SIZE_INIT_PARMS(g_bno055stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(bno055_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register("bno055", STATS_HDR(g_bno055stats));
SYSINIT_PANIC_ASSERT(rc == 0);
#endif
rc = sensor_init(sensor, dev);
if (rc != 0) {
goto err;
}
/* Add the accelerometer/magnetometer driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_ACCELEROMETER |
SENSOR_TYPE_MAGNETIC_FIELD | SENSOR_TYPE_GYROSCOPE |
SENSOR_TYPE_TEMPERATURE | SENSOR_TYPE_ROTATION_VECTOR |
SENSOR_TYPE_GRAVITY | SENSOR_TYPE_LINEAR_ACCEL |
SENSOR_TYPE_EULER, (struct sensor_driver *) &g_bno055_sensor_driver);
if (rc != 0) {
goto err;
}
rc = sensor_mgr_register(sensor);
if (rc != 0) {
goto err;
}
return (0);
err:
return (rc);
}
/**
* main
*
* The main task for the project. This function initializes the packages, calls
* init_tasks to initialize additional tasks (and possibly other objects),
* then starts serving events from default event queue.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
sysinit();
rc = conf_register(&test_conf_handler);
assert(rc == 0);
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
stats_init(STATS_HDR(g_stats_gpio_toggle),
STATS_SIZE_INIT_PARMS(g_stats_gpio_toggle, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(gpio_stats));
stats_register("gpio_toggle", STATS_HDR(g_stats_gpio_toggle));
flash_test_init();
conf_load();
log_reboot(hal_reset_cause());
init_tasks();
/* If this app is acting as the loader in a split image setup, jump into
* the second stage application instead of starting the OS.
*/
#if MYNEWT_VAL(SPLIT_LOADER)
{
void *entry;
rc = split_app_go(&entry, true);
if(rc == 0) {
hal_system_restart(entry);
}
}
#endif
/*
* As the last thing, process events from default event queue.
*/
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this accellerometer
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
mpu6050_init(struct os_dev *dev, void *arg)
{
struct mpu6050 *mpu;
struct sensor *sensor;
int rc;
if (!arg || !dev) {
return SYS_ENODEV;
}
mpu = (struct mpu6050 *) dev;
mpu->cfg.mask = SENSOR_TYPE_ALL;
log_register(dev->od_name, &_log, &log_console_handler, NULL, LOG_SYSLEVEL);
sensor = &mpu->sensor;
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_mpu6050stats),
STATS_SIZE_INIT_PARMS(g_mpu6050stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(mpu6050_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register(dev->od_name, STATS_HDR(g_mpu6050stats));
SYSINIT_PANIC_ASSERT(rc == 0);
rc = sensor_init(sensor, dev);
if (rc) {
return rc;
}
/* Add the accelerometer/gyroscope driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_GYROSCOPE |
SENSOR_TYPE_ACCELEROMETER,
(struct sensor_driver *) &g_mpu6050_sensor_driver);
if (rc) {
return rc;
}
rc = sensor_set_interface(sensor, arg);
if (rc) {
return rc;
}
return sensor_mgr_register(sensor);
}
/**
* main
*
* The main task for the project. This function initializes the packages, calls
* init_tasks to initialize additional tasks (and possibly other objects),
* then starts serving events from default event queue.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
sysinit();
rc = conf_register(&test_conf_handler);
assert(rc == 0);
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
/* Initialize the OIC */
log_register("oic", &oc_log, &log_console_handler, NULL, LOG_SYSLEVEL);
stats_init(STATS_HDR(g_stats_gpio_toggle),
STATS_SIZE_INIT_PARMS(g_stats_gpio_toggle, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(gpio_stats));
stats_register("gpio_toggle", STATS_HDR(g_stats_gpio_toggle));
conf_load();
reboot_start(hal_reset_cause());
#if MYNEWT_VAL(SPLIT_LOADER)
{
void *entry;
rc = split_app_go(&entry, true);
if(rc == 0) {
hal_system_start(entry);
}
}
#endif
init_tasks();
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
/* Never returns */
return rc;
}
/**
* main
*
* The main function for the project. This function initializes the os, calls
* init_tasks to initialize tasks (and possibly other objects), then starts the
* OS. We should not return from os start.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
sysinit();
rc = conf_register(&test_conf_handler);
assert(rc == 0);
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
stats_init(STATS_HDR(g_stats_gpio_toggle),
STATS_SIZE_INIT_PARMS(g_stats_gpio_toggle, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(gpio_stats));
stats_register("gpio_toggle", STATS_HDR(g_stats_gpio_toggle));
conf_load();
log_reboot(HARD_REBOOT);
#if MYNEWT_VAL(SPLIT_LOADER)
{
void *entry;
rc = split_app_go(&entry, true);
if(rc == 0) {
hal_system_start(entry);
}
}
#endif
init_tasks();
os_start();
/* os start should never return. If it does, this should be an error */
assert(0);
return rc;
}
int
ble_att_init(void)
{
int rc;
ble_att_preferred_mtu = BLE_ATT_MTU_PREFERRED_DFLT;
rc = stats_init_and_reg(
STATS_HDR(ble_att_stats), STATS_SIZE_INIT_PARMS(ble_att_stats,
STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_att_stats), "ble_att");
if (rc != 0) {
return BLE_HS_EOS;
}
return 0;
}
/**
* ble phy init
*
* Initialize the PHY.
*
* @return int 0: success; PHY error code otherwise
*/
int
ble_phy_init(void)
{
int rc;
uint32_t os_tmo;
/* Make sure HFXO is started */
NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;
NRF_CLOCK->TASKS_HFCLKSTART = 1;
os_tmo = os_time_get() + (5 * (1000 / OS_TICKS_PER_SEC));
while (1) {
if (NRF_CLOCK->EVENTS_HFCLKSTARTED) {
break;
}
if ((int32_t)(os_time_get() - os_tmo) > 0) {
return BLE_PHY_ERR_INIT;
}
}
/* Set phy channel to an invalid channel so first set channel works */
g_ble_phy_data.phy_chan = BLE_PHY_NUM_CHANS;
/* Toggle peripheral power to reset (just in case) */
NRF_RADIO->POWER = 0;
NRF_RADIO->POWER = 1;
/* Disable all interrupts */
NRF_RADIO->INTENCLR = NRF_RADIO_IRQ_MASK_ALL;
/* Set configuration registers */
NRF_RADIO->MODE = RADIO_MODE_MODE_Ble_1Mbit;
NRF_RADIO->PCNF0 = (NRF_LFLEN_BITS << RADIO_PCNF0_LFLEN_Pos) |
RADIO_PCNF0_S1INCL_Msk |
(NRF_S0_LEN << RADIO_PCNF0_S0LEN_Pos) |
(RADIO_PCNF0_PLEN_8bit << RADIO_PCNF0_PLEN_Pos);
/* XXX: should maxlen be 251 for encryption? */
NRF_RADIO->PCNF1 = NRF_MAXLEN |
(RADIO_PCNF1_ENDIAN_Little << RADIO_PCNF1_ENDIAN_Pos) |
(NRF_BALEN << RADIO_PCNF1_BALEN_Pos) |
RADIO_PCNF1_WHITEEN_Msk;
/* Set base0 with the advertising access address */
NRF_RADIO->BASE0 = (BLE_ACCESS_ADDR_ADV << 8) & 0xFFFFFF00;
NRF_RADIO->PREFIX0 = (BLE_ACCESS_ADDR_ADV >> 24) & 0xFF;
/* Configure the CRC registers */
NRF_RADIO->CRCCNF = RADIO_CRCCNF_SKIPADDR_Msk | RADIO_CRCCNF_LEN_Three;
/* Configure BLE poly */
NRF_RADIO->CRCPOLY = 0x0100065B;
/* Configure IFS */
NRF_RADIO->TIFS = BLE_LL_IFS;
/* Captures tx/rx start in timer0 capture 1 */
NRF_PPI->CHENSET = PPI_CHEN_CH26_Msk;
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) == 1)
NRF_CCM->INTENCLR = 0xffffffff;
NRF_CCM->SHORTS = CCM_SHORTS_ENDKSGEN_CRYPT_Msk;
NRF_CCM->EVENTS_ERROR = 0;
memset(g_nrf_encrypt_scratchpad, 0, sizeof(g_nrf_encrypt_scratchpad));
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1)
g_ble_phy_data.phy_aar_scratch = 0;
NRF_AAR->IRKPTR = (uint32_t)&g_nrf_irk_list[0];
NRF_AAR->INTENCLR = 0xffffffff;
NRF_AAR->EVENTS_END = 0;
NRF_AAR->EVENTS_RESOLVED = 0;
NRF_AAR->EVENTS_NOTRESOLVED = 0;
NRF_AAR->NIRK = 0;
#endif
/* Set isr in vector table and enable interrupt */
NVIC_SetPriority(RADIO_IRQn, 0);
NVIC_SetVector(RADIO_IRQn, (uint32_t)ble_phy_isr);
NVIC_EnableIRQ(RADIO_IRQn);
/* Register phy statistics */
if (!g_ble_phy_data.phy_stats_initialized) {
rc = stats_init_and_reg(STATS_HDR(ble_phy_stats),
STATS_SIZE_INIT_PARMS(ble_phy_stats,
STATS_SIZE_32),
STATS_NAME_INIT_PARMS(ble_phy_stats),
"ble_phy");
assert(rc == 0);
g_ble_phy_data.phy_stats_initialized = 1;
}
return 0;
}
/**
* Initializes the host portion of the BLE stack.
*/
int
ble_hs_init(struct os_eventq *app_evq, struct ble_hs_cfg *cfg)
{
int rc;
ble_hs_free_mem();
if (app_evq == NULL) {
rc = BLE_HS_EINVAL;
goto err;
}
ble_hs_parent_evq = app_evq;
ble_hs_cfg_init(cfg);
log_init();
log_console_handler_init(&ble_hs_log_console_handler);
log_register("ble_hs", &ble_hs_log, &ble_hs_log_console_handler);
ble_hs_hci_cmd_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs,
HCI_CMD_BUF_SIZE));
if (ble_hs_hci_cmd_buf == NULL) {
rc = BLE_HS_ENOMEM;
goto err;
}
/* Create memory pool of command buffers */
rc = os_mempool_init(&g_hci_cmd_pool, ble_hs_cfg.max_hci_bufs,
HCI_CMD_BUF_SIZE, ble_hs_hci_cmd_buf,
"HCICmdPool");
assert(rc == 0);
ble_hs_hci_os_event_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs,
HCI_OS_EVENT_BUF_SIZE));
if (ble_hs_hci_os_event_buf == NULL) {
rc = BLE_HS_ENOMEM;
goto err;
}
/* Create memory pool of OS events */
rc = os_mempool_init(&g_hci_os_event_pool, ble_hs_cfg.max_hci_bufs,
HCI_OS_EVENT_BUF_SIZE, ble_hs_hci_os_event_buf,
"HCIOsEventPool");
assert(rc == 0);
/* Initialize eventq */
os_eventq_init(&ble_hs_evq);
/* Initialize stats. */
rc = stats_module_init();
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
ble_hci_cmd_init();
rc = ble_hs_conn_init();
if (rc != 0) {
goto err;
}
rc = ble_l2cap_init();
if (rc != 0) {
goto err;
}
rc = ble_att_init();
if (rc != 0) {
goto err;
}
rc = ble_att_svr_init();
if (rc != 0) {
goto err;
}
rc = ble_gap_init();
if (rc != 0) {
goto err;
}
rc = ble_gattc_init();
if (rc != 0) {
goto err;
}
rc = ble_gatts_init();
if (rc != 0) {
goto err;
}
os_mqueue_init(&ble_hs_rx_q, NULL);
os_mqueue_init(&ble_hs_tx_q, NULL);
rc = stats_init_and_reg(
STATS_HDR(ble_hs_stats), STATS_SIZE_INIT_PARMS(ble_hs_stats,
STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_hs_stats), "ble_hs");
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
os_callout_func_init(&ble_hs_heartbeat_timer, ble_hs_parent_evq,
ble_hs_heartbeat, NULL);
os_callout_func_init(&ble_hs_event_co, &ble_hs_evq,
ble_hs_event_handle, NULL);
rc = os_mutex_init(&ble_hs_mutex);
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
return 0;
err:
ble_hs_free_mem();
return rc;
}
/**
* Clear an asserted interrupt on the device
*
* @param The sensor interface
* @return 0 on success, non-zero on failure
*/
int
tsl2561_clear_interrupt(struct sensor_itf *itf)
{
int rc;
uint8_t payload = { TSL2561_COMMAND_BIT | TSL2561_CLEAR_BIT };
struct hal_i2c_master_data data_struct = {
.address = itf->si_addr,
.len = 1,
.buffer = &payload
};
/* To clear the interrupt set the CLEAR bit in the COMMAND register */
rc = hal_i2c_master_write(itf->si_num, &data_struct,
OS_TICKS_PER_SEC / 10, 1);
if (rc) {
goto err;
}
STATS_INC(g_tsl2561stats, ints_cleared);
return 0;
err:
return rc;
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this luminosity sensor
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
tsl2561_init(struct os_dev *dev, void *arg)
{
struct tsl2561 *tsl2561;
struct sensor *sensor;
int rc;
if (!arg || !dev) {
rc = SYS_ENODEV;
goto err;
}
tsl2561 = (struct tsl2561 *) dev;
tsl2561->cfg.mask = SENSOR_TYPE_ALL;
sensor = &tsl2561->sensor;
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_tsl2561stats),
STATS_SIZE_INIT_PARMS(g_tsl2561stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(tsl2561_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register(dev->od_name, STATS_HDR(g_tsl2561stats));
SYSINIT_PANIC_ASSERT(rc == 0);
rc = sensor_init(sensor, dev);
if (rc) {
goto err;
}
/* Add the light driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_LIGHT,
(struct sensor_driver *) &g_tsl2561_sensor_driver);
if (rc) {
goto err;
}
/* Set the interface */
rc = sensor_set_interface(sensor, arg);
if (rc) {
goto err;
}
rc = sensor_mgr_register(sensor);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
static uint32_t
tsl2561_calculate_lux(uint16_t broadband, uint16_t ir, struct tsl2561_cfg *cfg)
{
uint64_t chscale;
uint64_t channel1;
uint64_t channel0;
uint16_t clipthreshold;
uint64_t ratio1;
uint64_t ratio;
int64_t b, m;
uint64_t temp;
uint32_t lux;
/* Make sure the sensor isn't saturated! */
switch (cfg->integration_time) {
case TSL2561_LIGHT_ITIME_13MS:
clipthreshold = TSL2561_CLIPPING_13MS;
break;
case TSL2561_LIGHT_ITIME_101MS:
clipthreshold = TSL2561_CLIPPING_101MS;
break;
default:
clipthreshold = TSL2561_CLIPPING_402MS;
break;
}
/* Return 65536 lux if the sensor is saturated */
if ((broadband > clipthreshold) || (ir > clipthreshold)) {
return 65536;
}
/* Get the correct scale depending on the intergration time */
switch (cfg->integration_time) {
case TSL2561_LIGHT_ITIME_13MS:
chscale = TSL2561_LUX_CHSCALE_TINT0;
break;
case TSL2561_LIGHT_ITIME_101MS:
chscale = TSL2561_LUX_CHSCALE_TINT1;
break;
default: /* No scaling ... integration time = 402ms */
chscale = (1 << TSL2561_LUX_CHSCALE);
break;
}
/* Scale for gain (1x or 16x) */
if (!cfg->gain) {
chscale = chscale << 4;
}
/* Scale the channel values */
channel0 = (broadband * chscale) >> TSL2561_LUX_CHSCALE;
channel1 = (ir * chscale) >> TSL2561_LUX_CHSCALE;
ratio1 = 0;
/* Find the ratio of the channel values (Channel1/Channel0) */
if (channel0 != 0) {
ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE+1)) / channel0;
}
/* round the ratio value */
ratio = (ratio1 + 1) >> 1;
#if MYNEWT_VAL(TSL2561_PACKAGE_CS)
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C)) {
b = TSL2561_LUX_B1C;
m = TSL2561_LUX_M1C;
} else if (ratio <= TSL2561_LUX_K2C) {
b = TSL2561_LUX_B2C;
m = TSL2561_LUX_M2C;
} else if (ratio <= TSL2561_LUX_K3C) {
b = TSL2561_LUX_B3C;
m = TSL2561_LUX_M3C;
} else if (ratio <= TSL2561_LUX_K4C) {
b = TSL2561_LUX_B4C;
m = TSL2561_LUX_M4C;
} else if (ratio <= TSL2561_LUX_K5C) {
b = TSL2561_LUX_B5C;
m = TSL2561_LUX_M5C;
} else if (ratio <= TSL2561_LUX_K6C) {
b = TSL2561_LUX_B6C;
m = TSL2561_LUX_M6C;
} else if (ratio <= TSL2561_LUX_K7C) {
b = TSL2561_LUX_B7C;
m = TSL2561_LUX_M7C;
} else if (ratio > TSL2561_LUX_K8C) {
b = TSL2561_LUX_B8C;
m = TSL2561_LUX_M8C;
}
#else
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T)) {
b = TSL2561_LUX_B1T;
m = TSL2561_LUX_M1T;
} else if (ratio <= TSL2561_LUX_K2T) {
b = TSL2561_LUX_B2T;
m = TSL2561_LUX_M2T;
} else if (ratio <= TSL2561_LUX_K3T) {
b = TSL2561_LUX_B3T;
m = TSL2561_LUX_M3T;
} else if (ratio <= TSL2561_LUX_K4T) {
b = TSL2561_LUX_B4T;
m = TSL2561_LUX_M4T;
} else if (ratio <= TSL2561_LUX_K5T) {
b = TSL2561_LUX_B5T;
m = TSL2561_LUX_M5T;
} else if (ratio <= TSL2561_LUX_K6T) {
b = TSL2561_LUX_B6T;
m = TSL2561_LUX_M6T;
} else if (ratio <= TSL2561_LUX_K7T) {
b = TSL2561_LUX_B7T;
m = TSL2561_LUX_M7T;
} else if (ratio > TSL2561_LUX_K8T) {
b = TSL2561_LUX_B8T;
m = TSL2561_LUX_M8T;
}
#endif
temp = ((channel0 * b) - (channel1 * m));
/* Do not allow negative lux value */
if (temp < 0) {
temp = 0;
}
/* Round lsb (2^(LUX_SCALE-1)) */
temp += (1 << (TSL2561_LUX_LUXSCALE - 1));
/* Strip off fractional portion */
lux = temp >> TSL2561_LUX_LUXSCALE;
return lux;
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this accelerometer
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_init(struct os_dev *dev, void *arg)
{
struct lis2dw12 *lis2dw12;
struct sensor *sensor;
int rc;
if (!arg || !dev) {
rc = SYS_ENODEV;
goto err;
}
lis2dw12 = (struct lis2dw12 *) dev;
lis2dw12->cfg.mask = SENSOR_TYPE_ALL;
log_register(dev->od_name, &_log, &log_console_handler, NULL, LOG_SYSLEVEL);
sensor = &lis2dw12->sensor;
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_lis2dw12stats),
STATS_SIZE_INIT_PARMS(g_lis2dw12stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(lis2dw12_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register(dev->od_name, STATS_HDR(g_lis2dw12stats));
SYSINIT_PANIC_ASSERT(rc == 0);
rc = sensor_init(sensor, dev);
if (rc) {
goto err;
}
/* Add the light driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_ACCELEROMETER,
(struct sensor_driver *) &g_lis2dw12_sensor_driver);
if (rc) {
goto err;
}
/* Set the interface */
rc = sensor_set_interface(sensor, arg);
if (rc) {
goto err;
}
rc = sensor_mgr_register(sensor);
if (rc) {
goto err;
}
if (sensor->s_itf.si_type == SENSOR_ITF_SPI) {
rc = hal_spi_disable(sensor->s_itf.si_num);
if (rc) {
goto err;
}
rc = hal_spi_config(sensor->s_itf.si_num, &spi_lis2dw12_settings);
if (rc == EINVAL) {
/* If spi is already enabled, for nrf52, it returns -1, We should not
* fail if the spi is already enabled
*/
goto err;
}
rc = hal_spi_enable(sensor->s_itf.si_num);
if (rc) {
goto err;
}
rc = hal_gpio_init_out(sensor->s_itf.si_cs_pin, 1);
if (rc) {
goto err;
}
}
init_interrupt(&lis2dw12->intr, lis2dw12->sensor.s_itf.si_ints);
lis2dw12->pdd.notify_ctx.snec_sensor = sensor;
lis2dw12->pdd.registered_mask = 0;
lis2dw12->pdd.interrupt = NULL;
rc = init_intpin(lis2dw12, lis2dw12_int_irq_handler, sensor);
if (rc) {
return rc;
}
return 0;
err:
return rc;
}
/**
* Expects to be called back through os_dev_create().
*
* @param The device object associated with this accelerometer
* @param Argument passed to OS device init, unused
*
* @return 0 on success, non-zero error on failure.
*/
int
adxl345_init(struct os_dev *dev, void *arg)
{
struct adxl345 *adxl;
struct sensor *sensor;
int rc;
if (!arg || !dev) {
return SYS_ENODEV;
}
adxl = (struct adxl345 *) dev;
adxl->cfg.mask = SENSOR_TYPE_ALL;
log_register(dev->od_name, &_log, &log_console_handler, NULL, LOG_SYSLEVEL);
sensor = &adxl->sensor;
/* Initialise the stats entry */
rc = stats_init(
STATS_HDR(g_adxl345stats),
STATS_SIZE_INIT_PARMS(g_adxl345stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(adxl345_stat_section));
SYSINIT_PANIC_ASSERT(rc == 0);
/* Register the entry with the stats registry */
rc = stats_register(dev->od_name, STATS_HDR(g_adxl345stats));
SYSINIT_PANIC_ASSERT(rc == 0);
rc = sensor_init(sensor, dev);
if (rc) {
return rc;
}
/* Add the accelerometer/gyroscope driver */
rc = sensor_set_driver(sensor, SENSOR_TYPE_ACCELEROMETER,
(struct sensor_driver *) &adxl345_sensor_driver);
if (rc) {
return rc;
}
rc = sensor_set_interface(sensor, arg);
if (rc) {
return rc;
}
rc = sensor_mgr_register(sensor);
if (rc) {
return rc;
}
if (sensor->s_itf.si_type == SENSOR_ITF_SPI) {
rc = hal_spi_config(sensor->s_itf.si_num, &spi_adxl345_settings);
if (rc == EINVAL) {
return rc;
}
rc = hal_spi_enable(sensor->s_itf.si_num);
if (rc) {
return rc;
}
rc = hal_gpio_init_out(sensor->s_itf.si_cs_pin, 1);
if (rc) {
return rc;
}
}
#if MYNEWT_VAL(ADXL345_INT_ENABLE)
adxl->pdd.read_ctx.srec_sensor = sensor;
adxl->pdd.notify_ctx.snec_sensor = sensor;
rc = init_intpin(adxl, interrupt_handler, sensor);
if (rc != 0) {
return rc;
}
#endif
return 0;
}
/**
* Initialize the Link Layer. Should be called only once
*
* @return int
*/
void
ble_ll_init(void)
{
int rc;
uint8_t features;
struct ble_ll_obj *lldata;
/* Get pointer to global data object */
lldata = &g_ble_ll_data;
/* Set acl pkt size and number */
lldata->ll_num_acl_pkts = MYNEWT_VAL(BLE_ACL_BUF_COUNT);
lldata->ll_acl_pkt_size = MYNEWT_VAL(BLE_ACL_BUF_SIZE);
/* Initialize eventq */
os_eventq_init(&lldata->ll_evq);
/* Initialize the transmit (from host) and receive (from phy) queues */
STAILQ_INIT(&lldata->ll_tx_pkt_q);
STAILQ_INIT(&lldata->ll_rx_pkt_q);
/* Initialize transmit (from host) and receive packet (from phy) event */
lldata->ll_rx_pkt_ev.ev_cb = ble_ll_event_rx_pkt;
lldata->ll_tx_pkt_ev.ev_cb = ble_ll_event_tx_pkt;
lldata->ll_dbuf_overflow_ev.ev_cb = ble_ll_event_dbuf_overflow;
/* Initialize the HW error timer */
os_callout_init(&g_ble_ll_data.ll_hw_err_timer,
&g_ble_ll_data.ll_evq,
ble_ll_hw_err_timer_cb,
NULL);
/* Initialize wait for response timer */
os_cputime_timer_init(&g_ble_ll_data.ll_wfr_timer, ble_ll_wfr_timer_exp,
NULL);
ble_ll_hci_os_event_buf = malloc(
OS_MEMPOOL_BYTES(16, sizeof (struct os_event)));
SYSINIT_PANIC_ASSERT(ble_ll_hci_os_event_buf != NULL);
/* Create memory pool of OS events */
rc = os_mempool_init(&g_ble_ll_hci_ev_pool, 16,
sizeof (struct os_event), ble_ll_hci_os_event_buf,
"g_ble_ll_hci_ev_pool");
SYSINIT_PANIC_ASSERT(rc == 0);
/* Initialize LL HCI */
ble_ll_hci_init();
/* Init the scheduler */
ble_ll_sched_init();
/* Initialize advertiser */
ble_ll_adv_init();
/* Initialize a scanner */
ble_ll_scan_init();
/* Initialize the connection module */
ble_ll_conn_module_init();
/* Set the supported features. NOTE: we always support extended reject. */
features = BLE_LL_FEAT_EXTENDED_REJ;
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) == 1)
features |= BLE_LL_FEAT_DATA_LEN_EXT;
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_CONN_PARAM_REQ) == 1)
features |= BLE_LL_FEAT_CONN_PARM_REQ;
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_SLAVE_INIT_FEAT_XCHG) == 1)
features |= BLE_LL_FEAT_SLAVE_INIT;
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) == 1)
features |= BLE_LL_FEAT_LE_ENCRYPTION;
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1)
features |= (BLE_LL_FEAT_LL_PRIVACY | BLE_LL_FEAT_EXT_SCAN_FILT);
ble_ll_resolv_init();
#endif
#if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) == 1)
features |= BLE_LL_FEAT_LE_PING;
#endif
/* Initialize random number generation */
ble_ll_rand_init();
/* XXX: This really doesn't belong here, as the address probably has not
* been set yet.
*/
ble_ll_seed_prng();
lldata->ll_supp_features = features;
/* Initialize the LL task */
os_task_init(&g_ble_ll_task, "ble_ll", ble_ll_task, NULL,
MYNEWT_VAL(BLE_LL_PRIO), OS_WAIT_FOREVER, g_ble_ll_stack,
BLE_LL_STACK_SIZE);
rc = stats_init_and_reg(STATS_HDR(ble_ll_stats),
STATS_SIZE_INIT_PARMS(ble_ll_stats, STATS_SIZE_32),
STATS_NAME_INIT_PARMS(ble_ll_stats),
"ble_ll");
SYSINIT_PANIC_ASSERT(rc == 0);
ble_hci_trans_cfg_ll(ble_ll_hci_cmd_rx, NULL, ble_ll_hci_acl_rx, NULL);
}