/**************************************************************************** * drivers/sensors/bh1749nuc_uorb.c * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. The * ASF licenses this file to you 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. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include "bh1749nuc_base.h" /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /**************************************************************************** * Private Type Definitions ****************************************************************************/ enum bh1749nuc_idx_e { BH1749NUC_RGB_IDX = 0, BH1749NUC_IR_IDX, BH1749NUC_MAX_IDX }; struct bh1749nuc_sensor_dev_s; struct bh1749nuc_sensor_s { struct sensor_lowerhalf_s lower; int gain; FAR struct bh1749nuc_sensor_dev_s *dev; #ifdef CONFIG_SENSORS_BH1749NUC_POLL uint32_t interval; uint64_t last_update; #endif bool enabled; }; struct bh1749nuc_sensor_dev_s { struct bh1749nuc_sensor_s priv[BH1749NUC_MAX_IDX]; struct bh1749nuc_dev_s dev; float scale_r; float scale_g; float scale_b; float scale_ir; mutex_t lock; #ifdef CONFIG_SENSORS_BH1749NUC_POLL sem_t run; #endif }; /**************************************************************************** * Private Function Prototypes ****************************************************************************/ static int bh1749nuc_activate(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, bool enable); #ifndef CONFIG_SENSORS_BH1749NUC_POLL static int bh1749nuc_fetch(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, FAR char *buffer, size_t buflen); #endif static int bh1749nuc_set_interval(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, FAR uint32_t *period_us); static int bh1749nuc_control(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, int cmd, unsigned long arg); /**************************************************************************** * Private Data ****************************************************************************/ static const struct sensor_ops_s g_bh1749nuc_sensor_ops = { NULL, /* open */ NULL, /* close */ bh1749nuc_activate, bh1749nuc_set_interval, NULL, /* batch */ #ifdef CONFIG_SENSORS_BH1749NUC_POLL NULL, /* fetch */ #else bh1749nuc_fetch, #endif NULL, /* flush */ NULL, /* selftest */ NULL, /* set_calibvalue */ NULL, /* calibrate */ NULL, /* get_info */ bh1749nuc_control }; /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Name: bh1749nuc_activate ****************************************************************************/ static int bh1749nuc_activate(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, bool enable) { FAR struct bh1749nuc_sensor_s *priv = NULL; FAR struct bh1749nuc_dev_s *dev = NULL; uint8_t val = 0; #ifdef CONFIG_SENSORS_BH1749NUC_POLL bool start_thread = false; #endif /* Get dev */ priv = (FAR struct bh1749nuc_sensor_s *)lower; dev = &priv->dev->dev; nxmutex_lock(&priv->dev->lock); if (enable) { #ifdef CONFIG_SENSORS_BH1749NUC_POLL if (!priv->enabled) { start_thread = true; priv->last_update = sensor_get_timestamp(); } #endif /* MODE_CONTROL1 */ val = (BH1749NUC_MODE_CONTROL1_MEAS_TIME160MS | BH1749NUC_MODE_CONTROL1_IR_GAIN_X1 | BH1749NUC_MODE_CONTROL1_RGB_GAIN_X1); bh1749nuc_putreg8(dev, BH1749NUC_MODE_CONTROL1, val); /* MODE_CONTROL2 */ val = BH1749NUC_MODE_CONTROL2_RGBI_EN; bh1749nuc_putreg8(dev, BH1749NUC_MODE_CONTROL2, val); } else { /* Stop sampling */ val = 0; bh1749nuc_putreg8(dev, BH1749NUC_MODE_CONTROL2, val); } priv->enabled = enable; #ifdef CONFIG_SENSORS_BH1749NUC_POLL if (start_thread) { /* Wake up the thread */ nxsem_post(&priv->dev->run); } #endif nxmutex_unlock(&priv->dev->lock); return OK; } #ifndef CONFIG_SENSORS_BH1749NUC_POLL /**************************************************************************** * Name: bh1749nuc_fetch ****************************************************************************/ static int bh1749nuc_fetch(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, FAR char *buffer, size_t buflen) { FAR struct bh1749nuc_sensor_s *priv = NULL; FAR struct bh1749nuc_dev_s *dev = NULL; struct sensor_rgb rgb_data; struct sensor_ir ir_data; uint16_t tmp = 0; uint64_t now = sensor_get_timestamp(); int ret = 0; /* Get dev */ priv = (FAR struct bh1749nuc_sensor_s *)lower; dev = &priv->dev->dev; nxmutex_lock(&priv->dev->lock); if (!priv->enabled) { ret = -EACCES; goto errout; } /* Get data without wait for VALID flag - otherwise the sensor freezes * when we read RBG and IR data one after another */ if (lower->type == SENSOR_TYPE_RGB) { if (buflen != sizeof(rgb_data)) { ret = -EINVAL; goto errout; } rgb_data.timestamp = now; tmp = bh1749nuc_read16(dev, BH1749NUC_RED_DATA_LSB); rgb_data.r = (tmp * priv->dev->scale_r); tmp = bh1749nuc_read16(dev, BH1749NUC_GREEN_DATA_LSB); rgb_data.g = (tmp * priv->dev->scale_g); tmp = bh1749nuc_read16(dev, BH1749NUC_BLUE_DATA_LSB); rgb_data.b = (tmp * priv->dev->scale_b); memcpy(buffer, &rgb_data, sizeof(rgb_data)); ret = sizeof(rgb_data); } else if (lower->type == SENSOR_TYPE_IR) { if (buflen != sizeof(ir_data)) { ret = -EINVAL; goto errout; } ir_data.timestamp = now; tmp = bh1749nuc_read16(dev, BH1749NUC_IR_DATA_LSB); ir_data.ir = (tmp * priv->dev->scale_ir); memcpy(buffer, &ir_data, sizeof(ir_data)); ret = sizeof(ir_data); } errout: nxmutex_unlock(&priv->dev->lock); return ret; } #endif /**************************************************************************** * Name: bh1749nuc_cotrol ****************************************************************************/ static int bh1749nuc_control(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, int cmd, unsigned long arg) { FAR struct bh1749nuc_sensor_s *priv = NULL; int ret = OK; priv = (FAR struct bh1749nuc_sensor_s *)lower; UNUSED(priv); switch (cmd) { default: { snerr("ERROR: Unrecognized cmd: %d\n", cmd); ret = -ENOTTY; break; } } return ret; } /**************************************************************************** * Name: bh1749nuc_set_interval ****************************************************************************/ static int bh1749nuc_set_interval(FAR struct sensor_lowerhalf_s *lower, FAR struct file *filep, FAR uint32_t *interval) { #ifdef CONFIG_SENSORS_BH1749NUC_POLL FAR struct bh1749nuc_sensor_s *priv = NULL; priv = (FAR struct bh1749nuc_sensor_s *)lower; priv->interval = *interval; #endif return OK; } #ifdef CONFIG_SENSORS_BH1749NUC_POLL /**************************************************************************** * Name: bh1749nuc_thread * * Description: Thread for performing interval measurement cycle and data * read. * * Parameter: * argc - Number opf arguments * argv - Pointer to argument list * ****************************************************************************/ static int bh1749nuc_thread(int argc, FAR char **argv) { FAR struct bh1749nuc_sensor_dev_s *dev = (FAR struct bh1749nuc_sensor_dev_s *)((uintptr_t)strtoul(argv[1], NULL, 16)); FAR struct bh1749nuc_sensor_s *rgb = &dev->priv[BH1749NUC_RGB_IDX]; FAR struct bh1749nuc_sensor_s *ir = &dev->priv[BH1749NUC_IR_IDX]; struct sensor_rgb rgb_data; struct sensor_ir ir_data; uint64_t min_interval; uint16_t tmp = 0; uint64_t now = sensor_get_timestamp(); int ret = 0; while (true) { if ((!rgb->enabled) && (!ir->enabled)) { /* Waiting to be woken up */ ret = nxsem_wait(&dev->run); if (ret < 0) { continue; } } /* Wait for data */ while (!(bh1749nuc_getreg8(&dev->dev, BH1749NUC_MODE_CONTROL2) & BH1749NUC_MODE_CONTROL2_VALID)); /* Get timestamp */ now = sensor_get_timestamp(); if (rgb->enabled) { rgb_data.timestamp = now; tmp = bh1749nuc_read16(&dev->dev, BH1749NUC_RED_DATA_LSB); rgb_data.r = (tmp * dev->scale_r); tmp = bh1749nuc_read16(&dev->dev, BH1749NUC_GREEN_DATA_LSB); rgb_data.g = (tmp * dev->scale_g); tmp = bh1749nuc_read16(&dev->dev, BH1749NUC_BLUE_DATA_LSB); rgb_data.b = (tmp * dev->scale_b); rgb->lower.push_event(rgb->lower.priv, &rgb_data, sizeof(rgb_data)); } if (ir->enabled) { ir_data.timestamp = now; tmp = bh1749nuc_read16(&dev->dev, BH1749NUC_IR_DATA_LSB); ir_data.ir = (tmp * dev->scale_ir); ir->lower.push_event(ir->lower.priv, &ir_data, sizeof(ir_data)); } /* Sleeping thread before fetching the next sensor data */ min_interval = MIN(rgb->interval, ir->interval); nxsig_usleep(min_interval); } return OK; } #endif /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: bh1749nuc_register_uorb * * Description: * Register the BH1749NUC uorb device as 'devpath' * * Input Parameters: * devno - The user specifies device number, from 0. * config - device configuration * * Returned Value: * Zero (OK) on success; a negated errno value on failure. * ****************************************************************************/ int bh1749nuc_register_uorb(int devno, FAR struct bh1749nuc_config_s *config) { FAR struct bh1749nuc_sensor_dev_s *dev = NULL; FAR struct bh1749nuc_sensor_s *tmp = NULL; int ret = OK; #ifdef CONFIG_SENSORS_BH1749NUC_POLL FAR char *argv[2]; char arg1[32]; #endif /* Without config info, we can't do anything. */ if (config == NULL) { return -EINVAL; } /* Initialize the device structure. */ dev = kmm_malloc(sizeof(struct bh1749nuc_sensor_dev_s)); if (dev == NULL) { snerr("ERROR: Failed to allocate bh1749nuc device instance\n"); return -ENOMEM; } memset(dev, 0, sizeof(struct bh1749nuc_sensor_dev_s)); nxmutex_init(&dev->lock); #ifdef CONFIG_SENSORS_BH1749NUC_POLL nxsem_init(&dev->run, 0, 0); #endif /* Configure dev */ dev->dev.i2c = config->i2c; dev->dev.addr = config->addr; dev->dev.freq = CONFIG_BH1749NUC_I2C_FREQUENCY; /* Check Device ID */ ret = bh1749nuc_checkid(&dev->dev); if (ret < 0) { snerr("Failed to register driver: %d\n", ret); return ret; } /* Return data in lux unit for RGB and IR */ dev->scale_r = (20.0f / 71.0f) * (1e-6 / 1.46e-7); dev->scale_g = (20.0f / 99.0f) * (1e-6 / 1.46e-7); dev->scale_b = (20.0f / 70.0f) * (1e-6 / 1.46e-7); dev->scale_ir = (20.0f / 25.0f) * (1e-6 / 1.46e-7); /* Register sensor */ tmp = &dev->priv[BH1749NUC_RGB_IDX]; tmp->lower.type = SENSOR_TYPE_RGB; tmp->lower.ops = &g_bh1749nuc_sensor_ops; tmp->dev = dev; tmp->gain = 1; #ifdef CONFIG_SENSORS_BH1749NUC_POLL tmp->enabled = false; tmp->interval = CONFIG_SENSORS_BH1749NUC_POLL_INTERVAL; #endif ret = sensor_register(&tmp->lower, devno); if (ret < 0) { goto rgb_err; } /* Register sensor */ tmp = &dev->priv[BH1749NUC_IR_IDX]; tmp->lower.type = SENSOR_TYPE_IR; tmp->lower.ops = &g_bh1749nuc_sensor_ops; tmp->dev = dev; tmp->gain = 1; #ifdef CONFIG_SENSORS_BH1749NUC_POLL tmp->enabled = false; tmp->interval = CONFIG_SENSORS_BH1749NUC_POLL_INTERVAL; #endif ret = sensor_register(&tmp->lower, devno); if (ret < 0) { goto ir_err; } /* SW Reset */ bh1749nuc_putreg8(&dev->dev, BH1749NUC_SYSTEM_CONTROL, BH1749NUC_SYSTEM_CONTROL_SW_RESET); #ifdef CONFIG_SENSORS_BH1749NUC_POLL /* Create thread for polling sensor data */ snprintf(arg1, 16, "%p", dev); argv[0] = arg1; argv[1] = NULL; ret = kthread_create("bh1749nuc_thread", SCHED_PRIORITY_DEFAULT, CONFIG_SENSORS_BH1749NUC_THREAD_STACKSIZE, bh1749nuc_thread, argv); if (ret < 0) { goto thr_err; } #endif return ret; #ifdef CONFIG_SENSORS_BH1749NUC_POLL thr_err: #endif sensor_unregister(&dev->priv[BH1749NUC_IR_IDX].lower, devno); ir_err: sensor_unregister(&dev->priv[BH1749NUC_RGB_IDX].lower, devno); rgb_err: kmm_free(dev); return ret; }