/* * This file is part of the libopencm3 project. * * Copyright (C) 2009 Uwe Hermann * * This library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library. If not, see . */ #include #include #include #include #include #include #define puts(s) SEGGER_RTT_WriteString(0, s);SEGGER_RTT_WriteString(0,"\n") #define DHT_PORT GPIOB #define DHT_PIN GPIO0 enum DHT11_STATE { DHT11_STOP, // Stop statemachine DHT11_START, // We drive DATA Low for minimum 18ms and then drive it HIGH and start waiting for response DHT11_RESPONSE, // Wait for DHT to drive DATA Low DHT11_DATA, // Receiving data DHT11_END, // Got last bit DHT11_TIMEOUT, // Not response or got partial data only }; int g_dht11_state = DHT11_STOP; // 2 pulses are the DHT Response and last 40 are data pulses for 5 bytes // so we have total of 42 pulses #define DHT11_BIT_COUNT 42 int g_dht_i = 0; // how many bits we have captured uint16_t g_dht_vals[DHT11_BIT_COUNT] = {0}; // captured bit times in us static void delay(int count) { for (int i=0; i < count; i++) { __asm__("nop"); } } static void gpio_setup(void) { /* Enable GPIOA clock. */ /* Manually: */ // RCC_APB2ENR |= RCC_APB2ENR_IOPCEN; /* Using API functions: */ rcc_periph_clock_enable(RCC_GPIOB); /* Set GPIO5 (in GPIO port A) to 'output push-pull'. */ /* Manually: */ // GPIOA_CRH = (GPIO_CNF_OUTPUT_PUSHPULL << (((5 - 8) * 4) + 2)); // GPIOA_CRH |= (GPIO_MODE_OUTPUT_2_MHZ << ((5 - 8) * 4)); /* Using API functions: */ // DHT Data pin gpio_set_mode(DHT_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, DHT_PIN); // Maple mini led gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO1); // A random DEBUG pin we can toggle and measure with logic gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO2); } // Onetime config of timer things that stay the same static void tim_setup(void) { nvic_enable_irq(NVIC_TIM3_IRQ); nvic_set_priority(NVIC_TIM3_IRQ, 1); // interrupts will not work without it??? rcc_periph_clock_enable(RCC_TIM3); rcc_periph_reset_pulse(RST_TIM3); // configure the timer to be a normal up counting timer, nothing fancy timer_set_mode(TIM3, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); timer_set_prescaler(TIM3, (rcc_apb1_frequency*2) / 1000000 - 1); // set timer tickrate to 1mhz timer_set_period(TIM3, 0xffff); // ~64 ms, DHT11 packet is never longer than 26ms timer_enable_irq(TIM3, TIM_DIER_UIE); // overflow timer_enable_irq(TIM3, TIM_DIER_CC3IE); // triggered when DHT drives DATA pin } void tim3_isr(void) { // Timer overflow that should only happen if DHT11 does not answer if (timer_get_flag(TIM3, TIM_SR_UIF)) { timer_clear_flag(TIM3, TIM_SR_UIF); puts("overflow"); g_dht11_state = DHT11_TIMEOUT; timer_disable_counter(TIM3); } else if (timer_get_flag(TIM3, TIM_SR_CC3IF)) // PB0 changed value { //gpio_toggle(GPIOB, GPIO2); // handle DHT11_END_START if (g_dht11_state == DHT11_START) { // Drive DATA pin high for a split second so that we have a nice sharp edge gpio_set(DHT_PORT, DHT_PIN); // Make the GPIO input so that we can wait for response // there is a external pull-up connected to the DATA pin // probably could use the internal pull-up also... gpio_set_mode(DHT_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, DHT_PIN); // setup timer input capture to wait for start response from dht11 // need to disable input capture before we can configure it. timer_ic_disable(TIM3, TIM_IC3); timer_ic_set_input(TIM3, TIM_IC3, TIM_IC_IN_TI3); timer_ic_set_polarity(TIM3, TIM_IC3, TIM_IC_FALLING); timer_clear_flag(TIM3, TIM_SR_CC3IF); // otherwise we will get a invalid interrupt timer_ic_enable(TIM3, TIM_IC3); //puts("waiting for response"); g_dht11_state = DHT11_RESPONSE; } // DHT11 drove DATA low and has started talking to us else if (g_dht11_state == DHT11_RESPONSE) { // store time when DHT11 pulled DATA low g_dht_vals[g_dht_i++] = TIM_CCR3(TIM3); g_dht11_state = DHT11_DATA; } // DHT11 is sending data to us else { // store length of the data bit g_dht_vals[g_dht_i++] = TIM_CCR3(TIM3); } // Did we just capture our last bit? if (g_dht_i >= DHT11_BIT_COUNT) { // yes we did g_dht11_state = DHT11_END; timer_disable_counter(TIM3); } timer_clear_flag(TIM3, TIM_SR_CC3IF); //gpio_toggle(GPIOB, GPIO2); } // Should only happen if TIM_SR_CC3IF is too slow // at 72mhz it should never happen but could at lower cpu speeds if (timer_get_flag(TIM3, TIM_SR_CC3OF)) { timer_clear_flag(TIM3, TIM_SR_CC3OF); //puts("we are too slow to read and clear timer input capture flags"); g_dht11_state = DHT11_TIMEOUT; timer_disable_counter(TIM3); } } // Setup the timer and trigger DHT11 Start static void dht_start(void) { timer_disable_counter(TIM3); g_dht11_state = DHT11_STOP; g_dht_i = 0; // Setup DHT11_END_START trigger on output compare 1 timer_set_counter(TIM3, 0); // capture compare channel must be disabled before we can configure it timer_ic_disable(TIM3, TIM_IC3); // set channel as output so that we can get an interrupt when OC3 values matches the timer counter timer_ic_set_input(TIM3, TIM_IC3, TIM_IC_OUT); // tick rate should be 1Mhz (via timer prescaler), so this should trigger in 20ms timer_set_oc_value(TIM3, TIM_OC3, 1000*20); // clear status flags so that we dont get any stray interrupts timer_clear_flag(TIM3, TIM_SR_CC3IF); // and make sure that we can get interrupts timer_ic_enable(TIM3, TIM_IC3); // Begin the statemachine g_dht11_state = DHT11_START; // Do DHT11_BEGIN_START aka drive DATA Low gpio_set_mode(DHT_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, DHT_PIN); gpio_clear(DHT_PORT, DHT_PIN); // And start counting timer_enable_counter(TIM3); } // Parse received DHT11 bit timing data from g_dht_vals and print out pretty values static void dht_parse_data(void) { int8_t data[5] = {0}; uint8_t checksum = 0; int data_index = 0; int data_bit = 7; // create bytes from bits for (int i=2; i < DHT11_BIT_COUNT; i++){ // First 2 pulses are start of response, ignore them uint16_t bit_time = g_dht_vals[i] - g_dht_vals[i-1]; // ~80us is 0 and ~120us is 1 if (bit_time > 100) { data[data_index] |= 1 << data_bit; } data_bit--; if (data_bit < 0) { data_bit = 7; data_index++; } } for (int i = 0; i < 4; i++){ checksum += data[i]; } if (checksum == data[4]) { SEGGER_RTT_printf(0, "Humidity: %d.%d%%; Temperature: %d.%dC\n", data[0], data[1], data[2], data[3]); } else { SEGGER_RTT_printf(0, "Checksum did not match, %x != %x\n", checksum, data[4]); } } // Just toggle the data pin, used only for debugging //static void dht_start_signal(void) //{ // gpio_set_mode(DHT_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, DHT_PIN); // gpio_clear(DHT_PORT, DHT_PIN); // delay(100000); // //delay(30000); // gpio_set(DHT_PORT, DHT_PIN); // delay(100); // gpio_set_mode(DHT_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, DHT_PIN); //} int main(void) { int i = 0; bool wait = false; puts("Start"); rcc_clock_setup_pll(&rcc_hse_configs[RCC_CLOCK_HSE8_72MHZ]); gpio_setup(); tim_setup(); /* Blink the LED (PA5) on the board. */ while (1) { /* Using API function gpio_toggle(): */ gpio_toggle(GPIOB, GPIO1); /* LED on/off */ i++; SEGGER_RTT_printf(0, "Poll: %d\n", i); delay(10000000); dht_start(); wait = true; while (wait) { switch (g_dht11_state) { case DHT11_END: dht_parse_data(); // fall through case DHT11_TIMEOUT: wait = false; } } } return 0; }