/****************************************************************************** * FunctionName : key_init * Description : init keys * Parameters : key_param *keys - keys parameter, which inited by key_init_single * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR key_init(struct keys_param *keys) { uint8 i; os_printf("-%s-%s \r\n", __FILE__, __func__); ETS_GPIO_INTR_ATTACH(key_intr_handler, keys); ETS_GPIO_INTR_DISABLE(); for (i = 0; i < keys->key_num; i++) { keys->single_key[i]->key_level = 1; PIN_FUNC_SELECT(keys->single_key[i]->gpio_name, keys->single_key[i]->gpio_func); gpio_output_set(0, 0, 0, GPIO_ID_PIN(keys->single_key[i]->gpio_id)); gpio_register_set(GPIO_PIN_ADDR(keys->single_key[i]->gpio_id), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear gpio14 status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(keys->single_key[i]->gpio_id)); //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_ANYEGDE); } ETS_GPIO_INTR_ENABLE(); }
/** * Sets the 'gpio_pin' pin as a GPIO and sets the interrupt to trigger on that pin. * The 'interruptArg' is the function argument that will be sent to your interruptHandler */ bool ICACHE_FLASH_ATTR easygpio_attachInterrupt(uint8_t gpio_pin, EasyGPIO_PullStatus pullStatus, void (*interruptHandler)(void *arg), void *interruptArg) { uint32_t gpio_name; uint8_t gpio_func; if (gpio_pin == 16) { os_printf("easygpio_setupInterrupt Error: GPIO16 does not have interrupts\n"); return false; } if (!easygpio_getGPIONameFunc(gpio_pin, &gpio_name, &gpio_func) ) { return false; } ETS_GPIO_INTR_ATTACH(interruptHandler, interruptArg); ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(gpio_name, gpio_func); easygpio_setupPullsByName(gpio_name, pullStatus); // disable output GPIO_DIS_OUTPUT(gpio_pin); gpio_register_set(GPIO_PIN_ADDR(gpio_pin), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear gpio14 status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(gpio_pin)); ETS_GPIO_INTR_ENABLE(); return true; }
/****************************************************************************** * FunctionName : key_init * Description : init keys * Parameters : key_param *keys - keys parameter, which inited by key_init_single * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR key_init() { uint8 i; ETS_GPIO_INTR_ATTACH(key_intr_handler, &key_parameters); ETS_GPIO_INTR_DISABLE(); for (i = 0; i < key_parameters.key_num; i++) { key_parameters.single_key[i]->key_level = 1; key_parameters.single_key[i]->is_long = 0; PIN_FUNC_SELECT(key_parameters.single_key[i]->gpio_name, key_parameters.single_key[i]->gpio_func); // Set GPIO as input gpio_output_set(0, 0, 0, GPIO_ID_PIN(key_parameters.single_key[i]->gpio_id)); gpio_register_set( GPIO_PIN_ADDR(key_parameters.single_key[i]->gpio_id), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE) ); //clear gpio14 status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(key_parameters.single_key[i]->gpio_id)); //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(key_parameters.single_key[i]->gpio_id), GPIO_PIN_INTR_NEGEDGE); } ETS_GPIO_INTR_ENABLE(); }
void ICACHE_FLASH_ATTR buttons_init() { //Attach the interrupt thing ETS_GPIO_INTR_ATTACH(rotary_intr_handler,12); //Disable interrupts ETS_GPIO_INTR_DISABLE(); //Set GPIO to IO PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13); PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0); //Set the GPIO to input gpio_output_set(0, 0, 0, GPIO_ID_PIN(12)); gpio_output_set(0, 0, 0, GPIO_ID_PIN(13)); gpio_output_set(0, 0, 0, GPIO_ID_PIN(0)); //Not sure what this does gpio_register_set(GPIO_PIN_ADDR(12), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); gpio_register_set(GPIO_PIN_ADDR(13), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); gpio_register_set(GPIO_PIN_ADDR(0), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear gpio status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(12)); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(13)); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(0)); //re-enable gpio0 interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(12), GPIO_PIN_INTR_ANYEDGE); //Global re-enable interrupts ETS_GPIO_INTR_ENABLE(); os_timer_disarm(&button_timer); os_timer_setfn(&button_timer, (os_timer_func_t *)button_push, 1); os_timer_arm(&button_timer, 50, 1); }
static void NO_INTR_CODE set_gpio_interrupt(uint8 pin) { ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); GPIO_DIS_OUTPUT(pin_num[pin]); gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); ETS_GPIO_INTR_ENABLE(); }
void supla_esp_gpio_enable_input_port(char port) { gpio_output_set(0, 0, 0, GPIO_ID_PIN(port)); gpio_register_set(GPIO_PIN_ADDR(port), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(port)); gpio_pin_intr_state_set(GPIO_ID_PIN(port), GPIO_PIN_INTR_ANYEDGE); }
/****************************************************************************** * FunctionName : user_plug_set_status * Description : set plug's status, 0x00 or 0x01 * Parameters : uint8 - status * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR user_plug_set_status(bool status) { // if (status != plug_param.status) { // if (status > 1) { // os_printf("error status input!\n"); // return; // } // // plug_param.status = status; // PLUG_STATUS_OUTPUT(PLUG_RELAY_LED_IO_NUM, status); // } if (status != plug_param.status) { if (status > 1) { os_printf("error status input!\n"); return; } plug_param.status = status; //PLUG_STATUS_OUTPUT(PLUG_RELAY_LED_IO_NUM, status); ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); GPIO_DIS_OUTPUT(pin_num[pin]); gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); ETS_GPIO_INTR_ENABLE(); //disable global interrupt ETS_GPIO_INTR_DISABLE(); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin])); pin_int_type[pin] = type; //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), type); //enable global interrupt ETS_GPIO_INTR_ENABLE(); ETS_GPIO_INTR_ATTACH(func, arg) } }
void ICACHE_FLASH_ATTR vibrate_init(uint8 gpio_id) { uint32 v_gpio_name=tisan_get_gpio_name(gpio_id); uint8 v_gpio_func=tisan_get_gpio_general_func(gpio_id); PIN_FUNC_SELECT(v_gpio_name, v_gpio_func); PIN_PULLUP_EN(v_gpio_name); gpio_output_set(0, 0, 0, GPIO_ID_PIN(gpio_id)); //set as input mode gpio_register_set(GPIO_PIN_ADDR(gpio_id), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(gpio_id)); //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(gpio_id), GPIO_PIN_INTR_NEGEDGE); peri_alarm_init(ALARM_GPIO_ID); peri_vibrate_tim_start(100); }
/** * Sets the 'gpio_pin' pin as a GPIO and sets the interrupt to trigger on that pin */ bool ICACHE_FLASH_ATTR easygpio_setupInterrupt(uint8_t gpio_pin, bool pullUp, bool pullDown, void (*interruptHandler)(void)) { uint32_t gpio_name; uint8_t gpio_func; if (gpio_pin == 6 || gpio_pin == 7 || gpio_pin == 8 || gpio_pin == 11 || gpio_pin >= 17) { os_printf("easygpio_setupInterrupt Error: There is no GPIO%d, check your code\n", gpio_pin); return false; } if (gpio_pin == 16) { os_printf("easygpio_setupInterrupt Error: GPIO16 does not have interrupts\n"); return false; } if (!easygpio_getGpioNameFunc(gpio_pin, &gpio_name, &gpio_func) ) { return false; } ETS_GPIO_INTR_ATTACH(interruptHandler, NULL); ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(gpio_name, gpio_func); easygpio_setupPulls(gpio_name, pullUp, pullDown); // disable output GPIO_DIS_OUTPUT(gpio_pin); gpio_register_set(GPIO_PIN_ADDR(gpio_pin), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear gpio14 status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(gpio_pin)); ETS_GPIO_INTR_ENABLE(); return true; }
void Softuart_Init(Softuart *s, uint16_t baudrate) { //disable rs485 s->is_rs485 = 0; if(! _Softuart_Instances_Count) { os_printf("SOFTUART initialize gpio\r\n"); //Initilaize gpio subsystem gpio_init(); } //set bit time s->bit_time = (1000000 / baudrate); os_printf("SOFTUART bit_time is %d\r\n",s->bit_time); //init tx pin if(!s->pin_tx.gpio_mux_name) { os_printf("SOFTUART ERROR: Set tx pin (%d)\r\n",s->pin_tx.gpio_mux_name); } else { //enable pin as gpio PIN_FUNC_SELECT(s->pin_tx.gpio_mux_name, s->pin_tx.gpio_func); //set pullup (UART idle is VDD) PIN_PULLUP_EN(s->pin_tx.gpio_mux_name); //set high for tx idle GPIO_OUTPUT_SET(GPIO_ID_PIN(s->pin_tx.gpio_id), 1); os_delay_us(100000); os_printf("SOFTUART TX INIT DONE\r\n"); } //init rx pin if(!s->pin_rx.gpio_mux_name) { os_printf("SOFTUART ERROR: Set rx pin (%d)\r\n",s->pin_rx.gpio_mux_name); } else { //enable pin as gpio PIN_FUNC_SELECT(s->pin_rx.gpio_mux_name, s->pin_rx.gpio_func); //set pullup (UART idle is VDD) PIN_PULLUP_EN(s->pin_rx.gpio_mux_name); //set to input -> disable output GPIO_DIS_OUTPUT(GPIO_ID_PIN(s->pin_rx.gpio_id)); //set interrupt related things //disable interrupts by GPIO ETS_GPIO_INTR_DISABLE(); //attach interrupt handler and a pointer that will be passed around each time ETS_GPIO_INTR_ATTACH(Softuart_Intr_Handler, s); //not sure what this does... (quote from example): // void gpio_register_set(uint32 reg_id, uint32 value); // // From include file // Set the specified GPIO register to the specified value. // This is a very general and powerful interface that is not // expected to be used during normal operation. It is intended // mainly for debug, or for unusual requirements. // // All people repeat this mantra but I don't know what it means // gpio_register_set(GPIO_PIN_ADDR(s->pin_rx.gpio_id), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); //clear interrupt handler status, basically writing a low to the output GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(s->pin_rx.gpio_id)); //enable interrupt for pin on any edge (rise and fall) //@TODO: should work with ANYEDGE (=3), but complie error gpio_pin_intr_state_set(GPIO_ID_PIN(s->pin_rx.gpio_id), 3); //globally enable GPIO interrupts ETS_GPIO_INTR_ENABLE(); os_printf("SOFTUART RX INIT DONE\r\n"); } //add instance to array of instances _Softuart_GPIO_Instances[s->pin_rx.gpio_id] = s; _Softuart_Instances_Count++; os_printf("SOFTUART INIT DONE\r\n"); }
int ICACHE_FLASH_ATTR set_gpio_mode(unsigned pin, unsigned mode, unsigned pull) { if (pin >= GPIO_PIN_NUM) return -1; if(pin == 0) { if(mode == GPIO_INPUT) gpio16_input_conf(); else gpio16_output_conf(); return 1; } switch(pull) { case GPIO_PULLUP: // PIN_PULLDWN_DIS(pin_mux[pin]); PIN_PULLUP_EN(pin_mux[pin]); break; case GPIO_PULLDOWN: PIN_PULLUP_DIS(pin_mux[pin]); // PIN_PULLDWN_EN(pin_mux[pin]); break; case GPIO_FLOAT: PIN_PULLUP_DIS(pin_mux[pin]); // PIN_PULLDWN_DIS(pin_mux[pin]); break; default: PIN_PULLUP_DIS(pin_mux[pin]); // PIN_PULLDWN_DIS(pin_mux[pin]); break; } switch(mode) { case GPIO_INPUT: GPIO_DIS_OUTPUT(pin_num[pin]); break; case GPIO_OUTPUT: ETS_GPIO_INTR_DISABLE(); #ifdef GPIO_INTERRUPT_ENABLE pin_int_type[pin] = GPIO_PIN_INTR_DISABLE; #endif PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); //disable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), GPIO_PIN_INTR_DISABLE); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin])); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain; ETS_GPIO_INTR_ENABLE(); break; #ifdef GPIO_INTERRUPT_ENABLE case GPIO_INT: ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); GPIO_DIS_OUTPUT(pin_num[pin]); gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); ETS_GPIO_INTR_ENABLE(); break; #endif default: break; } return 1; }
int platform_gpio_mode( unsigned pin, unsigned mode, unsigned pull ) { // NODE_DBG("Function platform_gpio_mode() is called. pin_mux:%d, func:%d\n",pin_mux[pin],pin_func[pin]); if (pin >= NUM_GPIO) return -1; if(pin == 0){ if(mode==PLATFORM_GPIO_INPUT) gpio16_input_conf(); else gpio16_output_conf(); return 1; } platform_pwm_close(pin); // closed from pwm module, if it is used in pwm switch(pull){ case PLATFORM_GPIO_PULLUP: PIN_PULLDWN_DIS(pin_mux[pin]); PIN_PULLUP_EN(pin_mux[pin]); break; case PLATFORM_GPIO_PULLDOWN: PIN_PULLUP_DIS(pin_mux[pin]); PIN_PULLDWN_EN(pin_mux[pin]); break; case PLATFORM_GPIO_FLOAT: PIN_PULLUP_DIS(pin_mux[pin]); PIN_PULLDWN_DIS(pin_mux[pin]); break; default: PIN_PULLUP_DIS(pin_mux[pin]); PIN_PULLDWN_DIS(pin_mux[pin]); break; } switch(mode){ case PLATFORM_GPIO_INPUT: #if defined( LUA_USE_MODULES_GPIO ) && defined( GPIO_INTERRUPT_ENABLE ) lua_gpio_unref(pin); // unref the lua ref call back. #endif GPIO_DIS_OUTPUT(pin_num[pin]); case PLATFORM_GPIO_OUTPUT: ETS_GPIO_INTR_DISABLE(); #ifdef GPIO_INTERRUPT_ENABLE pin_int_type[pin] = GPIO_PIN_INTR_DISABLE; #endif PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); //disable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), GPIO_PIN_INTR_DISABLE); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin])); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain; ETS_GPIO_INTR_ENABLE(); break; #ifdef GPIO_INTERRUPT_ENABLE case PLATFORM_GPIO_INT: ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]); GPIO_DIS_OUTPUT(pin_num[pin]); gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); ETS_GPIO_INTR_ENABLE(); break; #endif default: break; } return 1; }
//----------------------------------------------------------------------------------------- void static dht11_protocol(uint32 gpio_status,int cause) { static int actual_bit; switch(cause) // 0 = gpio interrupt, 1=timer { case 0: // gpio edge { // disable interrupt for GPIO gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_DISABLE); // clear interrupt status for GPIO GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & GPIO_Pin(dht11_gpio)); // Reactivate interrupts for GPIO0 gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE); switch(sStatus) { case dht11_connecting: if(GPIO_INPUT_GET(dht11_gpio)) { // Rising edge ?? Error. dht11_set_read_nok(); dht11_set_standby(); } else { sStatus = dht11_mark_connecting; } break; case dht11_mark_connecting: if(!GPIO_INPUT_GET(dht11_gpio)) { // Falling edge ?? Error. dht11_set_read_nok(); dht11_set_standby(); } else { sStatus = dht11_waiting_bit; } break; case dht11_waiting_bit: if(GPIO_INPUT_GET(dht11_gpio)) { // Rising edge ?? Error. dht11_set_read_nok(); dht11_set_standby(); } else { sStatus = dht11_mark_bit; actual_bit=0; } break; case dht11_mark_bit: if(! GPIO_INPUT_GET(dht11_gpio)) { // Falling edge ?? Error. dht11_set_read_nok(); dht11_set_standby(); } else { if(actual_bit >= 40) { dht11_set_standby(); // finish OK } else { last_timer = system_get_time(); sStatus = dht11_read_bit; } } break; case dht11_read_bit: if(GPIO_INPUT_GET(dht11_gpio)) { // Rising edge ?? Error. dht11_set_read_nok(); dht11_set_standby(); } else { // 26-28 uS means 0. 70 uS means 1 int bit_data = ((system_get_time()-last_timer) > 40) ? 1:0; int actual_byte = actual_bit / 8; sRead[actual_byte] <<= 1; sRead[actual_byte] |= bit_data; actual_bit++; sStatus = dht11_mark_bit; } break; case dht11_standby: case dht11_mark: default: dht11_set_standby(); break; } } break; case 1: //timer switch(sStatus) { case dht11_mark: // end of mark sStatus = dht11_connecting; // GPIO as Output to high level by default. GPIO_OUTPUT_SET(dht11_gpio,1); GPIO_AS_INPUT(dht11_gpio); ETS_GPIO_INTR_DISABLE(); gpio_register_set(GPIO_PIN_ADDR(dht11_gpio), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE)); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(dht11_gpio)); gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE); ETS_GPIO_INTR_ENABLE(); os_timer_disarm(&dht11_timer); os_timer_arm(&dht11_timer,6,0); // maximun frame time 4.8 ms break; case dht11_connecting: case dht11_mark_connecting: case dht11_waiting_bit: case dht11_mark_bit: case dht11_read_bit: default: dht11_set_read_nok(); dht11_set_standby(); break; } default: break; } }