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

static char * ICACHE_FLASH_ATTR readRx(RcvMsgBuff *rxBfr) {	static int idx = 0;	static char bfr[400];	char c;	ETS_UART_INTR_DISABLE();	while (rxBfr->count > 0) {		c = *(rxBfr->pReadPos);		rxBfr->count--;		rxBfr->pReadPos++;        if (rxBfr->pReadPos == (rxBfr->pRcvMsgBuff + RX_BUFF_SIZE)) {        	rxBfr->pReadPos = rxBfr->pRcvMsgBuff ;        }		if (c == '/r' || c == '/n') {			if (idx > 0) { // Otherwise ignore blank line				bfr[idx] = 0;				idx = 0;				ETS_UART_INTR_ENABLE();				return bfr;			}		} else {			if (idx < sizeof(bfr)-3) {				bfr[idx++] = c;			} else {				ERRORP("Bfr overflow/n");			}		}	}    ETS_UART_INTR_ENABLE();	return NULL;}

/**  * @brief  Setup commad of set wifi mode.  * @param  id: commad id number  * @param  pPara: AT input param  * @retval None  */void ICACHE_FLASH_ATTRat_setupCmdCwmode(uint8_t id, char *pPara){  uint8_t mode;  char temp[32];  pPara++;  mode = atoi(pPara);  if(mode == at_wifiMode)  {    uart0_sendStr("no change/r/n");    return;  }  if((mode >= 1) && (mode <= 3))  {    ETS_UART_INTR_DISABLE();    wifi_set_opmode(mode);    ETS_UART_INTR_ENABLE();    at_backOk;//    system_restart();  }  else  {    at_backError;  }}

size_t uart_resize_rx_buffer(uart_t* uart, size_t new_size){    if(uart == NULL || !uart->rx_enabled) {        return 0;    }    if(uart->rx_buffer->size == new_size) {        return uart->rx_buffer->size;    }    uint8_t * new_buf = (uint8_t*)malloc(new_size);    if(!new_buf) {        return uart->rx_buffer->size;    }    size_t new_wpos = 0;    ETS_UART_INTR_DISABLE();    while(uart_rx_available(uart) && new_wpos < new_size) {        new_buf[new_wpos++] = uart_read_char(uart);    }    uint8_t * old_buf = uart->rx_buffer->buffer;    uart->rx_buffer->rpos = 0;    uart->rx_buffer->wpos = new_wpos;    uart->rx_buffer->size = new_size;    uart->rx_buffer->buffer = new_buf;    free(old_buf);    ETS_UART_INTR_ENABLE();    return uart->rx_buffer->size;}

/**  * @brief  Uart receive task.  * @param  events: contain the uart receive data  * @retval None  */static void ICACHE_FLASH_ATTR ///////at_recvTask(os_event_t *events){    uint8_t temp;  while(READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S))  {        temp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;               if (ser_count>64) ser_count = 0;    ser[ser_count] = temp;    ser_count++;    ser[64] = ser_count;       feedwdt();  }    if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_FULL_INT_ST))  {    WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);  }  else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_TOUT_INT_ST))  {    WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);  }  ETS_UART_INTR_ENABLE();}

//Read from UART0(requires special uart.c!)static void ICACHE_FLASH_ATTR recvTask(os_event_t *events){	uint8_t c, i;  char ch[1000];  c = 0;  i = 0;    //uart0_tx_buffer("uart",4);  	while (READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S))	{		WRITE_PERI_REG(0X60000914, 0x73); //WTD		c = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF; 				ch[i] = c;		i++;  }	if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_FULL_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);	}	else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_TOUT_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);	}	ETS_UART_INTR_ENABLE();		// send to Server if available	if (pconn && i != 0) 	{	  espconn_sent(pconn, ch, i);	}		}

/**  * @brief  Setup commad of join to wifi ap.  * @param  id: commad id number  * @param  pPara: AT input param  * @retval None  */static void ICACHE_FLASH_ATTR wifi_connect(char * ssid, char * password, char * bssid){	char temp[64];	struct station_config stationConf;	int8_t len;	connect_attempts++;	//wifi_station_get_config(&stationConf);	os_bzero(&stationConf, sizeof(struct station_config));	os_memcpy(&stationConf.ssid, ssid, os_strlen(ssid));	//os_memcpy(&stationConf.password, password, os_strlen(password));	os_memcpy(&stationConf.bssid, bssid, 6);	stationConf.bssid_set = 1;    wifi_station_disconnect();    os_printf("stationConf.ssid: -%s-/r/n", stationConf.ssid);    os_printf("stationConf.password: -%s-/r/n", stationConf.password);    ETS_UART_INTR_DISABLE();    wifi_station_set_config(&stationConf);    ETS_UART_INTR_ENABLE();    wifi_station_connect();    os_timer_disarm(&at_japDelayChack);    os_timer_setfn(&at_japDelayChack, (os_timer_func_t *)at_japChack, NULL);    os_timer_arm(&at_japDelayChack, 3000, 0);}

/** * Setting the ESP8266 station to connect to the AP (which is recorded) * automatically or not when powered on. Enable auto-connect by default. * @param autoConnect bool * @return if saved */bool ESP8266WiFiSTAClass::setAutoConnect(bool autoConnect) {    bool ret;    ETS_UART_INTR_DISABLE();    ret = wifi_station_set_auto_connect(autoConnect);    ETS_UART_INTR_ENABLE();    return ret;}

static void ICACHE_FLASH_ATTR recvTask(os_event_t *events){	uint8_t i;	while (READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S))	{		WRITE_PERI_REG(0X60000914, 0x73); //WTD		uint16 length = 0;		while ((READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S)) && (length<MAX_UARTBUFFER))			uartbuffer[length++] = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;		for (i = 0; i < MAX_CONN; ++i)			if (connData[i].conn) 				espbuffsent(&connData[i], uartbuffer, length);			}	if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_FULL_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);	}	else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_TOUT_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);	}	ETS_UART_INTR_ENABLE();}

void user_init(void){		ETS_UART_INTR_DISABLE();		UART_SetBaudrate(UART0, BIT_RATE_9600);		UART_ResetFifo(UART0);		UART_SetBaudrate(UART1, BIT_RATE_115200);		UART_ResetFifo(UART1);		flash_param_init();		flash_param = flash_param_get();		emsRxBuf = allocateRcvMsgBuff();		uart_init(BIT_RATE_9600, BIT_RATE_115200);		rtc_clock_calibration = system_rtc_clock_cali_proc();			// get RTC clock period		os_printf("rtc_clock_calibration: %0x/n", rtc_clock_calibration >>12 );		os_printf("system_get_rtc_time:   %d/n", system_get_rtc_time());		os_printf("system_get_time:       %d/n", system_get_time());		serverInit(flash_param->port);		wifi_set_sleep_type(LIGHT_SLEEP_T);		system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);		ETS_UART_INTR_ENABLE();}

int ESP8266WiFiClass::disconnect(bool wifioff){    struct station_config conf;    *conf.ssid = 0;    *conf.password = 0;    ETS_UART_INTR_DISABLE();    if (_persistent)        wifi_station_set_config(&conf);    else        wifi_station_set_config_current(&conf);    wifi_station_disconnect();    ETS_UART_INTR_ENABLE();    if(wifioff) {        _useClientMode = false;        if(_useApMode) {            // turn on AP            _mode(WIFI_AP);        } else {            // turn wifi off            _mode(WIFI_OFF);        }    }    return 0;}

//// modified for LASS , receive data from UART0 (sensor)static void ICACHE_FLASH_ATTR recvTask(os_event_t *events){	uint8_t i;	uint16 length = 0;  //char* p;  //p=&LASSstring[0];	while (READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S))	{		WRITE_PERI_REG(0X60000914, 0x73); //WTD    //length=0;		while ((READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S)) && (length<MAX_UARTBUFFER))			uartbuffer[length++] = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;		//refer to Plantower PMS5003 			p1_0 = (uint32)uartbuffer[4]*256+(uint32)uartbuffer[5];			p2_5 = (uint32)uartbuffer[6]*256+(uint32)uartbuffer[7];			p10_0 = (uint32)uartbuffer[8]*256+(uint32)uartbuffer[9];	}	if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_FULL_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);	}	else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(UART0)) & UART_RXFIFO_TOUT_INT_ST))	{		WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);	}    INFO("%s/r/n",LASSstring);	//uart_rx_intr_enable(UART0);  ETS_UART_INTR_ENABLE();  ///// BUG ! TX malfunctioned!}

/** * set new mode * @param m WiFiMode_t */bool ESP8266WiFiGenericClass::mode(WiFiMode_t m) {    if(_persistent){        if(wifi_get_opmode() == (uint8) m && wifi_get_opmode_default() == (uint8) m){            return true;        }    } else if(wifi_get_opmode() == (uint8) m){        return true;    }    bool ret = false;    if (m != WIFI_STA && m != WIFI_AP_STA)        // calls lwIP's dhcp_stop(),        // safe to call even if not started        wifi_station_dhcpc_stop();    ETS_UART_INTR_DISABLE();    if(_persistent) {        ret = wifi_set_opmode(m);    } else {        ret = wifi_set_opmode_current(m);    }    ETS_UART_INTR_ENABLE();    return ret;}

void ESP8266WiFiClass::mode(WiFiMode m){    if(wifi_get_opmode() == (uint8)m) {        return;    }    ETS_UART_INTR_DISABLE();    wifi_set_opmode(m);    ETS_UART_INTR_ENABLE();}

void ESP8266WiFiClass::softAP(const char* ssid, const char* passphrase, int channel, int ssid_hidden){    _useApMode = true;    if(_useClientMode) {        // turn on AP+STA mode        _mode(WIFI_AP_STA);    } else {        // turn on STA mode        _mode(WIFI_AP);    }    if(!ssid || *ssid == 0 || strlen(ssid) > 31) {        // fail SSID too long or missing!        return;    }    if(passphrase && strlen(passphrase) > 63) {        // fail passphrase to long!        return;    }    struct softap_config conf;    wifi_softap_get_config(&conf);    strcpy(reinterpret_cast<char*>(conf.ssid), ssid);    conf.channel = channel;    conf.ssid_len = strlen(ssid);    conf.ssid_hidden = ssid_hidden;    conf.max_connection = 4;    conf.beacon_interval = 100;    if (!passphrase || strlen(passphrase) == 0)    {        conf.authmode = AUTH_OPEN;        *conf.password = 0;    }    else    {        conf.authmode = AUTH_WPA2_PSK;        strcpy(reinterpret_cast<char*>(conf.password), passphrase);    }    struct softap_config conf_current;    wifi_softap_get_config(&conf_current);    if (softap_config_equal(conf, conf_current))    {        DEBUGV("softap config unchanged");        return;    }    ETS_UART_INTR_DISABLE();    if (_persistent)        wifi_softap_set_config(&conf);    else        wifi_softap_set_config_current(&conf);    ETS_UART_INTR_ENABLE();}

/**  * @brief  Setup commad of module as wifi ap.  * @param  id: commad id number  * @param  pPara: AT input param  * @retval None  */void ICACHE_FLASH_ATTRat_setupCmdCwsap(uint8_t id, char *pPara){  char temp[64];  int8_t len;  struct softap_config apConfig;  wifi_softap_get_config(&apConfig);  if(at_wifiMode == STATION_MODE)  {    at_backError;    return;  }  pPara++;  len = at_dataStrCpy(apConfig.ssid, pPara, 32);  if(len < 1)  {    uart0_sendStr("ssid ERROR/r/n");    return;  }  pPara += (len+3);  len = at_dataStrCpy(apConfig.password, pPara, 64);  if(len < 8)  {    uart0_sendStr("pwd ERROR/r/n");    return;  }  pPara += (len+3);  apConfig.channel = atoi(pPara);  if(apConfig.channel<1 || apConfig.channel>13)  {    uart0_sendStr("ch ERROR/r/n");    return;  }  pPara++;  pPara = strchr(pPara, ',');  pPara++;  apConfig.authmode = atoi(pPara);  if(apConfig.authmode >= 5)  {    uart0_sendStr("s ERROR/r/n");    return;  }//  os_sprintf(temp,"%s,%s,%d,%d/r/n",//             apConfig.ssid,//             apConfig.password,//             apConfig.channel,//             apConfig.authmode);//  uart0_sendStr(temp);  ETS_UART_INTR_DISABLE();  wifi_softap_set_config(&apConfig);  ETS_UART_INTR_ENABLE();  at_backOk;//  system_restart();}

void EEPROMClass::commit(){    if (!_size || !_dirty)        return;    ETS_UART_INTR_DISABLE();    spi_flash_erase_sector(CONFIG_SECTOR);    spi_flash_write(CONFIG_ADDR, reinterpret_cast<uint32_t*>(_data), _size);    ETS_UART_INTR_ENABLE();    _dirty = false;}

int ESP8266WiFiClass::disconnect(){    struct station_config conf;    *conf.ssid = 0;    *conf.password = 0;    ETS_UART_INTR_DISABLE();    wifi_station_set_config(&conf);    wifi_station_disconnect();    ETS_UART_INTR_ENABLE();    return 0;}

/****************************************************************************** * FunctionName : uart_init * Description  : user interface for init uart * Parameters   : UartBautRate uart0_br - uart0 bautrate *                UartBautRate uart1_br - uart1 bautrate * Returns      : NONE *******************************************************************************/void ICACHE_FLASH_ATTR uart_init (UartBautRate uart0_br, UartBautRate uart1_br){	// rom use 74880 baut_rate, here reinitialize	UartDev.baut_rate = uart0_br;	uart_config (UART0);	UartDev.baut_rate = uart1_br;	uart_config (UART1);	ETS_UART_INTR_ENABLE();	// install uart1 putc callback	os_install_putc1 ((void *)uart1_write_char);}

/****************************************************************************** * FunctionName : user_init * Description  : entry of user application, init user function here * Parameters   : none * Returns      : none*******************************************************************************/void user_init(void){    bool ret;    PIN_FUNC_SELECT(LED_GPIO_MUX, LED_GPIO_FUNC);    xUARTQueue = xQueueCreate(128, sizeof(char));    uart_init_new();    UART_intr_handler_register(&uart0_rx_intr_handler, &xUARTQueue);    ETS_UART_INTR_ENABLE();    printf("SDK version:%s/n", system_get_sdk_version());    GPIO_OUTPUT_SET(LED_GPIO, 0);      //Set  station mode   wifi_set_opmode(STATIONAP_MODE);   // ESP8266 connect to router.   // user_set_station_config();   // Setup TCP server      wifi_station_set_auto_connect(0);    // wifi_station_set_reconnect_policy(0);    printf("Wifi Button example program. /r/n");    if (!read_user_config(&user_config))    {        ret = wifi_set_opmode(STATIONAP_MODE);        DBG("wifi_set_opmode returns %d op_mode now %d/r/n", ret, wifi_get_opmode());        // user_set_station_config();        user_tcpserver_init(SERVER_LOCAL_PORT);        // user_tcpserver_init(SERVER_LOCAL_PORT);        wifi_station_set_auto_connect(1);    }    else    {        printf ("No valid config/r/n");    }    printf("Hiya");    // sys_init_timing();   lwip_init();   // while(1);   // xTaskCreate(check_input, "input", 256, &xUARTQueue, 3, NULL);   // xTaskCreate(helloworld, "hw", configMINIMAL_STACK_SIZE, NULL, 2, NULL);   // xTaskCreate(blinky, "bl", configMINIMAL_STACK_SIZE, NULL, 2, NULL);}

void ICACHE_FLASH_ATTR flash_read() {    os_printf("flashRead() size-%d/n", sizeof(FlashData));    flashData->magic =0;    ETS_UART_INTR_DISABLE();    spi_flash_read((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,                (uint32 *)flashData, sizeof(FlashData));    ETS_UART_INTR_ENABLE();    if (flashData->magic != MAGIC_NUM)    {    	os_printf("ReadFlash ERROR!/n");    	initFlash();    }}

int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t channel, uint8_t bssid[6]){    _useClientMode = true;    if(_useApMode) {        // turn on AP+STA mode        mode(WIFI_AP_STA);    } else {        // turn on STA mode        mode(WIFI_STA);    }    if(!ssid || *ssid == 0x00 || strlen(ssid) > 31) {        // fail SSID to long or missing!        return WL_CONNECT_FAILED;    }    if(passphrase && strlen(passphrase) > 63) {        // fail passphrase to long!        return WL_CONNECT_FAILED;    }    struct station_config conf;    strcpy(reinterpret_cast<char*>(conf.ssid), ssid);    if (passphrase) {        strcpy(reinterpret_cast<char*>(conf.password), passphrase);    } else {        *conf.password = 0;    }    if (bssid) {        conf.bssid_set = 1;        memcpy((void *) &conf.bssid[0], (void *) bssid, 6);    } else {        conf.bssid_set = 0;    }    ETS_UART_INTR_DISABLE();    wifi_station_set_config(&conf);    wifi_station_connect();    ETS_UART_INTR_ENABLE();    if(channel > 0 && channel <= 13) {        wifi_set_channel(channel);    }    if(!_useStaticIp)        wifi_station_dhcpc_start();    return status();}

void ICACHE_FLASH_ATTR flash_write() {    os_printf("flashWrite() size-%d/n", sizeof(FlashData));    ETS_UART_INTR_DISABLE();    spi_flash_erase_sector(PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE);    spi_flash_write(0x3c000, (uint32 *)flashData, sizeof(FlashData));    ETS_UART_INTR_ENABLE();  // spi_flash_read(0x3C000, (uint32 *) settings, 1024);   // spi_flash_erase_sector(0x3C);  // spi_flash_write(0x3C000,(uint32 *)settings,1024); }

// Turn UART interrupts off and poll for nchars or until timeout hitsuint16_t ICACHE_FLASH_ATTRuart0_rx_poll(char *buff, uint16_t nchars, uint32_t timeout_us) {  ETS_UART_INTR_DISABLE();  uint16_t got = 0;  uint32_t start = system_get_time(); // time in us  while (system_get_time()-start < timeout_us) {    while (READ_PERI_REG(UART_STATUS(UART0)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S)) {      buff[got++] = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;      if (got == nchars) goto done;    }  }done:  ETS_UART_INTR_ENABLE();  return got;}

/**  * @brief  Setup commad of join to wifi ap.  * @param  id: commad id number  * @param  pPara: AT input param  * @retval None  */void ICACHE_FLASH_ATTRat_setupCmdCwjap(uint8_t id, char *pPara){  char temp[64];  struct station_config stationConf;  int8_t len;  if (at_wifiMode == SOFTAP_MODE)  {    at_backError;    return;  }  pPara++;  len = at_dataStrCpy(&stationConf.ssid, pPara, 32);  if(len != -1)  {    pPara += (len+3);    len = at_dataStrCpy(&stationConf.password, pPara, 64);  }  if(len != -1)  {    wifi_station_disconnect();    mdState = m_wdact;    ETS_UART_INTR_DISABLE();    wifi_station_set_config(&stationConf);    ETS_UART_INTR_ENABLE();    wifi_station_connect();//    if(1)//    {//      mdState = m_wact;//    }//    os_sprintf(temp,"%s:%s,%s/r/n",//               at_fun[id].at_cmdName,//               stationConf.ssid,//               stationConf.password);//    uart0_sendStr(temp);    os_timer_disarm(&at_japDelayChack);    os_timer_setfn(&at_japDelayChack, (os_timer_func_t *)at_japChack, NULL);    os_timer_arm(&at_japDelayChack, 3000, 0);    specialAtState = FALSE;  }  else  {    at_backError;  }}

/****************************************************************************** * FunctionName : uart_init * Description  : user interface for init uart * Parameters   : UartBautRate uart0_br - uart0 bautrate *                UartBautRate uart1_br - uart1 bautrate * Returns      : NONE*******************************************************************************/void ICACHE_FLASH_ATTRuart_init(UartBautRate uart0_br, UartBautRate uart1_br){  // rom use 74880 baut_rate, here reinitialize  UartDev.baut_rate = uart0_br;  uart_config(UART0);  UartDev.baut_rate = uart1_br;  uart_config(UART1);  for (int i=0; i<4; i++) uart_tx_one_char(UART1, '/n');  for (int i=0; i<4; i++) uart_tx_one_char(UART0, '/n');  ETS_UART_INTR_ENABLE();  // install uart1 putc callback  os_install_putc1((void *)uart0_write_char);  uart_recvTaskNum = register_usr_task(uart_recvTask);}

/** * set new mode * @param m WiFiMode_t */bool ESP8266WiFiGenericClass::mode(WiFiMode_t m) {    if(wifi_get_opmode() == (uint8) m) {        return true;    }    bool ret = false;    ETS_UART_INTR_DISABLE();    if(_persistent) {        ret = wifi_set_opmode(m);    } else {        ret = wifi_set_opmode_current(m);    }    ETS_UART_INTR_ENABLE();    return ret;}

/**  * @brief  Client send over callback function.  * @param  arg: contain the ip link information  * @retval None  */static void ICACHE_FLASH_ATTRat_tcpclient_sent_cb(void *arg){//  os_free(at_dataLine);//  os_printf("send_cb/r/n");  if(IPMODE == TRUE)  {    ipDataSendFlag = 0;    os_timer_disarm(&at_delayChack);    os_timer_arm(&at_delayChack, 20, 0);    system_os_post(at_recvTaskPrio, 0, 0); ////    ETS_UART_INTR_ENABLE();    return;  }  uart0_sendStr("/r/nSEND OK/r/n");  specialAtState = TRUE;  at_state = at_statIdle;}