/* * 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 #define SEGMENT_PORT GPIOA #define SEGMENT_A GPIO5 #define SEGMENT_B GPIO3 #define SEGMENT_C GPIO6 #define SEGMENT_D GPIO0 #define SEGMENT_E GPIO1 #define SEGMENT_F GPIO7 #define SEGMENT_G GPIO4 #define SEGMENT_DOT GPIO2 #define SEGMENT_ALL GPIO0 | GPIO1 | GPIO2 | GPIO3 | GPIO4 | GPIO5 | GPIO6 | GPIO7 | GPIO4 #define COMMON_PORT GPIOB #define COMMON_ALL GPIO15 | GPIO14 | GPIO13 | GPIO12 | GPIO11 #define COMMON_1 GPIO15 #define COMMON_2 GPIO14 #define COMMON_3 GPIO13 #define COMMON_4 GPIO12 #define COMMON_L GPIO11 const uint16_t segment_numbers[] = { SEGMENT_A | SEGMENT_B | SEGMENT_C | SEGMENT_D | SEGMENT_E | SEGMENT_F, // 0 SEGMENT_B | SEGMENT_C, // 1 SEGMENT_A | SEGMENT_B | SEGMENT_D | SEGMENT_E | SEGMENT_G, // 2 SEGMENT_A | SEGMENT_B | SEGMENT_C | SEGMENT_D | SEGMENT_G, // 3 SEGMENT_B | SEGMENT_C | SEGMENT_F | SEGMENT_G, // 4 SEGMENT_A | SEGMENT_C | SEGMENT_D | SEGMENT_F | SEGMENT_G, // 5 SEGMENT_A | SEGMENT_C | SEGMENT_D | SEGMENT_E | SEGMENT_F | SEGMENT_G, // 6 SEGMENT_A | SEGMENT_B | SEGMENT_C, // 7 SEGMENT_A | SEGMENT_B | SEGMENT_C | SEGMENT_D | SEGMENT_E | SEGMENT_F | SEGMENT_G, // 8 SEGMENT_A | SEGMENT_B | SEGMENT_C | SEGMENT_D | SEGMENT_F | SEGMENT_G, // 9 SEGMENT_A | SEGMENT_B | SEGMENT_C | SEGMENT_E | SEGMENT_F | SEGMENT_G, // A 10 SEGMENT_C | SEGMENT_D | SEGMENT_E | SEGMENT_F | SEGMENT_G, // B 11 SEGMENT_A | SEGMENT_D | SEGMENT_E | SEGMENT_F, // C 12 SEGMENT_B | SEGMENT_C | SEGMENT_D | SEGMENT_E | SEGMENT_G, // D 13 SEGMENT_A | SEGMENT_D | SEGMENT_E | SEGMENT_F | SEGMENT_G, // E 14 SEGMENT_A | SEGMENT_E | SEGMENT_F | SEGMENT_G, // F 15 SEGMENT_B | SEGMENT_C | SEGMENT_E | SEGMENT_F | SEGMENT_G, // H 16 SEGMENT_G // - 17 }; const uint16_t common_numbers[] = { COMMON_1, COMMON_2, COMMON_3, COMMON_4 }; volatile int segment_values[] = {17, 17, 17, 17}; volatile int common_counter = 0; 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_GPIOA); 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); // 7segments gpio_set_mode(SEGMENT_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, SEGMENT_ALL); // commons gpio_set_mode(COMMON_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, COMMON_ALL); } // Onetime config of timer things that stay the same static void tim_setup(void) { // 7 segment driver timer nvic_enable_irq(NVIC_TIM2_IRQ); nvic_set_priority(NVIC_TIM2_IRQ, 2); rcc_periph_clock_enable(RCC_TIM2); rcc_periph_reset_pulse(RST_TIM2); timer_set_mode(TIM2, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); timer_set_prescaler(TIM2, (rcc_apb1_frequency*2) / 1000000 - 1); // set timer tickrate to 1mhz timer_set_period(TIM2, 2000); // 2ms timer_enable_irq(TIM2, TIM_DIER_UIE); // start displaying 7 segment numbers timer_enable_counter(TIM2); // DHT11 Reading timer nvic_enable_irq(NVIC_TIM3_IRQ); nvic_set_priority(NVIC_TIM3_IRQ, 1); 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 // timer is enabled in dht_start() } static void show_segment_value(int common, int value, bool decimal) { gpio_clear(COMMON_PORT, COMMON_ALL); gpio_set(SEGMENT_PORT, SEGMENT_ALL); gpio_clear(SEGMENT_PORT, segment_numbers[value] | (decimal ? SEGMENT_DOT : 0)); gpio_set(COMMON_PORT, common_numbers[common]); } void tim2_isr(void) { if (timer_get_flag(TIM2, TIM_SR_UIF)) { timer_clear_flag(TIM2, TIM_SR_UIF); show_segment_value(common_counter, segment_values[common_counter], common_counter == 1 ? true : false); common_counter++; if (common_counter > 3){ common_counter = 0; } } } 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]); if (segment_values[3] == 0xC) { segment_values[3] = 16; // now showing humidity segment_values[0] = (data[0] / 10) % 10; segment_values[1] = data[0] % 10; segment_values[2] = data[1] % 10; } else { segment_values[3] = 0xC; // now showing temperature segment_values[0] = (data[2] / 10) % 10; segment_values[1] = data[2] % 10; segment_values[2] = data[3] % 10; } } 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 */ SEGGER_RTT_printf(0, "Poll: %d, seg: %d\n", i, i & 0xf); //show_segment_value(i & 3, 16, false); i++; delay(10000000); //delay(1000000); 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; }