// Copyright (c) 2014 Adafruit Industries

// Author: Tony DiCola

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all

// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

// SOFTWARE.

#include <stdbool.h>

#include <stdlib.h>

#include "pi_2_dht_read.h"

#include "pi_2_mmio.h"

// This is the only processor specific magic value, the maximum amount of time to

// spin in a loop before bailing out and considering the read a timeout.  This should

// be a high value, but if you're running on a much faster platform than a Raspberry

// Pi or Beaglebone Black then it might need to be increased.

#define DHT_MAXCOUNT 32000

// Number of bit pulses to expect from the DHT.  Note that this is 41 because

// the first pulse is a constant 50 microsecond pulse, with 40 pulses to represent

// the data afterwards.

#define DHT_PULSES 41

int pi_2_dht_read(int type, int pin, float* humidity, float* temperature) {

  // Validate humidity and temperature arguments and set them to zero.

  if (humidity == NULL || temperature == NULL) {

    return DHT_ERROR_ARGUMENT;

  }

  *temperature = 0.0f;

  *humidity = 0.0f;

  // Initialize GPIO library.

  if (pi_2_mmio_init() < 0) {

    return DHT_ERROR_GPIO;

  }

  // Store the count that each DHT bit pulse is low and high.

  // Make sure array is initialized to start at zero.

  int pulseCounts[DHT_PULSES*2] = {0};

  // Set pin to output.

  pi_2_mmio_set_output(pin);

  // Bump up process priority and change scheduler to try to try to make process more 'real time'.

  set_max_priority();

  // Set pin high for ~500 milliseconds.

  pi_2_mmio_set_high(pin);

  sleep_milliseconds(500);

  // The next calls are timing critical and care should be taken

  // to ensure no unnecssary work is done below.

  // Set pin low for ~20 milliseconds.

  pi_2_mmio_set_low(pin);

  busy_wait_milliseconds(20);

  // Set pin at input.

  pi_2_mmio_set_input(pin);

  // Need a very short delay before reading pins or else value is sometimes still low.

volatile int i;

  for (i = 0; i < 50; ++i) {

  }

  // Wait for DHT to pull pin low.

  uint32_t count = 0;

  while (pi_2_mmio_input(pin)) {

    if (++count >= DHT_MAXCOUNT) {

      // Timeout waiting for response.

      set_default_priority();

      return DHT_ERROR_TIMEOUT;

    }

  }

  // Record pulse widths for the expected result bits.

  int j;

  for ( j=0; j < DHT_PULSES*2; j+=2) {

    // Count how long pin is low and store in pulseCounts[i]

    while (!pi_2_mmio_input(pin)) {

      if (++pulseCounts[i] >= DHT_MAXCOUNT) {

        // Timeout waiting for response.

        set_default_priority();

        return DHT_ERROR_TIMEOUT;

      }

    }

    // Count how long pin is high and store in pulseCounts[i+1]

    while (pi_2_mmio_input(pin)) {

      if (++pulseCounts[i+1] >= DHT_MAXCOUNT) {

        // Timeout waiting for response.

        set_default_priority();

        return DHT_ERROR_TIMEOUT;

      }

    }

  }

  // Done with timing critical code, now interpret the results.

  // Drop back to normal priority.

  set_default_priority();

  // Compute the average low pulse width to use as a 50 microsecond reference threshold.

  // Ignore the first two readings because they are a constant 80 microsecond pulse.

  uint32_t threshold = 0;

  int k;

  for (k=2; i < DHT_PULSES*2; k+=2) {

    threshold += pulseCounts[k];

  }

  threshold /= DHT_PULSES-1;

  // Interpret each high pulse as a 0 or 1 by comparing it to the 50us reference.

  // If the count is less than 50us it must be a ~28us 0 pulse, and if it's higher

  // then it must be a ~70us 1 pulse.

  uint8_t data[5] = {0};

  int l;

  for ( l=3; l < DHT_PULSES*2; l+=2) {

    int index = (l-3)/16;

    data[index] <<= 1;

    if (pulseCounts[l] >= threshold) {

      // One bit for long pulse.

      data[index] |= 1;

    }

    // Else zero bit for short pulse.

  }

  // Useful debug info:

  //printf("Data: 0x%x 0x%x 0x%x 0x%x 0x%x\n", data[0], data[1], data[2], data[3], data[4]);

  // Verify checksum of received data.

  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {

    if (type == DHT11) {

      // Get humidity and temp for DHT11 sensor.

      *humidity = (float)data[0];

      *temperature = (float)data[2];

    }

    else if (type == DHT22) {

      // Calculate humidity and temp for DHT22 sensor.

      *humidity = (data[0] * 256 + data[1]) / 10.0f;

      *temperature = ((data[2] & 0x7F) * 256 + data[3]) / 10.0f;

      if (data[2] & 0x80) {

        *temperature *= -1.0f;

      }

    }

    return DHT_SUCCESS;

  }

  else {

    return DHT_ERROR_CHECKSUM;

  }

}