自学教程：C++ ETS_GPIO_INTR_ENABLE函数代码示例

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_ATTRi2c_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(' ');}

// initializationvoid 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_ATTRkey_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_ATTReasygpio_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_ATTRi2c_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_ATTRbutton_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_ATTRuser_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_ATTRgpio_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 resultsbool 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_ATTRbuttons_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_ATTRperi_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();		}	}}