sensors/ds18b20/main.c

#include <bsp430/platform.h>
#include <bsp430/periph/port.h>
#include <bsp430/utility/console.h>
#include <bsp430/utility/uptime.h>
#include <bsp430/utility/onewire.h>

/* Sanity check that the features we requested are present */
#if ! (BSP430_CONSOLE - 0)
#error Console is not configured correctly
#endif
/* Sanity check that the features we requested are present */
#if ! (BSP430_UPTIME - 0)
#error Uptime is not configured correctly
#endif

#ifndef APP_DS18B20_BUS
#define APP_DS18B20_BUS ds18b20
/* Where the device can be found */
const struct sBSP430onewireBus ds18b20 = {
  .port = APP_DS18B20_PORT_HAL,
  .bit = APP_DS18B20_BIT,
};
#endif /* APP_DS18B20_BUS */

#ifndef APP_DS18B20_POWER_BIT
/* Bit on APP_DS18B20_BUS.port that supplies power during temperature
 * conversions. */
#define APP_DS18B20_POWER_BIT 0
#endif /* APP_DS18B20_POWER_BIT */

/* The serial number read from the device on startup */
struct sBSP430onewireSerialNumber serial;

void main ()
{
  int rc;
  int external_power;
  static const char * const supply_type[] = { "parasitic", "external" };
  const struct sBSP430onewireBus * const bus = &APP_DS18B20_BUS;

  vBSP430platformInitialize_ni();

  (void)iBSP430consoleInitialize();

  BSP430_CORE_ENABLE_INTERRUPT();
  cprintf("\nHere we go...\n");

  cprintf("Uptime now %lu with frequency %lu Hz\n",
          ulBSP430uptime_ni(), ulBSP430uptimeConversionFrequency_Hz());

  cprintf("Monitoring DS18xx on %s.%u ; ",
          xBSP430portName(BSP430_PORT_HAL_GET_PERIPH_HANDLE(bus->port)) ?: "P?",
          iBSP430portBitPosition(bus->bit));
  if (APP_DS18B20_POWER_BIT) {
    cprintf("parasitic conversion power from %s.%u\n",
            xBSP430portName(BSP430_PORT_HAL_GET_PERIPH_HANDLE(bus->port)) ?: "P?",
            iBSP430portBitPosition(APP_DS18B20_POWER_BIT));
    BSP430_PORT_HAL_HPL_DIR(bus->port) &= ~APP_DS18B20_POWER_BIT;
  } else {
    cprintf("no parasitic power boost\n");
  }

  external_power = iBSP430onewireReadPowerSupply(bus);
  cprintf("Power supply: %s\n", supply_type[external_power]);
  if (0 > external_power) {
    cprintf("ERROR: Device not present?\n");
  } else if ((! external_power) && (! (APP_DS18B20_POWER_BIT))) {
    cprintf("ERROR: Parasitic power without conversion boost?\n");
  }

  do {
    rc = iBSP430onewireReadSerialNumber(bus, &serial);
    if (0 != rc) {
      cprintf("ERROR: Failed to read serial number from DS18B20: %d\n", rc);
      BSP430_CORE_DELAY_CYCLES(BSP430_CLOCK_NOMINAL_MCLK_HZ);
    }
  } while (0 != rc);
  cprintf("DS18B20 serial number: %02x%02x%02x%02x%02x%02x\n",
          serial.id[0], serial.id[1], serial.id[2],
          serial.id[3], serial.id[4], serial.id[5]);

  while (1) {
    int rc;
    unsigned long start_tck;
    unsigned long end_tck;
    unsigned int duration_ms;
    int t_c;

    start_tck = ulBSP430uptime_ni();
    rc = -1;
    if (0 == iBSP430onewireRequestTemperature_ni(bus)) {
      if (external_power) {
        /* Wait for read to complete.  Conversion time can be as long as
         * 750 ms if 12-bit resolution is used (this resolution is the
         * default). Timing will be wrong unless interrupts are enabled
         * so uptime overflow events can be handled.  Sleep for 600ms,
         * then test at 10ms intervals until the result is ready.  Each
         * check is nominally 61 microseconds. */
        BSP430_UPTIME_DELAY_MS_NI(600, LPM3_bits, 0);
        while (! iBSP430onewireReadBit_ni(bus)) {
          BSP430_UPTIME_DELAY_MS_NI(10, LPM3_bits, 0);
        }
      } else {
        /* Output high on the parasitic power boost line for 750ms, to
         * power the conversion.  Then switch that signal back to
         * input so the data can flow over the same circuit. */
        BSP430_PORT_HAL_HPL_OUT(bus->port) |= APP_DS18B20_POWER_BIT;
        BSP430_PORT_HAL_HPL_DIR(bus->port) |= APP_DS18B20_POWER_BIT;
        BSP430_UPTIME_DELAY_MS_NI(750, LPM3_bits, 0);
        BSP430_PORT_HAL_HPL_DIR(bus->port) &= ~APP_DS18B20_POWER_BIT;
      }
      rc = iBSP430onewireReadTemperature_ni(bus, &t_c);
    }
    end_tck = ulBSP430uptime_ni();
    duration_ms = BSP430_UPTIME_UTT_TO_MS(end_tck - start_tck);

    cprintf("%s: ", xBSP430uptimeAsText_ni(end_tck));
    if (0 == rc) {
      cprintf("Temperature %d dCel or %d d[degF] in %u ms\n",
              (10 * t_c) / 16, BSP430_ONEWIRE_xCel_TO_ddegF(t_c),
              duration_ms);
    } else {
      cprintf("Measurement failed in %u ms\n", duration_ms);
    }

    /* You'd want to do this if you were going to sleep here */
    vBSP430onewireShutdown_ni(bus);
    BSP430_UPTIME_DELAY_MS_NI(30000, LPM3_bits, 0);
  }
}