nuttx/drivers/sensors/ds18b20.c

/****************************************************************************
 * drivers/sensors/ds18b20.c
 * Character driver for DS18B20 Digital Humidity and Temperature Module.
 *
 * 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 <nuttx/config.h>

#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#include <nuttx/kmalloc.h>
#include <nuttx/kthread.h>
#include <nuttx/signal.h>
#include <nuttx/semaphore.h>
#include <nuttx/fs/fs.h>
#include <nuttx/1wire/1wire.h>
#include <nuttx/1wire/1wire_master.h>
#include <nuttx/1wire/1wire_crc.h>
#include <nuttx/sensors/ds18b20.h>
#include <nuttx/sensors/sensor.h>

#if defined(CONFIG_1WIRE) && defined(CONFIG_SENSORS_DS18B20)

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#ifndef CONFIG_ENDIAN_BIG
#  define ds18b20_leuint64(x) (x)
#endif

/* Scratchpad data definition for reading */

#define DS18B20_SPAD_LSB_OFFSET       0
#define DS18B20_SPAD_MSB_OFFSET       1
#define DS18B20_SPAD_TH_OFFSET        2
#define DS18B20_SPAD_TL_OFFSET        3
#define DS18B20_SPAD_RES_OFFSET       4
#define DS18B20_SPAD_CRC_OFFSET       9
#define DS18B20_SPAD_SIZE             9

/* Scratchpad data definition for writing */

#define DS18B20_WSPAD_CMD_OFFSET       0
#define DS18B20_WSPAD_TH_OFFSET        0
#define DS18B20_WSPAD_TL_OFFSET        1
#define DS18B20_WSPAD_RES_OFFSET       2
#define DS18B20_WSPAD_SIZE             3

/* Measurement resolution bit definition */

#define DS18B20_RESMIN                 0
#define DS18B20_RESMAX                 3
#define DS18B20_NRES                   DS18B20_RESMAX - DS18B20_RESMIN + 1

#define DS18B20_RES_VAL(x)             (((x) >> 5) & 0x3)
#define DS18B20_RES_CONV(x)            (((x) & 0x3) << 5)

/* Measurement timneout offset */

#define DS18B20_TIMEOUT_OFFSET(x)      (DS18B20_RESMAX - (x))

/* Default alarm temperature */

#define DS18B20_TALARM_MIN             -55
#define DS18B20_TALARM_MAX             125

/* Helper for getting data from scratchpad memory */

#define DS18B20_TEMP_PREDEC(lsb, msb)  (int8_t)(((msb) << 4) | ((lsb) >> 4))
#define DS18B20_TEMP_RES(lsb, res)     (DS18B20_RESMAX - DS18B20_RES_VAL(res))
#define DS18B20_TEMP_RESMASK(lsb, res) (0x0f << DS18B20_TEMP_RES(lsb, res))
#define DS18B20_TEMP_DEC(lsb, res)     (((lsb) & 0x0f) & \
                                       DS18B20_TEMP_RESMASK(lsb, res))
#define DS18B20_TEMP(lsb, msb, res)    (DS18B20_TEMP_PREDEC(lsb, msb) + \
                                        DS18B20_TEMP_DEC(lsb, res) / 16.0)

/****************************************************************************
 * Private Types
 ****************************************************************************/

/* Internal sensor data */

struct ds18b20_sensor_data_s
{
  uint64_t timestamp;
  uint8_t  spad[DS18B20_SPAD_SIZE];
};

/* User configuration register */

struct ds18b20_config_s
{
  uint8_t res;                           /* Sensor resolution */
  struct ds18b20_alarm_s alarm;          /* Sensor temperature alarm */
};

/* Callback handling for alarm detection */

struct ds18b20_cb_alarm_s
{
  bool     isalarm;
  uint64_t romcode;
};

/* Lower sensor */

struct ds18b20_sensor_s
{
  struct sensor_lowerhalf_s lower;       /* Common lower interface */
#ifdef CONFIG_SENSORS_DS18B20_POLL
  bool                      enabled;     /* Sensor activated */
#endif
};

/* Internal device */

struct ds18b20_dev_s
{
  struct ds18b20_sensor_s     sensor;         /* Sensor  */
  FAR struct onewire_master_s *master;        /* 1wire master interface */
  struct onewire_config_s     config;         /* 1wire device configuration */
  struct ds18b20_config_s     reg;            /* Sensor resolution */
#ifdef CONFIG_SENSORS_DS18B20_POLL
  unsigned int                interval;       /* Polling interval */
  sem_t                       run;            /* Locks sensor thread */
#endif
};

/****************************************************************************
 * Private Function Prototypes
 ****************************************************************************/

/* Sensor functions */

static int ds18b20_active(FAR struct sensor_lowerhalf_s *lower,
                          unsigned char enabled);

static int ds18b20_fetch(FAR struct sensor_lowerhalf_s *lower,
                         FAR char *buffer, size_t buflen);

static int ds18b20_control(FAR struct sensor_lowerhalf_s *lower,
                           int cmd, unsigned long arg);

#ifdef CONFIG_SENSORS_DS18B20_POLL
static int ds18b20_set_interval(FAR struct sensor_lowerhalf_s *lower,
                                FAR unsigned int *period_us);
#endif

/****************************************************************************
 * Private Data
 ****************************************************************************/

/* Timeout definitions after measurement according to the data sheet */

static const uint32_t g_res_timeout[DS18B20_NRES] =
{
  93750,
  187500,
  375000,
  750000
};

static const struct sensor_ops_s g_ds18b20_ops =
{
#ifdef CONFIG_SENSORS_DS18B20_POLL
  .set_interval = ds18b20_set_interval,
#endif
  .activate     = ds18b20_active,
  .fetch        = ds18b20_fetch,
  .control      = ds18b20_control
};

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: ds18b20_rawdata
 *
 * Description:
 *   Helper for extract temperature data from scratchpad
 *
 * Return:
 *   Raw temperature data
 *
 ****************************************************************************/

static inline int16_t ds18b20_rawtemp(FAR const uint8_t *spad)
{
  return (spad[DS18B20_SPAD_LSB_OFFSET] |
          (spad[DS18B20_SPAD_MSB_OFFSET] << 8));
}

/****************************************************************************
 * Name: ds18b20_tempdata
 *
 * Description:
 *   Helper for converting temperatur data from raw sensor data
 *
 * Return:
 *   Temperature data
 *
 ****************************************************************************/

static inline float ds18b20_temp(FAR const uint8_t *spad)
{
  int8_t predec = DS18B20_TEMP_PREDEC(spad[DS18B20_SPAD_LSB_OFFSET],
                                      spad[DS18B20_SPAD_MSB_OFFSET]);
  uint8_t dec   = DS18B20_TEMP_DEC(spad[DS18B20_SPAD_LSB_OFFSET],
                                   spad[DS18B20_SPAD_RES_OFFSET]);

  return predec + dec / 16.0;
}

/****************************************************************************
 * Name: ds18b20_alarm_cb
 *
 * Description:
 *   Call back function for searching a single alarm device.
 *
 * Input Parameters:
 *   romcode - Unique romcode of a device with alarm flag set
 *   arg     - Pointer to struct onewire_alarm_s
 *
 ****************************************************************************/

#ifdef CONFIG_SENSORS_DS18B20_POLL
static void ds18b20_alarm_cb(int family, uint64_t romcode, FAR void *arg)
{
  FAR struct ds18b20_cb_alarm_s *priv = (FAR struct ds18b20_cb_alarm_s *)arg;

  if (romcode == priv->romcode)
    {
      priv->isalarm = true;
    }
}
#endif

/****************************************************************************
 * Name: ds18b20_isalarm
 *
 * Description:
 *   Check if a 1wire device has set the alarm flag in an atomic operation.
 *
 * Input Parameters:
 *   master  - Pointer to the allocated 1-wire interface
 *   config  - Described the 1WIRE configuration
 *
 * Return Value:
 *   0   - no alarm flag is set
 *   1   - alarm flag is set
 *   < 0 - in case of error
 *
 ****************************************************************************/

#ifdef CONFIG_SENSORS_DS18B20_POLL
static int ds18b20_isalarm(FAR struct onewire_master_s *master,
                           FAR const struct onewire_config_s *config)
{
  int ret;
  struct ds18b20_cb_alarm_s alarm;
  alarm.romcode = config->romcode;
  alarm.isalarm = false;

  ret = onewire_search(master, DS18B20_DEVICE_FAMILY, true, ds18b20_alarm_cb,
                       &alarm);
  if (ret > 0)
    {
      /* Check if our device is in the alarm list */

      if (alarm.isalarm == true)
        {
          ret = 1;
        }
      else
        {
          /* Device found, but not our */

          ret = 0;
        }
    }

  return ret;
}
#endif

/****************************************************************************
 * Name: ds18b20_measure
 *
 * Description: Perform a measurement
 *
 * Parameter:
 *   dev - Internal private lower half driver instance
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_measure(FAR struct ds18b20_dev_s *dev)
{
  int ret;
  uint8_t buf = DS18B20_CMD_CONVERTT;

  ret = onewire_write(dev->master, &dev->config, &buf, 1);
  if (ret < 0)
    {
      snerr("ERROR: Unable to perform a temperature measurement\n");
      return ret;
    }

  return OK;
}

/****************************************************************************
 * Name: ds18b20_write_spad
 *
 * Description: Write scratchpad data to chip
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   th   - High alarm temperature
 *   lh   - Low alarm temperature
 *   res  - Temperature resolution
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_write_spad(FAR struct ds18b20_dev_s *dev, int8_t th,
                              int8_t tl, uint8_t res)
{
  int ret;
  uint8_t wbuf[DS18B20_WSPAD_SIZE + 1];

  wbuf[DS18B20_WSPAD_CMD_OFFSET]     = ONEWIRE_CMD_WRITE_SCRATCHPAD;
  wbuf[DS18B20_WSPAD_TH_OFFSET + 1]  = th;
  wbuf[DS18B20_WSPAD_TL_OFFSET + 1]  = tl;
  wbuf[DS18B20_WSPAD_RES_OFFSET + 1] = res;

  ret = onewire_write(dev->master, &dev->config, wbuf, sizeof(wbuf));
  if (ret < 0)
    {
      snerr("ERROR: Unable to write scratchpad\n");
    }

  return ret;
}

/****************************************************************************
 * Name: ds18b20_read_spad
 *
 * Description: Read scratchpad data from chip
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   spad - Pointer to store the scratchpad data
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_read_spad(FAR struct ds18b20_dev_s *dev,
                             FAR uint8_t *spad)
{
  int ret;
  uint8_t crc;
  uint8_t wbuf = ONEWIRE_CMD_READ_SCRATCHPAD;
  FAR struct ds18b20_config_s *reg = &dev->reg;

  ret = onewire_writeread(dev->master, &dev->config, &wbuf, 1, spad,
                          DS18B20_SPAD_SIZE);
  if (ret < 0)
    {
      snerr("ERROR: Unable to read scratchpad\n");
      return ret;
    }

  crc = onewire_crc8(spad, DS18B20_SPAD_SIZE - 1);
  if (crc != spad[DS18B20_SPAD_CRC_OFFSET - 1])
    {
      snerr("ERROR: crc mismatch in scratchpad\n");
      return -EIO;
    }

  /* Update configurable register state each time reading the scratchpad */

  reg->res = spad[DS18B20_SPAD_RES_OFFSET];

  if (reg->res < DS18B20_RES_CONV(DS18B20_RESMIN) ||
      reg->res > DS18B20_RES_CONV(reg->res))
    {
      /* Usually this should not happen, but be sure that we did not run into
       * a buffer overflow later.
       */

      swarn("WARNING: Sensor responsed unknown resolution: %d\n", reg->res);
      reg->res = DS18B20_RES_CONV(DS18B20_RESMAX);
    }

  reg->alarm.thigh = spad[DS18B20_SPAD_TH_OFFSET];
  reg->alarm.tlow  = spad[DS18B20_SPAD_TL_OFFSET];

  return OK;
}

/****************************************************************************
 * Name: ds18b20_set_res
 *
 * Description: Set resolution for temperature measurement
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   res  - Resolution, can be 9 to 12 bit
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_set_res(FAR struct ds18b20_dev_s *dev, uint8_t res)
{
  int ret;
  uint8_t spad[DS18B20_SPAD_SIZE];

  /* Read current scratchpad first */

  ret = ds18b20_read_spad(dev, spad);
  if (ret < 0)
    {
      return ret;
    }

  ret = ds18b20_write_spad(dev, dev->reg.alarm.thigh, dev->reg.alarm.tlow,
                           res);
  if (ret < 0)
    {
      return ret;
    }

  /* Read current scratchpad again and verify that res is set */

  ret = ds18b20_read_spad(dev, spad);
  if (ret < 0)
    {
      return ret;
    }

  if (DS18B20_RES_VAL(spad[DS18B20_SPAD_RES_OFFSET]) != DS18B20_RES_VAL(res))
    {
      snerr("ERROR: Expected resolution not matched, received RES: %d\n",
            spad[DS18B20_SPAD_RES_OFFSET]);
      return -EIO;
    }

  return OK;
}

/****************************************************************************
 * Name: ds18b20_set_alarm
 *
 * Description: Set temperature alarm
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   alarm - Pointer to store the alarm temperature
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_set_alarm(FAR struct ds18b20_dev_s *dev,
                             FAR const struct ds18b20_alarm_s *alarm)
{
  int ret;
  uint8_t spad[DS18B20_SPAD_SIZE];

  /* Read current scratchpad first, to get current resolution */

  ret = ds18b20_read_spad(dev, spad);
  if (ret < 0)
    {
      return ret;
    }

  ret = ds18b20_write_spad(dev, alarm->thigh, alarm->tlow, dev->reg.res);
  if (ret < 0)
    {
      return ret;
    }

#ifdef CONFIG_SENSORS_DS18B20_POLL
    dev->reg.alarm.wakeup = alarm->wakeup;
#endif

  /* Read current scratchpad again and verify that alarm is set */

  ret = ds18b20_read_spad(dev, spad);
  if (ret < 0)
    {
      return ret;
    }

  if (spad[DS18B20_SPAD_TH_OFFSET] != alarm->thigh ||
      spad[DS18B20_SPAD_TL_OFFSET] != alarm->tlow)
    {
      snerr("ERROR: Expected alarm trigger does not match, " \
            "received TH: %d, TL: %d\n",
            spad[DS18B20_SPAD_TH_OFFSET],
            spad[DS18B20_SPAD_TL_OFFSET]);
      return -EIO;
    }

  return ret;
}

/****************************************************************************
 * Name: ds18b20_curtime
 *
 * Description: Helper to get current timestamp.
 *
 * Return:
 *   Timestamp in nsec
 ****************************************************************************/

static unsigned long ds18b20_curtime(void)
{
  struct timespec ts;
#ifdef CONFIG_CLOCK_MONOTONIC
  clock_gettime(CLOCK_MONOTONIC, &ts);
#else
  clock_gettime(CLOCK_REALTIME, &ts);
#endif

  return 1000000ull * ts.tv_sec + ts.tv_nsec / 1000;
}

/****************************************************************************
 * Name: ds18b20_notify
 *
 * Description:
 *   Notify upper about data has been changed.
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   data - Read sensor data
 *
 ****************************************************************************/

#ifdef CONFIG_SENSORS_DS18B20_POLL
static void ds18b20_notify(FAR struct ds18b20_dev_s *dev,
                           FAR struct ds18b20_sensor_data_s *data)
{
  FAR struct ds18b20_sensor_s *sensor = &dev->sensor;
  struct sensor_event_temp temp;

  temp.temperature = ds18b20_temp(data->spad);
  temp.timestamp   = data->timestamp;
  sensor->lower.push_event(sensor->lower.priv, &temp,
                           sizeof(struct sensor_event_temp));
}
#endif

/****************************************************************************
 * Name: ds18b20_measure_read
 *
 * Description: Perform a measurement and read last measured temperature
 *
 * Parameter:
 *   dev  - Internal private lower half driver instance
 *   data - Pointer to store sensor data
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_measure_read(FAR struct ds18b20_dev_s *dev,
                                FAR struct ds18b20_sensor_data_s *data)
{
  int ret;

  ret = ds18b20_measure(dev);
  if (ret < 0)
    {
      return ret;
    }

  nxsig_usleep(g_res_timeout[DS18B20_RES_VAL(dev->reg.res)]);

  ret = ds18b20_read_spad(dev, data->spad);
  if (ret < 0)
    {
      return ret;
    }

  data->timestamp = ds18b20_curtime();
  return OK;
}

/****************************************************************************
 * Name: ds18b20_fetch
 *
 * Description: Performs a measuremnt cylce and data read with data
 *              conversion.
 *
 * Parameter:
 *   lower  - Pointer to lower half sensor driver instance
 *   buffer - Pointer to the buffer for reading data
 *   buflen - Size of the buffer
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_fetch(FAR struct sensor_lowerhalf_s *lower,
                        FAR char *buffer, size_t buflen)
{
  int ret;
  struct ds18b20_sensor_data_s data;
  FAR struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)lower;

  /* Check if the user is reading the right size */

  if (buflen != sizeof(struct sensor_event_temp))
    {
      snerr("ERROR: You need to read %d bytes from this sensor!\n",
            sizeof(struct sensor_event_temp));
      return -EINVAL;
    }

  ret = ds18b20_measure_read(priv, &data);
  if (!ret)
    {
      FAR struct sensor_event_temp *temp =
        (FAR struct sensor_event_temp *)buffer;
      temp->temperature = ds18b20_temp(data.spad);
      temp->timestamp   = data.timestamp;
    }
  else
    {
      return ret;
    }

  return buflen;
}

/****************************************************************************
 * Name: ds18b20_control
 *
 * Description: Interface function of struct sensor_ops_s.
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_control(FAR struct sensor_lowerhalf_s *lower,
                          int cmd, unsigned long arg)
{
  int ret;
  struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)lower;

  switch (cmd)
    {
      /* Read rom code */

      case SNIOC_READROMCODE:
        {
          FAR uint64_t *ptr = (FAR uint64_t *)((uintptr_t)arg);
          DEBUGASSERT(ptr != NULL);
          *ptr = priv->config.romcode;
          sninfo("read romcode: %16llx\n", *ptr);
          ret = OK;
        }
        break;

      /* Set new temperature alarm */

      case SNIOC_SETALARM:
        {
          FAR struct ds18b20_alarm_s *ptr =
            (FAR struct ds18b20_alarm_s *)((uintptr_t)arg);
          DEBUGASSERT(ptr != NULL);
          sninfo("set alarm: [TH/TL] = %d/%d °C\n", ptr->thigh, ptr->tlow);
          ret = ds18b20_set_alarm(priv, ptr);
        }
        break;

      /* Set sensor resolution */

      case SNIOC_SETRESOLUTION:
        {
          uint8_t res = arg - 9;
          sninfo("set resolution: %ld\n", arg);
          if (res >= DS18B20_RESMIN && res <= DS18B20_RESMAX)
            {
              ret = ds18b20_set_res(priv, DS18B20_RES_CONV(res));
            }
          else
            {
              ret = -EINVAL;
            }
        }
        break;

      default:
        snerr("ERROR: Unrecognized cmd: %d\n", cmd);
        ret = -ENOTTY;
        break;
    }

  return ret;
}

/****************************************************************************
 * Name: ds18b20_active
 *
 * Description: Interface function of struct sensor_ops_s.
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

static int ds18b20_active(FAR struct sensor_lowerhalf_s *lower,
                         unsigned char enabled)
{
#ifdef CONFIG_SENSORS_DS18B20_POLL
  bool start_thread = false;
  struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)lower;

  if (enabled)
    {
      if (!priv->sensor.enabled)
        {
          start_thread = true;
        }
    }

  priv->sensor.enabled = enabled;

  if (start_thread == true)
    {
      /* Wake up the thread */

      nxsem_post(&priv->run);
    }
#endif

  return OK;
}

/****************************************************************************
 * Name: ds18b20_set_interval
 *
 * Description: Interface function of struct sensor_ops_s.
 *
 * Return:
 *   OK - on success
 ****************************************************************************/

#ifdef CONFIG_SENSORS_DS18B20_POLL
static int ds18b20_set_interval(FAR struct sensor_lowerhalf_s *lower,
                               FAR unsigned int *period_us)
{
  FAR struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)lower;
  priv->interval = *period_us;
  return OK;
}
#endif

/****************************************************************************
 * Name: ds18b20_thread
 *
 * Description: Thread for performing interval measurement cycle and data
 *              read.
 *
 * Parameter:
 *   argc - Number opf arguments
 *   argv - Pointer to argument list
 ****************************************************************************/

#ifdef CONFIG_SENSORS_DS18B20_POLL
static int ds18b20_thread(int argc, char** argv)
{
  uint16_t orawdata;
  FAR struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)
        ((uintptr_t)strtoul(argv[1], NULL, 0));

  /* Set initial value to out of measurement range to ensure that the first
   * data read leads to an upper notification.
   */

  orawdata = 0xffff;

  while (true)
    {
      int ret;
      struct ds18b20_sensor_data_s data;
      FAR struct ds18b20_sensor_s *sensor = &priv->sensor;
      FAR struct ds18b20_alarm_s *alarm = &priv->reg.alarm;

      if (!sensor->enabled)
        {
          /* Waiting to be woken up */

          nxsem_wait(&priv->run);
        }

      if (alarm->wakeup == true)
        {
          /* Perform a temperature conversion to update the alarm flag */

          ret = ds18b20_measure(priv);
          if (!ret)
            {
              /* Wait until temperature conversion is done and the alarm flag
               * is up to date.
               */

              nxsig_usleep(g_res_timeout[DS18B20_RES_VAL(priv->reg.res)]);

              /* Check for existing temperature alarm */

              ret = ds18b20_isalarm(priv->master, &priv->config);
              if (ret == 1)
                {
                  ret = ds18b20_measure_read(priv, &data);
                  if (!ret && sensor->enabled == true)
                    {
                      /* Notify upper */

                      ds18b20_notify(priv, &data);
                    }
                }
            }
        }
      else
        {
          /* Default nofitication when temperature has been changed */

          ret = ds18b20_measure_read(priv, &data);
          if (!ret)
            {
              uint16_t rawtemp = ds18b20_rawtemp(data.spad);

              if (sensor->enabled == true && orawdata != rawtemp)
                {
                  ds18b20_notify(priv, &data);
                }

              /* Store the last sensor data for later comparison */

              orawdata = ds18b20_rawtemp(data.spad);
            }
        }

      /* Sleeping thread before fetching the next sensor data */

      nxsig_usleep(priv->interval);
    }

  return OK;
}
#endif

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: ds18b20_register
 *
 * Description:
 *   Register the DS18B20 character device.
 *
 * Input Parameters:
 *   devno   - The user specifies device number, from 0.
 *   onewire - An instance of the 1wire interface to communicate with DS18B20
 *             sensor.
 *   romcode - The ROM code of the DS18B20.
 *
 * Returned Value:
 *   Zero (OK) on success; a negated errno value on failure.
 ****************************************************************************/

int ds18b20_register(int devno, FAR struct onewire_master_s *onewire,
                     uint64_t romcode)
{
  int ret;
  struct ds18b20_sensor_s *tmp;
#ifdef CONFIG_SENSORS_DS18B20_POLL
  FAR char *argv[2];
  char arg1[32];
#endif

  /* Sanity check */

  if (!onewire)
    {
      snerr("Invalid 1wire instance\n");
      return -EINVAL;
    }

  /* Initialize the DS18B20 device structure */

  FAR struct ds18b20_dev_s *priv = (FAR struct ds18b20_dev_s *)
    kmm_malloc(sizeof(struct ds18b20_dev_s));

  if (priv == NULL)
    {
      snerr("ERROR: Failed to allocate instance\n");
      return -ENOMEM;
    }

  priv->master           = onewire;
  priv->config.romcode   = romcode;
  priv->reg.res          = DS18B20_RES_CONV(DS18B20_RESMAX);
  priv->reg.alarm.thigh  = DS18B20_TALARM_MAX;
  priv->reg.alarm.tlow   = DS18B20_TALARM_MIN;
#ifdef CONFIG_SENSORS_DS18B20_POLL
  priv->reg.alarm.wakeup = false;
  priv->interval         = CONFIG_SENSORS_DS18B20_POLL_INTERVAL;

  nxsem_init(&priv->run, 0, 0);
  nxsem_set_protocol(&priv->run, SEM_PRIO_NONE);
#endif

  /* Temperature register */

  tmp = &priv->sensor;
#ifdef CONFIG_SENSORS_DS18B20_POLL
  tmp->enabled = false;
#endif
  tmp->lower.ops = &g_ds18b20_ops;
  tmp->lower.type = SENSOR_TYPE_AMBIENT_TEMPERATURE;
  tmp->lower.uncalibrated = false;
  tmp->lower.buffer_number = 1;
  ret = sensor_register(&tmp->lower, devno);
  if (ret < 0)
    {
      goto sensor_err;
    }

#ifdef CONFIG_SENSORS_DS18B20_POLL

  /* Create thread for polling sensor data */

  snprintf(arg1, 16, "0x%" PRIxPTR, (uintptr_t)priv);
  argv[0] = arg1;
  argv[1] = NULL;
  ret = kthread_create("ds18b20_thread", SCHED_PRIORITY_DEFAULT,
                       CONFIG_SENSORS_DS18B20_THREAD_STACKSIZE,
                       ds18b20_thread, argv);
  if (ret > 0)
#endif
    {
      return OK;
    }

sensor_err:
  sensor_unregister(&priv->sensor.lower, devno);
  kmm_free(priv);
  return ret;
}
#endif /* CONFIG_1WIRE && CONFIG_SENSORS_DS18B20 */