--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kstmApp/src/pi_2_dht_read.c Fri Aug 14 11:30:43 2015 +0200
@@ -0,0 +1,162 @@
+// 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;
+ }
+}