#include "miniavr.h" #include "ports.h" #include "timer0.h" #include "timer1.h" #include "utils.h" // Uncomment to switch to Proof-Of-Concept mode. This setting executes the state machine // only once and immediately exits. Without this symbol, the main program runs in a never- // ending loop that automatically starts a query as soon as the sensor is ready. //#define POC // Uncomment to break the proof of concept into two distinct phases, i.e. start pulse // and sensor response. //#define DEBUG // Timer 1 statics uint8_t timer1::log::ix; timer1::value_type timer1::log::logs[timer1::log::max]; // Temperature/humidity sensors static constexpr uint8_t pin_mask = _BV(PC0); /* * Phase diagram * * |< bit 39 >|< bit 38 >| ... |< bit 0 >| * --+ +--+ +----+ | +---+| +-------+| +---+| +-- * \ 2ms / \ / \| / \ / \ / \ / * +--...--+ +----+ +---+ +---+ +-- ... --+ +---+ * START WAIT | ACK | 0 | 1 | ... ... | STOP * * The call operator returns BUSY for the duration of the entire process and VALID or * INVALID at the end of the decoding step, i.e. after bit 0 of the CRC was received. * * The duration of a LOW phase gives the decision threshold between 0 and 1 when the * signal is HIGH. Therefore that duration is measured between every transition. This * makes the state machine independent of the timer configuration since measurements * are relative to one another. * * * The entire process (less the start pulse) takes up to 5.57ms. The overall time-out is * then set to about 6ms (N=7 with prescaler=64 on a 8 bit timer to cover cases where a * start occurred close to an overflow). * * Author: DαrtℏTux, Arduino Discord */ struct DHT { using timer_t = timer0; // Invalid data marker static constexpr int16_t invalid_data = -1; enum class status: uint8_t { NOT_READY, // Not ready to receive commands READY, // Ready to receive commands #ifdef DEBUG ARMED, // Temporary state, waiting for sensor data #endif BUSY, // Decoding in process VALID, // Decoding done and valid INVALID, // CRC mismatch TIME_OUT, ERROR, // Generic error (e.g. unexpected data line state) }; static io::level read() { return portc & pin_mask ? io::level::HIGH : io::level::LOW; } static void pulldown() { ::pulldown(portc, pin_mask); } static void pullup() { ::pullup(portc, pin_mask); } // Set sensor pin to the default level (HIGH) DHT() { pullup(); reset(); } [[nodiscard]] status start(); [[nodiscard]] status operator () (); // Retrieve humidity x 10 in a fixed decimal number uint16_t humidity() const { return data[h]; } // Retrieve temperature x 10 in a fixed decimal number int16_t temperature() const { return (data[t] & 0x7FFF) * ((data[t] & 0x8000) ? -1 : 1); } protected: void reset(bool invalidate_data = true); void abort(); bool is_waiting(); status release(); enum { t, h }; // Duration, in overflow counts, for the grace period (i.e. forced inactivity) static constexpr uint16_t grace_count = 2.1 * F_CPU / 64 / 256; // Time out for the sensor to respond to the start pulse static constexpr uint8_t timeout_ticks = 6E-3 * F_CPU / 64 / 256 + 1; // Number of bits to process, first two are ignored static constexpr uint8_t byte_count = 4 + 1; // 2 x 16-bit integers + 1 CRC static constexpr uint8_t bit_count = byte_count * 8; static constexpr uint8_t falling_edge_count = bit_count + 2; // Skip 2 falling edges // Overflow count for the start pulse static constexpr uint16_t start_count = 3E-3 * F_CPU / 64 / 256 + 0.5; #ifdef DEBUG // These are only valid when the main clock is set to 16MHz static_assert(grace_count == 2050); static_assert(timeout_ticks == 6); static_assert(start_count == 3); #endif static constexpr uint16_t invalid_humidity = -1; static constexpr uint16_t invalid_temperature = 0x8001; uint16_t data[2]; // Humidity and temperature raw data uint16_t tmp; // Work register uint16_t ticks; // Number of ticks (timer overflow count) uint8_t crc; // Runtime checksum // Timer value on a falling or rising edge and decision threshold timer_t::value_type start_tick, threshold_tick; unsigned bit: 7; // Bit index in the current field (see state) io::level level: 1; // Cached data line state }; // This self-promotion indicates how many bytes this class needs static_assert(sizeof(DHT) == 12); void DHT::reset(bool invalidate_data) { bit = 0; ticks = grace_count; if (invalidate_data) { data[t] = invalid_temperature; data[h] = invalid_humidity; } } // Return true if a delay is active, decrementing the counter on an overflow from the timer. // In other cases false is returned. // Note: this function maintains an internal state. State change is guaranteed // even if overflows were missed since the flag is only reset on testing. inline bool DHT::is_waiting() { // We're done waiting to this condition: // return ticks == 0 || (DHT::timer_t::overflow() && --ticks == 0); // The following is the opposite: return ticks && !(DHT::timer_t::overflow() && --ticks == 0); } // Restore the data line to the defaults (INPUT with PULLUP enabled) // also resetting the internal decoder state. inline void DHT::abort() { pullup(); reset(); } // Start a query for a new measurement and return ERROR if the line could not be // asserted LOW, NOT_READY during the grace period and BUSY on success. DHT::status DHT::start() { // Ready state is only set after the grace period is over. The operator is // responsible for decrementing that count. if (ticks) return status::NOT_READY; // Don't if the line is already LOW if (read() == io::level::LOW) { abort(); return status::ERROR; } // Set sensor's pin LOW for 1ms (DHT22) or 20ms (DHT11) pulldown(); ticks = start_count; return status::BUSY; } // Release the data line and wait for sensor data. Return false on error, i.e. if the // data line remained LOW for unknown reasons. On success true is returned. DHT::status DHT::release() { // The data line must be HIGH, in which case step to the ACK state pullup(); __builtin_avr_delay_cycles (4); if ((level = read()) == io::level::LOW) { abort(); return status::ERROR; } // Countdown indicator for time out ticks = timeout_ticks; // We must skip 2 falling edges, bit counts from 42 down to 1 crc = 0; threshold_tick = 0; bit = falling_edge_count; #ifdef DEBUG // Give debugging sessions a chance to catch the end of the start pulse return status::ARMED; #else return status::BUSY; #endif } // Note: this function maintains multiple internal states and must only // be called on edge changes! DHT::status DHT::operator () () { // Take samples of the data line and timestamp const io::level sample = read(); const timer_t::value_type current_tick = timer_t(); // Either we're decoding, in which case `bit` is non zero, or we're // only waiting for the start pulse to end or we're waiting for the // end of the grace period. During the start pulse, the data line is // LOW otherwise it's HIGH... but we can only decide _after_ the delay // expired. if (bit == 0) { // If a delay is pending, we have to wait anyway const bool is_idle = sample == io::level::HIGH; if (is_waiting()) return is_idle ? status::NOT_READY : status::BUSY; // Data line was HIGH and delay expired, so we're now ready to // accept a new command if (is_idle) return status::READY; // Otherwise this is the end of the start pulse, so release the data // line and make sure the sensor acknowledged return release(); } // This is the decoding phase, decrement the time out counter if active if (!is_waiting()) { reset(); return status::TIME_OUT; } // Return early if there's no change if (level == sample) return status::BUSY; // Continue decoding on a new transition. The first transition to be // detected is guaranteed to be HIGH > LOW. // A falling edge means a new bit, except for the first transition (ACK). // Shift a zero or one based on the current duration of the HIGH level. level = sample; if (sample == io::level::LOW) { // Start decoding on bit 39 if (--bit < bit_count) { tmp <<= 1; if (timer_t::value_type(current_tick - start_tick) > threshold_tick) tmp |= 0x1; // Verify checksum on the last bit if (bit == 0) { const bool is_invalid = crc -= tmp; reset(is_invalid); return is_invalid ? status::INVALID : status::VALID; } // Add to checksum on multiples of 8 and store to different slots // on bit 24 (humidity, slot 1) and 8 (temperature, slot 0) if ((bit & 0x7) == 0) crc += tmp; if ((bit & 0x8) == 0x08) { // Force the compiler to use the `swap` instruction instead // of a rotate/shift loop const uint8_t ix = bit >> 4 | bit << 4; data[ix & 0x0f] = tmp; } } } // Store LOW duration on a rising edge as the decision threshold to stay // agnostic of the timer configuration/settings, as long as it's fast enough, // that is at least 250kHz else threshold_tick = current_tick - start_tick; // Store current tick count for an upcoming measurement start_tick = current_tick; // Note: member `bit` may be back to zero by now return status::BUSY; } // Report DHT states only void dump(DHT::status status) { switch (status) { case DHT::status::READY: println("Ready"); break; case DHT::status::NOT_READY: println("Not ready!"); break; case DHT::status::BUSY: println("Busy..."); break; case DHT::status::VALID: println("CRC"); break; case DHT::status::INVALID: println("!CRC"); break; case DHT::status::TIME_OUT: println("Timed out"); break; case DHT::status::ERROR: println("Error"); break; } } // General setup DHT dht; void setup() { // Set UART to 500kbd, 8N1 (U2X0=1) UCSR0A = _BV(U2X0); UCSR0C = 3 << UCSZ00; UCSR0B = _BV(RXEN0) | _BV(TXEN0); UBRR0 = 7; // Let's pretend timer0 is the scheduler... timer0::start(timer0::x64); // Start timestamp generator timer1::start(timer1::x8); } // Brief example how to use this sensor state machine void loop() { // This MUST be run on every iteration to retrieve the internal // state machine status code switch (dht()) { // Automatic start when READY case DHT::status::READY: dump(dht.start()); break; // Decode when the CRC is VALID case DHT::status::VALID: print("T°: "); println(dht.temperature(), DEC); print("H%: "); println(dht.humidity(), DEC); break; // Show errors otherwise case DHT::status::INVALID: println("!CRC"); break; case DHT::status::TIME_OUT: println("Timed out"); break; case DHT::status::ERROR: println("Error"); break; } } int main() { setup(); println("Hello, World..."); // This is the proof-of-concept #ifdef POC while (dht() == DHT::status::NOT_READY); dump(dht()); // Works! At last! if (dht.start() == DHT::status::BUSY) { #ifdef DEBUG // This should exit with ARMED or ERROR: while (dht() == DHT::status::BUSY); #endif // This should exit with VALID, INVALID or TIME_OUT DHT::status status; while ((status = dht()) == DHT::status::BUSY); dump(status); if (status == DHT::status::VALID) { print("T°: "); println(dht.temperature(), DEC); print("H%: "); println(dht.humidity(), DEC); } } #else // Run in an Arduino-like fashion while (1) loop(); #endif }