static void ICACHE_FLASH_ATTR flowTimerCb(void) { // 1 second if (flowOverridden) { ETS_GPIO_INTR_DISABLE(); flowCount = 0; ETS_GPIO_INTR_ENABLE(); } else { ETS_GPIO_INTR_DISABLE(); oneSecFlowCount = flowCount; flowCount = 0; ETS_GPIO_INTR_ENABLE(); } flowSetAverage(oneSecFlowCount); if (flowAverage == 0) { // Use average to deal with any timing issues when demand oscillates INFOP("!"); secondsNotFlowingCount++; } else { INFOP(">"); secondsNotFlowingCount = 0; } flowCountPerReading += oneSecFlowCount; if (oneSecFlowCount < flowMin) { flowMin = oneSecFlowCount; } if (oneSecFlowCount > flowMax) { flowMax = oneSecFlowCount; } calcFlows(); }
/****************************************************************************** * FunctionName : i2c_master_gpio_init * Description : config SDA and SCL gpio to open-drain output mode, * mux and gpio num defined in i2c_master.h * Parameters : NONE * Returns : NONE *******************************************************************************/ void ICACHE_FLASH_ATTR i2c_master_gpio_init(uint8 scl, uint8 sda, uint32 bitrate) { pinSCL = scl; pinSDA = sda; #if 0 ETS_GPIO_INTR_DISABLE(); // ETS_INTR_LOCK(); // Assume the pin mux is set before calling this function //PIN_FUNC_SELECT(I2C_MASTER_SDA_MUX, I2C_MASTER_SDA_FUNC); //PIN_FUNC_SELECT(I2C_MASTER_SCL_MUX, I2C_MASTER_SCL_FUNC); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(sda)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(sda))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << sda)); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(scl)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(scl))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << scl)); I2C_MASTER_SDA_SCL(1, 1); ETS_GPIO_INTR_ENABLE() ; // ETS_INTR_UNLOCK(); #endif I2C_MASTER_SDA_SCL(1, 1); i2c_master_init(); }
static void spi(uint8 c) { uint8 mask = 0x80; ETS_GPIO_INTR_DISABLE(); while (mask != 0) { if (mask & c) { // stdoutPutchar('1'); // easygpio_outputSet(LCD_Data, 1); GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, (1 << LCD_Data)); } else { // stdoutPutchar('0'); // easygpio_outputSet(LCD_Data, 0); GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, (1 << LCD_Data)); } mask >>= 1; asm volatile ( "NOP;NOP;NOP;NOP;NOP;" ); GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, (1 << LCD_clk)); asm volatile ( "NOP;NOP;NOP;NOP;NOP;" "NOP;NOP;NOP;NOP;NOP;" ); GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, (1 << LCD_clk)); } ETS_GPIO_INTR_ENABLE(); // stdoutPutchar(' '); }
// initialization void IRrecv::enableIRIn() { // initialize state machine variables irparams.rcvstate = STATE_IDLE; irparams.rawlen = 0; // set pin modes //PIN_FUNC_SELECT(IR_IN_MUX, IR_IN_FUNC); GPIO_DIS_OUTPUT(irparams.recvpin); // Initialize timer os_timer_disarm(&timer); os_timer_setfn(&timer, (os_timer_func_t *)read_timeout, &timer); // ESP Attach Interrupt ETS_GPIO_INTR_DISABLE(); ETS_GPIO_INTR_ATTACH(gpio_intr, NULL); gpio_pin_intr_state_set(GPIO_ID_PIN(irparams.recvpin), GPIO_PIN_INTR_ANYEDGE); ETS_GPIO_INTR_ENABLE(); //ETS_INTR_UNLOCK(); //attachInterrupt(irparams.recvpin, readIR, CHANGE); //irReadTimer.initializeUs(USECPERTICK, readIR).start(); //os_timer_arm_us(&irReadTimer, USECPERTICK, 1); //ets_timer_arm_new(&irReadTimer, USECPERTICK, 1, 0); }
/****************************************************************************** * 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(); }
/** * I2C init function * This sets up the GPIO io */ void ICACHE_FLASH_ATTR i2c_init(void) { //Disable interrupts ETS_GPIO_INTR_DISABLE(); //Set pin functions PIN_FUNC_SELECT(I2C_SDA_MUX, I2C_SDA_FUNC); PIN_FUNC_SELECT(I2C_SCK_MUX, I2C_SCK_FUNC); //Set SDA as open drain GPIO_REG_WRITE( GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_SDA_PIN)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_SDA_PIN))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE) ); GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_SDA_PIN)); //Set SCK as open drain GPIO_REG_WRITE( GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_SCK_PIN)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_SCK_PIN))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE) ); GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_SCK_PIN)); //Turn interrupt back on ETS_GPIO_INTR_ENABLE(); i2c_sda(1); i2c_sck(1); return; }
/****************************************************************************** * FunctionName : i2c_master_gpio_init * Description : config SDA and SCL gpio to open-drain output mode, * mux and gpio num defined in i2c_master.h * Parameters : uint8 sda and scl pin numbers * Returns : bool, true if init okay *******************************************************************************/ bool i2c_master_gpio_init(uint8 sda, uint8 scl) { if((sda > GPIO_PIN_NUM) || (pin_func[sda] == GPIO_PIN_FUNC_INVALID)){ return false; } if((scl > GPIO_PIN_NUM) || (pin_func[scl] == GPIO_PIN_FUNC_INVALID)){ return false; } pinSDA = sda; pinSCL = scl; ETS_GPIO_INTR_DISABLE() ; // ETS_INTR_LOCK(); PIN_FUNC_SELECT(pin_mux[sda], pin_func[sda]); PIN_FUNC_SELECT(pin_mux[scl], pin_func[scl]); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(sda)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(sda))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << sda)); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(scl)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(scl))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << scl)); i2c_master_setDC(1, 1); ETS_GPIO_INTR_ENABLE() ; // ETS_INTR_UNLOCK(); i2c_master_init(); return true; }
/* * Set GPIO mode to output. Optionally in RAM helper because interrupts are dsabled */ static void NO_INTR_CODE set_gpio_no_interrupt(uint8 pin, uint8_t push_pull) { unsigned pnum = pin_num[pin]; 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(pnum), GPIO_PIN_INTR_DISABLE); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pnum)); // configure push-pull vs open-drain if (push_pull) { GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain; } else { GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //enable open drain; } ETS_GPIO_INTR_ENABLE(); }
void ICACHE_FLASH_ATTR button_press() { ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts // Button interrupt received INFO("BUTTON: Button pressed\r\n"); // Button pressed, flip switch if (GPIO_REG_READ(BUTTON_GPIO) & BIT2) { INFO("BUTTON: Switch off\r\n"); GPIO_OUTPUT_SET(SWITCH03_GPIO, 0); } else { INFO("BUTTON: Switch on\r\n"); GPIO_OUTPUT_SET(SWITCH03_GPIO, 1); } // Send new status to the MQTT broker char *json_buf = NULL; json_buf = (char *)os_zalloc(jsonSize); json_ws_send((struct jsontree_value *)&device_tree, "device", json_buf); INFO("BUTTON: Sending current switch status\r\n"); MQTT_Publish(&mqttClient, config.mqtt_topic_s01, json_buf, strlen(json_buf), 0, 0); os_free(json_buf); json_buf = NULL; // Debounce os_delay_us(200000); // Clear interrupt status uint32 gpio_status; gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts }
void supla_esp_gpio_init_led(void) { ETS_GPIO_INTR_DISABLE(); #ifdef LED_RED_PORT #if LED_RED_PORT != 16 GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_RED_PORT)); gpio_pin_intr_state_set(GPIO_ID_PIN(LED_RED_PORT), GPIO_PIN_INTR_DISABLE); gpio_output_set(0, GPIO_ID_PIN(LED_RED_PORT), GPIO_ID_PIN(LED_RED_PORT), 0); #endif #endif #ifdef LED_GREEN_PORT GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_GREEN_PORT)); gpio_pin_intr_state_set(GPIO_ID_PIN(LED_GREEN_PORT), GPIO_PIN_INTR_DISABLE); gpio_output_set(0, GPIO_ID_PIN(LED_GREEN_PORT), GPIO_ID_PIN(LED_GREEN_PORT), 0); #endif #ifdef LED_BLUE_PORT GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_BLUE_PORT)); gpio_pin_intr_state_set(GPIO_ID_PIN(LED_BLUE_PORT), GPIO_PIN_INTR_DISABLE); gpio_output_set(0, GPIO_ID_PIN(LED_BLUE_PORT), GPIO_ID_PIN(LED_BLUE_PORT), 0); #endif ETS_GPIO_INTR_ENABLE(); }
void ICACHE_FLASH_ATTR user_init() { // Initialize the GPIO subsystem. //UART_init(BIT_RATE_115200, BIT_RATE_115200, 0); //UART_SetPrintPort(UART0); stdout_init(); i2c_master_gpio_init(); user_set_station_config(); pcf8754_i2c_write_byte(I2C_INPUT_ADDRESS, 0); // ================================================= // Initialize GPIO2 and GPIO0 as GPIO // ================================================= PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_GPIO3); PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0RXD_U); gpio_output_set(0, 0, 0, GPIO_ID_PIN(3)); // set set gpio 0 as input ETS_GPIO_INTR_DISABLE(); // Attach interrupt handle to gpio interrupts. ETS_GPIO_INTR_ATTACH(gpio_intr_handler, NULL); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(3)); // clear gpio status gpio_pin_intr_state_set(GPIO_ID_PIN(3), GPIO_PIN_INTR_ANYEDGE); // clear gpio status. ETS_GPIO_INTR_ENABLE(); // Enable interrupts by GPIO // register a callback function to let user code know that system // initialization is complete system_init_done_cb(&post_user_init_func); //Start os task system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen); }
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(); }
/****************************************************************************** * 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 gpio_init() { // Configure switch (relays) INFO("Configure Switch 1 %d\n", SWITCH01_GPIO ); PIN_FUNC_SELECT(SWITCH01_GPIO_MUX, SWITCH01_GPIO_FUNC); set_switch(SWITCH01_GPIO, 0); //GPIO_OUTPUT_SET(SWITCH01_GPIO, 0); INFO("Configure Switch 2 %d\n", SWITCH02_GPIO ); PIN_FUNC_SELECT(SWITCH02_GPIO_MUX, SWITCH02_GPIO_FUNC); set_switch(SWITCH02_GPIO, 0); //GPIO_OUTPUT_SET(SWITCH02_GPIO, 0); INFO("Configure Switch 3 %d\n", SWITCH03_GPIO ); PIN_FUNC_SELECT(SWITCH03_GPIO_MUX, SWITCH03_GPIO_FUNC); set_switch(SWITCH03_GPIO, 0); //GPIO_OUTPUT_SET(SWITCH03_GPIO, 0); //Configure Toggle switches INFO("Configure Toggle 1 %d\n", TOGGLE01_GPIO ); ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts ETS_GPIO_INTR_ATTACH(toggle_changed, 0); // GPIO interrupt handler PIN_FUNC_SELECT(TOGGLE01_GPIO_MUX, TOGGLE01_GPIO_FUNC); // Set function GPIO_DIS_OUTPUT(TOGGLE01_GPIO); // Set as input gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE01_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge //ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts INFO("Configure Toggle 2 %d\n", TOGGLE02_GPIO ); //ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts //ETS_GPIO_INTR_ATTACH(toggle_changed); // GPIO interrupt handler PIN_FUNC_SELECT(TOGGLE02_GPIO_MUX, TOGGLE02_GPIO_FUNC); // Set function GPIO_DIS_OUTPUT(TOGGLE02_GPIO); // Set as input gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE02_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge //ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts INFO("Configure Toggle 3 %d\n", TOGGLE03_GPIO ); //ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts //ETS_GPIO_INTR_ATTACH(toggle_changed); // GPIO interrupt handler PIN_FUNC_SELECT(TOGGLE03_GPIO_MUX, TOGGLE03_GPIO_FUNC); // Set function GPIO_DIS_OUTPUT(TOGGLE03_GPIO); // Set as input gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE03_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts // Configure push button // INFO("Confgiure push button %d\n", BUTTON_GPIO ); // ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts // ETS_GPIO_INTR_ATTACH(button_press, BUTTON_GPIO); // GPIO0 interrupt handler // PIN_FUNC_SELECT(BUTTON_GPIO_MUX, BUTTON_GPIO_FUNC); // Set function // GPIO_DIS_OUTPUT(BUTTON_GPIO); // Set as input // gpio_pin_intr_state_set(GPIO_ID_PIN(BUTTON_GPIO), 2); // Interrupt on negative edge // ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts }
void pin_init0(void) { ETS_GPIO_INTR_DISABLE(); ETS_GPIO_INTR_ATTACH(pin_intr_handler_iram, NULL); // disable all interrupts memset(&MP_STATE_PORT(pin_irq_handler)[0], 0, 16 * sizeof(mp_obj_t)); for (int p = 0; p < 16; ++p) { GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1 << p); SET_TRIGGER(p, 0); } ETS_GPIO_INTR_ENABLE(); }
// Decodes the received IR message // Returns 0 if no data ready, 1 if data ready. // Results of decoding are stored in results bool IRrecv::decode(decode_results *results) { if(false==irparams.isValueReady)return false; ETS_GPIO_INTR_DISABLE(); irparams.isValueReady=false; results->bits = NEC_BITS; results->value = irparams.Value; results->decode_type = NEC; ETS_GPIO_INTR_ENABLE(); return true; }
/* * Initialise GPIO interrupt mode. Optionally in RAM because interrupts are disabled */ void NO_INTR_CODE platform_gpio_intr_init( unsigned pin, GPIO_INT_TYPE type ) { if (platform_gpio_exists(pin)) { 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); ETS_GPIO_INTR_ENABLE(); } }
int ICACHE_FLASH_ATTR gpio_intr_init(unsigned pin, GPIO_INT_TYPE type) { if (pin >= GPIO_PIN_NUM) return -1; //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(); return 1; }
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); }
void interrupt_test(){ // disable interrupts ETS_GPIO_INTR_DISABLE(); uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); // publish that button has been pressed INFO("Button pressed!!"); pb1Transmit(); //gpio_pin_intr_state_set(GPIO_ID_PIN(4), GPIO_PIN_INTR_POSEDGE); // enable interrupts ETS_GPIO_INTR_ENABLE(); }
void user_init(void) { uart_init(BIT_RATE_230400, BIT_RATE_230400); system_set_os_print(1); // enable/disable operating system printout os_sprintf(topic_temp, MQTT_TOPICTEMP, system_get_chip_id()); os_sprintf(topic_hum, MQTT_TOPICHUM, system_get_chip_id()); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13); ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts ETS_GPIO_INTR_ATTACH(interrupt_test, 4); PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO4_U, FUNC_GPIO4); gpio_output_set(0, 0, 0, GPIO_ID_PIN(4)); // Set GPIO12 as input GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(4)); gpio_pin_intr_state_set(GPIO_ID_PIN(4), GPIO_PIN_INTR_ANYEDGE); ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts config_load(); DHTInit(DHT11); MQTT_InitConnection(&mqttClient, config.mqtt_host, config.mqtt_port, config.security); MQTT_InitClient(&mqttClient, config.device_id, config.mqtt_user, config.mqtt_pass, config.mqtt_keepalive, 1); MQTT_InitLWT(&mqttClient, "lwt/", "offline", 0, 0); MQTT_OnConnected(&mqttClient, mqtt_connected_cb); MQTT_OnDisconnected(&mqttClient, mqtt_disconnected_cb); MQTT_OnPublished(&mqttClient, mqtt_published_cb); MQTT_OnData(&mqttClient, mqtt_data_cb); WIFI_Connect(config.sta_ssid, config.sta_pwd, wifi_connect_cb); os_timer_disarm(&dhtTimer); os_timer_setfn(&dhtTimer, (os_timer_func_t *)dhtCb, (void *)0); os_timer_arm(&dhtTimer, DELAY, 1); os_timer_disarm(&hbTimer); os_timer_setfn(&hbTimer, (os_timer_func_t *)application_heartbeat, (void *)0); os_timer_arm(&hbTimer, 60000, 1); INFO("\r\nSystem started ...\r\n"); }
void ICACHE_RAM_ATTR SoftwareSerial::handle_interrupt(void *arg) { uint32_t gpioStatus = GPIO_REG_READ(GPIO_STATUS_ADDRESS); // Clear the interrupt(s) otherwise we get called again GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpioStatus); ETS_GPIO_INTR_DISABLE(); uint8_t pin = 0; while (gpioStatus) { while(!(gpioStatus & (1 << pin))) pin++; gpioStatus &= ~(1 << pin); if (InterruptList[pin]) { // For some reason there is always an interrupt directly after the // stop bit. Detect that by checking if we have a start bit if (digitalRead(pin) == InterruptList[pin]->m_invert) InterruptList[pin]->rxRead(); } } ETS_GPIO_INTR_ENABLE(); }
LOCAL void ICACHE_FLASH_ATTR read_input_pin(void *arg) { uint32 gpio_status; ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts sleepms(15); if(!GPIO_INPUT_GET(PIN_GPIO13)) { button_counter++; console_printf("READ_INPUT_PIN executed..."); console_printf("COUNTER:%d\n",button_counter); os_timer_disarm(&input_pin_timer); // Disarm input pin timer os_timer_setfn(&input_pin_timer, (os_timer_func_t *)handle_pin_press, NULL); // Setup input pin timer os_timer_arm(&input_pin_timer, button_timeout, 1); // Arm input pin timer, 0,5sec, repeat sleepms(button_debounce); // debounce time } gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); //clear interrupt status ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts} }
/****************************************************************************** * FunctionName : i2c_master_gpio_init * Description : config SDA and SCL gpio to open-drain output mode, * mux and gpio num defined in i2c_master.h * Parameters : NONE * Returns : NONE *******************************************************************************/ void ICACHE_FLASH_ATTR i2c_master_gpio_init(void) { ETS_GPIO_INTR_DISABLE() ; // ETS_INTR_LOCK(); PIN_FUNC_SELECT(I2C_MASTER_SDA_MUX, I2C_MASTER_SDA_FUNC); PIN_FUNC_SELECT(I2C_MASTER_SCL_MUX, I2C_MASTER_SCL_FUNC); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_MASTER_SDA_GPIO)); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SCL_GPIO)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SCL_GPIO))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain; GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_MASTER_SCL_GPIO)); I2C_MASTER_SDA_HIGH_SCL_HIGH(); ETS_GPIO_INTR_ENABLE() ; // ETS_INTR_UNLOCK(); i2c_master_init(); }
void mp_hal_pin_config_od(mp_hal_pin_obj_t pin_id) { const pyb_pin_obj_t *pin = &pyb_pin_obj[pin_id]; if (pin->phys_port == 16) { // configure GPIO16 as input with output register holding 0 WRITE_PERI_REG(PAD_XPD_DCDC_CONF, (READ_PERI_REG(PAD_XPD_DCDC_CONF) & 0xffffffbc) | 1); WRITE_PERI_REG(RTC_GPIO_CONF, READ_PERI_REG(RTC_GPIO_CONF) & ~1); WRITE_PERI_REG(RTC_GPIO_ENABLE, (READ_PERI_REG(RTC_GPIO_ENABLE) & ~1)); // input WRITE_PERI_REG(RTC_GPIO_OUT, (READ_PERI_REG(RTC_GPIO_OUT) & ~1)); // out=0 return; } ETS_GPIO_INTR_DISABLE(); PIN_FUNC_SELECT(pin->periph, pin->func); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin->phys_port)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin->phys_port))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); // open drain GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << pin->phys_port)); ETS_GPIO_INTR_ENABLE(); }
/****************************************************************************** * FunctionName : peri_key_init. * Description : initialize key device. * Parameters : none * Returns : none *******************************************************************************/ void ICACHE_FLASH_ATTR peri_single_key_init(uint8 gpio_id,key_function long_press, key_function short_press) { struct key_param *single_key = (struct key_param *)os_zalloc(sizeof(struct key_param)); uint32 gpio_name=tisan_get_gpio_name(gpio_id); uint8 gpio_func=tisan_get_gpio_general_func(gpio_id); single_key->gpio_id = gpio_id; single_key->key_level = 1; single_key->long_press = long_press; single_key->short_press = short_press; ETS_GPIO_INTR_DISABLE(); peri_vibrate_init_NULL(); key_init(gpio_name, gpio_id, gpio_func); ETS_GPIO_INTR_ATTACH(gpio_intr_handler,single_key); ETS_GPIO_INTR_ENABLE(); }
/** * Initialize the ESP8266 hardware environment. * * TODO: we should move stuff from user_main.c here */ void jshInit() { // A call to jshInitDevices is architected as something we have to do. os_printf("> jshInit\n"); // Initialize the ESP8266 GPIO subsystem. gpio_init(); systemTimeInit(); utilTimerInit(); jshInitDevices(); // sanity check for pin function enum to catch ordering changes if (JSHPINSTATE_I2C != 12 || JSHPINSTATE_GPIO_IN_PULLDOWN != 5 || JSHPINSTATE_MASK != 15) { jsError("JshPinState #defines have changed, please update pinStateToString()"); } // Register a callback function to be called for a GPIO interrupt gpio_intr_handler_register(intrHandlerCB, NULL); ETS_GPIO_INTR_ENABLE(); os_printf("< jshInit\n"); } // End of jshInit
void ICACHE_FLASH_ATTR gpio_intr_dispatcher(gpio_intr_handler cb) { uint8 i, level; uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); for (i = 0; i < GPIO_PIN_NUM; i++) { if (pin_int_type[i] && (gpio_status & BIT(pin_num[i])) ) { //disable global interrupt ETS_GPIO_INTR_DISABLE(); //disable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[i]), GPIO_PIN_INTR_DISABLE); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(pin_num[i])); level = 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(pin_num[i])); if(cb){ cb(i, level); } //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[i]), pin_int_type[i]); //enable global interrupt ETS_GPIO_INTR_ENABLE(); } } }