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

/**  * @brief  Initializes build two tasks.  * @param  None  * @retval None  */void ICACHE_FLASH_ATTRat_init(void){  system_os_task(at_recvTask, at_recvTaskPrio, at_recvTaskQueue, at_recvTaskQueueLen);//  system_os_task(at_busyTask, at_busyTaskPrio, at_busyTaskQueue, at_busyTaskQueueLen);  system_os_task(at_procTask, at_procTaskPrio, at_procTaskQueue, at_procTaskQueueLen);}

void dispatch_init1(void){	flash_sector_buffer_use = fsb_free;	system_os_task(uart_task, uart_task_id, uart_task_queue, uart_task_queue_length);	system_os_task(command_task, command_task_id, command_task_queue, command_task_queue_length);	system_os_task(timer_task, timer_task_id, timer_task_queue, timer_task_queue_length);}

void user_init(void){	//gpio_init();	uart_init(BIT_RATE_115200, BIT_RATE_115200);	int at_wifiMode = wifi_get_opmode();	uart0_sendStr("/r/nCustom Server/r/n");	wifi_set_opmode( 2 ); //We broadcast our ESSID, wait for peopel to join.	pTcpServer = (struct espconn *)os_zalloc(sizeof(struct espconn));	pTcpServer->type = ESPCONN_TCP;	pTcpServer->state = ESPCONN_NONE;	pTcpServer->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));	pTcpServer->proto.tcp->local_port = PORT;	espconn_regist_connectcb(pTcpServer, at_tcpserver_listen);	espconn_accept(pTcpServer);	espconn_regist_time(pTcpServer, SERVER_TIMEOUT, 0);	printf("Hello, world.  Starting server./n" );	InitDumbcraft();		os_sprintf( my_server_name, "ESP8266Dumb" );	system_os_task(at_procTask, at_procTaskPrio, at_procTaskQueue, at_procTaskQueueLen);	uart0_sendStr("/r/nCustom Server/r/n");	system_os_post(at_procTaskPrio, 0, 0 );}

//Init function void ICACHE_FLASH_ATTRuser_init(){    // Initialize the GPIO subsystem.    gpio_init();    //Set GPIO2 to output mode    PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);    //Set GPIO2 low    gpio_output_set(0, BIT2, BIT2, 0);    //Disarm timer    os_timer_disarm(&some_timer);    //Setup timer    os_timer_setfn(&some_timer, (os_timer_func_t *)some_timerfunc, NULL);    //Arm the timer    //&some_timer is the pointer    //1000 is the fire time in ms    //0 for once and 1 for repeating    os_timer_arm(&some_timer, 50, 1);        //Start os task    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);}

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

//Init function void ICACHE_FLASH_ATTRuser_init(void){    scan_complete = true;        // Configure the UART0 and UART1 (TX only) to 9600	uart_init(BIT_RATE_115200,BIT_RATE_115200);        //Set station mode    wifi_set_opmode_current( STATION_MODE );        //Disarm timer    os_timer_disarm(&trilaterate_timer);    //Setup timer    os_timer_setfn(&trilaterate_timer, (os_timer_func_t *)scanner, NULL);    //&trilaterate_timer is callback    //delay in ms    //0 for once and 1 for repeating    //This callback timer value can't be too small as a new scan will start before the previous finishes.     //The callback function checks if the scan is complete before starting a new scan.    os_timer_arm(&trilaterate_timer, 10, 1); //100Hz        //Start os task    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);}

//Init function void ICACHE_FLASH_ATTRuser_init(){  // Set up serial logging  uart_div_modify(0, UART_CLK_FREQ / 115200);  // Set GPIO 16 (reset GPIO) to high   gpio_init();  WRITE_PERI_REG(PAD_XPD_DCDC_CONF,    (READ_PERI_REG(PAD_XPD_DCDC_CONF) & 0xffffffbc) | (uint32)0x1);      // mux configuration for XPD_DCDC to output rtc_gpio0  WRITE_PERI_REG(RTC_GPIO_CONF,    (READ_PERI_REG(RTC_GPIO_CONF) & (uint32)0xfffffffe) | (uint32)0x0);  //mux configuration for out enable  WRITE_PERI_REG(RTC_GPIO_ENABLE,    (READ_PERI_REG(RTC_GPIO_ENABLE) & (uint32)0xfffffffe) | (uint32)0x1);        //out enable  WRITE_PERI_REG(RTC_GPIO_OUT,    (READ_PERI_REG(RTC_GPIO_OUT) & (uint32)0xfffffffe) | (uint32)(1));  //Disarm timer  os_timer_disarm(&some_timer);  //Setup timer  os_timer_setfn(&some_timer, (os_timer_func_t *)some_timerfunc, NULL);  // Set the timer for 10s  os_timer_arm(&some_timer, 10000, 1);  os_printf("Resetting in 10s .../n");      //Start os task  system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);}

void user_init(void){    //Init uart    uart_init(BIT_RATE_115200, BIT_RATE_115200);    os_delay_us(1000);    ets_uart_printf("Booting.../r/n");    // i2c    i2c_init();    if(!eeprom_writeByte(0x78,0x01,0x00))    	ets_uart_printf("Write failed/n/r");    //Disarm timer    os_timer_disarm(&sensor_timer);    //Setup timer    os_timer_setfn(&sensor_timer, (os_timer_func_t *)sensor_timerfunc, NULL);    //Arm timer for every 10 sec.    os_timer_arm(&sensor_timer, 5000, 1);    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);}

//Init functionvoid ICACHE_FLASH_ATTRuser_init(){//    uart_init(BIT_RATE_115200, BIT_RATE_115200);    os_printf("Blinky, SDK version:%s/n", system_get_sdk_version());    gdb_stub_init();    // Initialize the GPIO subsystem.    gpio_init();    //Set GPIO2 to output mode    PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);    //Set GPIO2 low    gpio_output_set(0, BIT2, BIT2, 0);    //Disarm timer    os_timer_disarm(&some_timer);    //Setup timer    os_timer_setfn(&some_timer, (os_timer_func_t *)some_timerfunc, NULL);    //Arm the timer    //&some_timer is the pointer    //1000 is the fire time in ms    //0 for once and 1 for repeating    os_timer_arm(&some_timer, 1000, 1);    //Start os task    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    gdb_breakpoint();}

//Init function void ICACHE_FLASH_ATTRuser_init(){    disk_initialize(MMC);    //Start os task    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);}

/**  @brief Serial Bridge task initialize  @param[in] port: network port*/MEMSPACEbridge_task_init(int port){	static struct espconn esp_data_config;	static esp_tcp esp_data_tcp_config;	if(!(uart_send_queue = queue_new(BUFFER_SIZE)))		reset();	if(!(uart_receive_queue = queue_new(BUFFER_SIZE)))		reset();	if(!(tcp_data_send_buffer = malloc(BUFFER_SIZE)))		reset();	wifi_set_sleep_type(NONE_SLEEP_T);	tcp_accept(&esp_data_config, &esp_data_tcp_config, port, tcp_data_connect_callback);	espconn_regist_time(&esp_data_config, 0, 0);	esp_data_tcp_connection = 0;	system_os_task(bridge_task, bridge_task_id, bridge_task_queue, bridge_task_queue_length);	system_os_post(bridge_task_id, 0, 0);	printf("/nbridge task init done/n");}

void mg_ev_mgr_init(struct mg_mgr *mgr) {  DBG(("%p Mongoose init, tq %p", mgr, s_mg_task_queue));  system_os_task(mg_lwip_task, MG_TASK_PRIORITY, s_mg_task_queue,                 MG_TASK_QUEUE_LEN);  os_timer_setfn(&s_poll_tmr, mg_poll_timer_cb, mgr);  os_timer_arm(&s_poll_tmr, MG_POLL_INTERVAL_MS, 1 /* repeat */);}

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);}

/*** Main function ***/void ICACHE_FLASH_ATTR user_init() {	uart_div_modify(0, UART_CLK_FREQ / BAUD);	os_printf("Startup from %d.../r/n", system_get_rst_info()->reason);	gpio_init();	ap_init();	// HTTPD	espFsInit((void*)(webpages_espfs_start));	httpdInit(builtInUrls, 80);	// Set GPIO2 (DCF77 pin) to input, disable pullup	gpio_output_set(0, 0, 0, 2);	PIN_PULLUP_DIS(PERIPHS_IO_MUX_GPIO2_U);	// DCF77 read timer	os_timer_disarm(&dcf_read_timer);	os_timer_setfn(&dcf_read_timer, (os_timer_func_t *) dcf_read_timer_cb, NULL);	os_timer_arm(&dcf_read_timer, 5, 1);	// Second increase timer	os_timer_disarm(&time_inc_timer);	os_timer_setfn(&time_inc_timer, (os_timer_func_t *) time_inc_timer_cb, NULL);	os_timer_arm(&time_inc_timer, 1000, 1);	// DCF77 decode timer: decide wheter 1 or 0	dcf_decode_timer_adjust();	os_printf(" completed!/r/n/r/n");	system_os_task(loop, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);	system_os_post(user_procTaskPrio, 0, 0);}

// WiFi call backLOCAL void ICACHE_FLASH_ATTRwifi_cb(System_Event_t *event){    switch(event->event)    {        case EVENT_STAMODE_CONNECTED:            os_printf("EVENT: STAMODE_CONNECTED!/n");            break;        case EVENT_STAMODE_DISCONNECTED:            os_printf("EVENT: STAMODE_DISCONNECTED!/n");            break;        case EVENT_STAMODE_AUTHMODE_CHANGE:            os_printf("EVENT: STAMODE_AUTHMODE_CHANGE/n");            break;        case EVENT_STAMODE_GOT_IP:            os_printf("Event: EVENT_STAMODE_GOT_IP/n");            system_os_task(connect_to_jarvis, user_procTaskPrio,                     user_procTaskQueue, user_procTaskQueueLen);            system_os_post(user_procTaskPrio, 0, 0 );            break;        case EVENT_SOFTAPMODE_STACONNECTED:            os_printf("Event: EVENT_SOFTAPMODE_STACONNECTED/n");            break;        case EVENT_SOFTAPMODE_STADISCONNECTED:            os_printf("Event: EVENT_SOFTAPMODE_STADISCONNECTED/n");            break;        default:            os_printf("Unexpected event: %d/n", event->event);            break;    }}

void ICACHE_FLASH_ATTR init_GPIOs_intr(void){	if(GPIO_TEST1 == GPIO_TEST2 || GPIO_TEST1 > 15 || GPIO_TEST1 > 15) {		GPIO_TEST1 = 4;		GPIO_TEST2 = 5;	}//	ets_isr_mask(1 << ETS_GPIO_INUM); // запрет прерываний GPIOs	// чтение пользовательских констант (0 < idx < 4) из записей в Flash	GPIO_INT_Counter1 = read_user_const(1);	GPIO_INT_Counter2 = read_user_const(2);	system_os_task(task_GPIOs_intr, GPIOs_intr_TASK_PRIO, GPIOs_intr_taskQueue, GPIOs_intr_TASK_QUEUE_LEN);	uint32 pins_mask = (1<<GPIO_TEST1) | (1<<GPIO_TEST2);	gpio_output_set(0,0,0, pins_mask); // настроить GPIOx на ввод	set_gpiox_mux_func_ioport(GPIO_TEST1); // установить функцию GPIOx в режим порта i/o	set_gpiox_mux_func_ioport(GPIO_TEST2); // установить функцию GPIOx в режим порта i/o//	GPIO_ENABLE_W1TC = pins_mask; // GPIO OUTPUT DISABLE отключить вывод в портах	ets_isr_attach(ETS_GPIO_INUM, GPIOs_intr_handler, NULL);    gpio_pin_intr_state_set(GPIO_TEST1, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?    gpio_pin_intr_state_set(GPIO_TEST2, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?    // разрешить прерывания GPIOs	GPIO_STATUS_W1TC = pins_mask;	ets_isr_unmask(1 << ETS_GPIO_INUM);	GPIO_INTR_INIT = 1;	GPIO_INT_init_flg = 1;	os_printf("GPIOs_intr init (%d,%d) ", GPIO_TEST1, GPIO_TEST2);}

void ICACHE_FLASH_ATTRuser_init(){    void* p;    uint32 now,diff;        //~ system_timer_reinit(); //US_TIMER        uart_init(BIT_RATE_115200, BIT_RATE_115200);        os_printf("/n/nESP8266 IRMP Test v0.3 W.Strobl 20151120/n");    os_printf("F_INTERRUPTS==%d/n",F_INTERRUPTS);        sysinfo();        hw_timer_init(NMI_SOURCE,1);    hw_timer_set_func(irmp_timer);    hw_timer_arm (1000000/F_INTERRUPTS);        // Initialize the GPIO subsystem.    gpio_init();            irmp_init ();        //Start os task        system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    system_os_post(user_procTaskPrio, 0, 0 );        os_printf("IRMP listening .../n");        }

void MQTT_InitClient(MQTT_Client *mqttClient, uint8_t* client_id, uint8_t* client_user, uint8_t* client_pass, uint32_t keepAliveTime){//spam	INFO("MQTT_InitClient/r/n");	os_memset(&mqttClient->connect_info, 0, sizeof(mqtt_connect_info_t));	mqttClient->connect_info.client_id = client_id;	mqttClient->connect_info.username = client_user;	mqttClient->connect_info.password = client_pass;	mqttClient->connect_info.keepalive = keepAliveTime;	mqttClient->connect_info.clean_session = 1;	//mqttClient->mqtt_state = (mqtt_state_t *)os_zalloc(sizeof(mqtt_state_t));	mqttClient->mqtt_state.in_buffer = (uint8_t *)os_zalloc(MQTT_BUF_SIZE);	mqttClient->mqtt_state.in_buffer_length = MQTT_BUF_SIZE;	mqttClient->mqtt_state.out_buffer =  (uint8_t *)os_zalloc(MQTT_BUF_SIZE);	mqttClient->mqtt_state.out_buffer_length = MQTT_BUF_SIZE;	mqttClient->mqtt_state.connect_info = &mqttClient->connect_info;	mqttClient->keepAliveTick = 0;	mqttClient->reconnectTick = 0;	os_timer_disarm(&mqttClient->mqttTimer);	os_timer_setfn(&mqttClient->mqttTimer, (os_timer_func_t *)mqtt_timer, mqttClient);	os_timer_arm(&mqttClient->mqttTimer, 1000, 1);	QUEUE_Init(&mqttClient->msgQueue, QUEUE_BUFFER_SIZE);	system_os_task(MQTT_Task, MQTT_TASK_PRIO, mqtt_procTaskQueue, MQTT_TASK_QUEUE_SIZE);	system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)mqttClient);}

//Init function void ICACHE_FLASH_ATTR user_init(){    uart_init(115200, 115200);    os_delay_us(100);    uart0_sendStr("*** Monitor mode test ***/r/n");        os_printf(" -> Promisc mode setup ... ");    wifi_set_promiscuous_rx_cb(promisc_cb);    wifi_promiscuous_enable(1);    os_printf("done./n");    os_printf(" -> Timer setup ... ");    os_timer_disarm(&channelHop_timer);    os_timer_setfn(&channelHop_timer, (os_timer_func_t *) channelHop, NULL);    os_timer_arm(&channelHop_timer, CHANNEL_HOP_INTERVAL, 1);    os_printf("done./n");        os_printf(" -> Set opmode ... ");    wifi_set_opmode( 0x1 );    os_printf("done./n");    //Start os task    system_os_task(loop, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    os_printf(" -> Init finished!/n/n");}

void user_init(void){	uart_init(BIT_RATE_115200, BIT_RATE_115200);	int at_wifiMode = wifi_get_opmode();	uart0_sendStr("/r/nCustom Server/r/n");	wifi_set_opmode( 2 ); //We broadcast our ESSID, wait for peopel to join.    pUdpServer = (struct espconn *)os_zalloc(sizeof(struct espconn));    if (pUdpServer == NULL)    {      uart0_sendStr("UdpServer Failure/r/n");      return;    }    pUdpServer->type = ESPCONN_UDP;    pUdpServer->state = ESPCONN_NONE;    pUdpServer->proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp));    pUdpServer->proto.udp->local_port = PORT;    pUdpServer->reverse = NULL;    espconn_regist_recvcb(pUdpServer, at_udpserver_recv);    espconn_accept(pUdpServer);	char outbuffer[] = { 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff };	WS2812OutBuffer( outbuffer, sizeof(outbuffer) );	system_os_task(at_procTask, at_procTaskPrio, at_procTaskQueue, at_procTaskQueueLen);	uart0_sendStr("/r/nCustom Server/r/n");	system_os_post(at_procTaskPrio, 0, 0 );}

void ICACHE_FLASH_ATTRCMD_Init(){	INFO("CMD: INIT/r/n");	RINGBUF_Init(&rxRb, rxBuf, sizeof(rxBuf));	PROTO_Init(&rxProto, protoCompletedCb, protoRxBuf, sizeof(protoRxBuf));	system_os_task(CMD_Task, CMD_TASK_PRIO, cmdRecvQueue, CMD_TASK_QUEUE_SIZE);	system_os_post(CMD_TASK_PRIO, 0, 0);}

void serialInit(void){	// Initialize the serial port for USB serial bridge	uartInit(115200, 115200);//	TURN_OFF_SYSTEM_MESSAGES();	TURN_ON_SYSTEM_MESSAGES();	system_os_task(taskHandler, USER_TASK_PRIO_0, taskQueue, taskQueueLen);//	DISPLAY_MENU();	DISPLAY_MENU_W_SPI();}

void ICACHE_FLASH_ATTR user_init(void){    system_update_cpu_freq(160);        i2c_init();    display_init(0x3c);    system_os_task(loop, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    system_os_post(user_procTaskPrio, 0, 0);}

void ICACHE_FLASH_ATTR user_init() {    // Initialize    gpio_init();    uart_init(2400, 2400);    os_delay_us(10000);    //print("/r/n:)/r/n");    if (0 && DEBUG) {        wifi_station_disconnect();        wifi_station_dhcpc_stop();    }    //setup_server();    // -------------------------------------------------------------------------    ets_uart_printf("S");    //Set GPIO2 to output mode    PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);    //Set GPIO2 low    gpio_output_set(0, BIT2, BIT2, 0);    //Disarm timer    os_timer_disarm(&check_timer);    //Setup timer    os_timer_setfn(&check_timer, (os_timer_func_t *)check_timerfunc, NULL);    //Arm the timer    //1000 is the fire time in ms    //0 for once and 1 for repeating    os_timer_arm(&check_timer, 5000, 1); // Start going        //Start os task    system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);    system_init_done_cb(init_done);}

//Main routine. Initialize stdout, the I/O and the webserver and we're done.void user_init(void) {    uart_init();    ioInit();    websocketdInit(8080, &onWsConnection);    //Start os task    system_os_task(rxLoop, RX_PRIO, user_procTaskQueue, RX_QUEUE_LEN);    system_os_post(RX_PRIO, 0, 0 );    os_printf("/nReady/n");}

//Init functionvoid ICACHE_FLASH_ATTRuser_init(){  // Initialize UART0  uart_div_modify(0, UART_CLK_FREQ / 9600);  //Set up the hello world task  system_os_task(task_hello, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);  //send a message to the "hello world" task to activate it  system_os_post(user_procTaskPrio, 0, 0 );}

void ICACHE_FLASH_ATTR user_init(void) {#ifdef DEBUG_SERIAL	uart_init(BIT_RATE_115200,BIT_RATE_115200);	system_set_os_print(TRUE);#else	system_set_os_print(FALSE);#endif	//Create task for main loop    system_os_task(ost_loop, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);    system_os_post(user_procTaskPrio, 0, 0 );    //Create task for the WiFi setup    system_os_task(ost_wifi_setup, 1,user_procTaskQueue, user_procTaskQueueLen);    system_os_post(1, 0, 0 );    //Create task for the WiFi networks scan    system_os_task(ost_wifi_scan, 2,user_procTaskQueue, user_procTaskQueueLen);    system_os_post(2, 0, 0 );}

static void ICACHE_FLASH_ATTR startUp() {	TESTP("/n%s ( %s - %s ) starting .../n", "MQTT Bridge", wifi_station_get_hostname(), version);	INFOP("wifi_get_phy_mode = %d/n", wifi_get_phy_mode());//	os_timer_disarm(&uartTimer);//	os_timer_setfn(&uartTimer, (os_timer_func_t *) uartTimerCb, (void *) 0);//	os_timer_arm(&uartTimer, 10 * 1000, true);	if ( !system_os_task(backgroundTask, USER_TASK_PRIO_1, taskQueue, QUEUE_SIZE))		ERRORP("Can't set up background task/n");	lastAction = INIT_DONE;}

void user_init(void){	uart_init(BIT_RATE_115200, BIT_RATE_115200);	uart0_sendStr("/r/nesp8266 ws2812 driver/r/n");//	int opm = wifi_get_opmode();//	if( opm == 1 ) need_to_switch_opmode = 120;//	wifi_set_opmode_current(2);//Uncomment this to force a system restore.//	system_restore();	CSSettingsLoad( 0 );	CSPreInit();    pUdpServer = (struct espconn *)os_zalloc(sizeof(struct espconn));	ets_memset( pUdpServer, 0, sizeof( struct espconn ) );	espconn_create( pUdpServer );	pUdpServer->type = ESPCONN_UDP;	pUdpServer->proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp));	pUdpServer->proto.udp->local_port = 7777;	espconn_regist_recvcb(pUdpServer, udpserver_recv);	if( espconn_create( pUdpServer ) )	{		while(1) { uart0_sendStr( "/r/nFAULT/r/n" ); }	}	CSInit();	SetServiceName( "ws2812" );	AddMDNSName( "cn8266" );	AddMDNSName( "ws2812" );	AddMDNSService( "_http._tcp", "An ESP8266 Webserver", 80 );	AddMDNSService( "_ws2812._udp", "WS2812 Driver", 7777 );	AddMDNSService( "_cn8266._udp", "ESP8266 Backend", 7878 );	//Add a process	system_os_task(procTask, procTaskPrio, procTaskQueue, procTaskQueueLen);	//Timer example	os_timer_disarm(&some_timer);	os_timer_setfn(&some_timer, (os_timer_func_t *)myTimer, NULL);	os_timer_arm(&some_timer, 100, 1);	ws2812_init();	uint8_t ledout[] = { 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00 };	ws2812_push( ledout, sizeof( ledout ) );	system_os_post(procTaskPrio, 0, 0 );}

//Init functionvoid ICACHE_FLASH_ATTRuser_init(){	uart_init(BIT_RATE_115200, BIT_RATE_115200);	os_delay_us(100000);	wifiInit();		//Start os task	system_os_task(loop, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);		system_os_post(user_procTaskPrio, 0, 0);}