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

/*-----------------------------------------------------------------------------------*/err_tunixif_init_client(struct netif *netif){  struct unixif *unixif;  unixif = (struct unixif *)malloc(sizeof(struct unixif));  if (!unixif) {    return ERR_MEM;  }  netif->state = unixif;  netif->name[0] = 'u';  netif->name[1] = 'n';  netif->output = unixif_output;  unixif->fd = unix_socket_client("/tmp/lwip-lower");  if (unixif->fd == -1) {    perror("unixif_init");    abort();  }  unixif->q = list_new(UNIXIF_QUEUELEN);  if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {    LWIP_ASSERT("Failed to create semaphore", 0);  }  sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  return ERR_OK;}

/*-----------------------------------------------------------------------------------*/static voidmain_thread(void *arg){  sys_sem_t sem;  LWIP_UNUSED_ARG(arg);  if(sys_sem_new(&sem, 0) != ERR_OK) {    LWIP_ASSERT("Failed to create semaphore", 0);  }  tcpip_init(tcpip_init_done, &sem);  sys_sem_wait(&sem);  printf("TCP/IP initialized./n");#if LWIP_SOCKET  if(ping_flag) {    sys_thread_new("ping_thread", ping_thread, NULL, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  }#endif  printf("Applications started./n");#ifdef MEM_PERF  mem_perf_init("/tmp/memstats.client");#endif /* MEM_PERF */#if 0    stats_display();#endif  /* Block forever. */  sys_thread_new("pppos_rx_thread", pppos_rx_thread, NULL, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  sys_sem_wait(&sem);}

void ucos_test(void){	char *str1 = "!";	char *str2 = "?";	   OSInit();	//mbox = OSQCreate (queue, sizeof(queue)/sizeof(queue[0]));	//dprintf("OSQCreate return:0x%8x/r/n",mbox);		/*install os timer*/		//sys_timer_start();    //OSTaskCreate(task1,(void *)str1,&task1_stk[1024],11);    //OSTaskCreate(task2,(void *)str2,&task2_stk[1024],10);    //OSTaskCreate(task3,(void *)"*",&task3_stk[1024],11);    //debug_enable = 1;	sys_thread_new("thread1", task1, str1, 1024, 8);	sys_thread_new("thread2", task2, str2, 1024, 9);	sys_thread_new("thread3", task3, str2, 1024, 10);	sys_mbox_new(&sys_mbox, 30);	//sys_sem_new(&sys_sem, 0);	sys_mutex_new(&sys_mutex);    OSStart();	    while(1)    {        dprintf("os runtime error");    }}

voidlaunch_app_threads(){    /* start webserver thread */    if (INCLUDE_WEB_SERVER)        sys_thread_new("httpd", web_application_thread, 0,                       THREAD_STACKSIZE,                       DEFAULT_THREAD_PRIO);    /* start echo server thread */    if (INCLUDE_ECHO_SERVER)        sys_thread_new("echod", echo_application_thread, 0,                       THREAD_STACKSIZE,                       DEFAULT_THREAD_PRIO);    /* start tftp server thread */    if (INCLUDE_TFTP_SERVER)        sys_thread_new("tftpd", tftpserver_application_thread, 0,                       THREAD_STACKSIZE,                       DEFAULT_THREAD_PRIO);    /* start echo server thread */    if (INCLUDE_RXPERF_SERVER)        sys_thread_new("rxperfd", rx_application_thread, 0,                       THREAD_STACKSIZE,                       DEFAULT_THREAD_PRIO);    /* start echo server thread */    if (INCLUDE_TXPERF_CLIENT)        sys_thread_new("txperfd", tx_application_thread, 0,                       THREAD_STACKSIZE,                       DEFAULT_THREAD_PRIO);}

void socket_examples_init(void){#if SOCKET_EXAMPLES_RUN_PARALLEL  sys_thread_new("sockex_nonblocking_connect", sockex_nonblocking_connect, NULL, 0, 0);  sys_thread_new("sockex_testrecv", sockex_testrecv, NULL, 0, 0);  sys_thread_new("sockex_testtwoselects", sockex_testtwoselects, NULL, 0, 0);#else  sys_thread_new("socket_example_test", socket_example_test, NULL, 0, 0);#endif}

/*-----------------------------------------------------------------------------------*/err_tunixif_init_server(struct netif *netif){  int fd, fd2;  struct sockaddr_un addr;  socklen_t len;  struct unixif *unixif;  fd = unix_socket_server("/tmp/lwip-lower");  if (fd == -1) {    perror("unixif_server");    abort();  }  LWIP_DEBUGF(UNIXIF_DEBUG, ("unixif_server: fd %d/n", fd));//  /* device capabilities */  /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */  netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;//  unixif = (struct unixif *)malloc(sizeof(struct unixif));  if (!unixif) {    return ERR_MEM;  }  // unixif-struct is stored in state-field of the netif-structure  netif->state = unixif;  netif->name[0] = 'u';  netif->name[1] = 'n';  netif->output = unixif_output;  unixif->q = list_new(UNIXIF_QUEUELEN);  len = sizeof(addr);  fd2 = accept(fd, (struct sockaddr *)&addr, &len);  if (fd2 == -1) {    perror("unixif_accept");    abort();  }  LWIP_DEBUGF(UNIXIF_DEBUG, ("unixif_accept: %d/n", fd2));  unixif->fd = fd2;  if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {    LWIP_ASSERT("Failed to create semaphore", 0);  }  sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  return ERR_OK;}

err_t eth_arch_enetif_init(struct netif *netif){    ethernet_cfg_t ethcfg;    /* set MAC hardware address */#if (MBED_MAC_ADDRESS_SUM != MBED_MAC_ADDR_INTERFACE)    netif->hwaddr[0] = MBED_MAC_ADDR_0;    netif->hwaddr[1] = MBED_MAC_ADDR_1;    netif->hwaddr[2] = MBED_MAC_ADDR_2;    netif->hwaddr[3] = MBED_MAC_ADDR_3;    netif->hwaddr[4] = MBED_MAC_ADDR_4;    netif->hwaddr[5] = MBED_MAC_ADDR_5;#else    mbed_mac_address((char *)netif->hwaddr);#endif    netif->hwaddr_len = ETHARP_HWADDR_LEN;    /* maximum transfer unit */    netif->mtu = 1500;    /* device capabilities */    netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP;#if LWIP_NETIF_HOSTNAME    /* Initialize interface hostname */    netif->hostname = "lwiprza1";#endif /* LWIP_NETIF_HOSTNAME */    netif->name[0] = 'e';    netif->name[1] = 'n';    netif->output     = rza1_etharp_output;    netif->linkoutput = rza1_low_level_output;    /* Initialize the hardware */    ethcfg.int_priority = 6;    ethcfg.recv_cb      = &rza1_recv_callback;    ethcfg.ether_mac    = (char *)netif->hwaddr;    ethernetext_init(&ethcfg);    /* semaphore */    sys_sem_new(&recv_ready_sem, 0);    /* task */    sys_thread_new("rza1_recv_task", rza1_recv_task, netif, DEFAULT_THREAD_STACKSIZE, RECV_TASK_PRI);    sys_thread_new("rza1_phy_task", rza1_phy_task, netif, DEFAULT_THREAD_STACKSIZE, PHY_TASK_PRI);    return ERR_OK;}

/* ------------------------------------------------------------------------------------------------------ *									      socket_examples_init() * * Description : socket initialisation function. * * Argument(s) : none. * */void TaskSocket_Create(void){//	sys_thread_new("sockex_nonblocking_connect", sockex_nonblocking_connect, NULL, 128, 2);//	sys_thread_new("sockex_testrecv", sockex_testrecv, NULL, 128, 3);//	sys_thread_new("sockex_app", sockex_app, NULL, 128, 4);	sys_thread_new("sockex_selects", sockex_selects, NULL, 256, 2);}

static voidlow_level_init(struct netif *netif){//  struct ethernetif *ethernetif = netif->state;  unsigned portBASE_TYPE uxPriority;  /* maximum transfer unit */  netif->mtu = netifMTU;    /* broadcast capability */  netif->flags = NETIF_FLAG_BROADCAST;   /* Do whatever else is needed to initialize interface. */    xNetIf = netif;  /* Initialise the MACB.  This routine contains code that polls status bits.  If the Ethernet cable is not plugged in then this can take a considerable  time.  To prevent this starving lower priority tasks of processing time we  lower our priority prior to the call, then raise it back again once the  initialisation is complete. */  uxPriority = uxTaskPriorityGet( NULL );  vTaskPrioritySet( NULL, tskIDLE_PRIORITY );  while( xMACBInit(&AVR32_MACB) == FALSE )  {    __asm__ __volatile__ ( "nop" );  }  vTaskPrioritySet( NULL, uxPriority );  /* Create the task that handles the MACB. */  // xTaskCreate( ethernetif_input, ( signed portCHAR * ) "ETH_INT", netifINTERFACE_TASK_STACK_SIZE, NULL, netifINTERFACE_TASK_PRIORITY, NULL );  sys_thread_new( ethernetif_input, NULL, netifINTERFACE_TASK_PRIORITY );}

/* * Arguments: function, [arguments (any) ...] * Returns: [thread_udata] */static intthread_run (lua_State *L){  struct sys_thread *td, *vmtd = sys_thread_get();  if (!vmtd) luaL_argerror(L, 0, "Threading not initialized");  luaL_checktype(L, 1, LUA_TFUNCTION);  td = sys_thread_new(L, vmtd, NULL, 1);  if (!td) goto err;  lua_insert(L, 1);  /* thread_udata */  /* function and arguments */  {    const int n = lua_gettop(L) - 1;    luaL_checkstack(td->L, n, NULL);    lua_xmove(L, td->L, n);  }  if (!sys_thread_create(td, 0)) {    return 1;  }  sys_thread_del(td); err:  return sys_seterror(L, 0);}

void uip_sys_init(void){    uip_init();         //uip init    sys_thread_new("uip",uip_tcpip_thread, RT_NULL, RT_LWIP_TCPTHREAD_STACKSIZE, RT_LWIP_TCPTHREAD_PRIORITY);    hello_world_init(); //}

/*-----------------------------------------------------------------------------------*/static voidlow_level_init(struct netif *netif){  struct tunif *tunif;  char buf[sizeof(IFCONFIG_CALL) + 50];  tunif = (struct tunif *)netif->state;  /* Obtain MAC address from network interface. */  /* Do whatever else is needed to initialize interface. */  tunif->fd = open("/dev/tun0", O_RDWR);  LWIP_DEBUGF(TUNIF_DEBUG, ("tunif_init: fd %d/n", tunif->fd));  if (tunif->fd == -1) {    perror("tunif_init");    exit(1);  }  sprintf(buf, IFCONFIG_CALL,           ip4_addr1(&(netif->gw)),           ip4_addr2(&(netif->gw)),           ip4_addr3(&(netif->gw)),           ip4_addr4(&(netif->gw)),           ip4_addr1(&(netif->ip_addr)),           ip4_addr2(&(netif->ip_addr)),           ip4_addr3(&(netif->ip_addr)),           ip4_addr4(&(netif->ip_addr)));  LWIP_DEBUGF(TUNIF_DEBUG, ("tunif_init: system(/"%s/");/n", buf));  system(buf);  sys_thread_new("tunif_thread", tunif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);}

/*-----------------------------------------------------------------------------------*/err_tdelif_init_thread(struct netif *netif){  struct delif *del;  LWIP_DEBUGF(DELIF_DEBUG, ("delif_init_thread/n"));    del = malloc(sizeof(struct delif));  if (!del)      return ERR_MEM;  netif->state = del;  netif->name[0] = 'd';  netif->name[1] = 'e';  netif->output = delif_output;  del->netif = malloc(sizeof(struct netif));  if (!del->netif) {      free(del);      return ERR_MEM;  }  del->netif->ip_addr = netif->ip_addr;  del->netif->gw = netif->gw;  del->netif->netmask = netif->netmask;  del->input = netif->input;  del->netif->input = delif_input;  sys_thread_new("delif_thread", delif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);  return ERR_OK;}

//---------------------------------------------------------------------int update_ota_cloud(char *repository, char *file_path){	update_cfg_cloud_t *pUpdateCfg;		if(TaskOTA){		printf("/n/r[%s] Update task has created.", __FUNCTION__);		return 0;	}	pUpdateCfg = update_malloc(sizeof(update_cfg_cloud_t));	if(pUpdateCfg == NULL){		printf("/n/r[%s] Alloc update cfg failed.", __FUNCTION__);		goto exit;	}	if(strlen(repository) > (REPOSITORY_LEN-1)){		printf("/n/r[%s] Repository length is too long.", __FUNCTION__);		goto exit;	}	if(strlen(file_path) > (FILE_PATH_LEN-1)){		printf("/n/r[%s] File path length is too long.", __FUNCTION__);		goto exit;	}	strcpy((char*)pUpdateCfg->repository, repository);	strcpy((char*)pUpdateCfg->file_path, file_path);	TaskOTA = sys_thread_new("OTA_server", update_ota_cloud_task, pUpdateCfg, STACK_SIZE, TASK_PRIORITY);	if(TaskOTA == NULL){	  			printf("/n/r[%s] Create update task failed", __FUNCTION__);		goto exit;	}exit:	update_free(pUpdateCfg);	return 0;}

void echo_application_thread(){	int sock, new_sd;	struct sockaddr_in address, remote;	int size;	if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)		return;	address.sin_family = AF_INET;	address.sin_port = htons(echo_port);	address.sin_addr.s_addr = INADDR_ANY;	if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0)		return;	lwip_listen(sock, 0);	size = sizeof(remote);	while (1) {		if ((new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size)) > 0) {			sys_thread_new("echos", process_echo_request,				(void*)new_sd,				THREAD_STACKSIZE,				DEFAULT_THREAD_PRIO);		}	}}

/** * SLIP netif initialization * * Call the arch specific sio_open and remember * the opened device in the state field of the netif. * * @param netif the lwip network interface structure for this slipif * @return ERR_OK if serial line could be opened, *         ERR_IF is serial line couldn't be opened * * @note netif->num must contain the number of the serial port to open *       (0 by default) */err_tslipif_init(struct netif *netif){  LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"/n", (u16_t)netif->num));  netif->name[0] = 's';  netif->name[1] = 'l';  netif->output = slipif_output;  netif->mtu = MAX_SIZE;  netif->flags = NETIF_FLAG_POINTTOPOINT;  /* Try to open the serial port (netif->num contains the port number). */  netif->state = sio_open(netif->num);  if (!netif->state) {    /* Opening the serial port failed. */    return ERR_IF;  }  /* initialize the snmp variables and counters inside the struct netif   * ifSpeed: no assumption can be made without knowing more about the   * serial line!   */  NETIF_INIT_SNMP(netif, snmp_ifType_slip, 0);  /* Create a thread to poll the serial line. */  sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop, netif, SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);  return ERR_OK;}

void cli_local_main( void* pport ) {    uint16_t port;    struct sockaddr_in addr;    struct sockaddr client_addr;    unsigned sock_len = sizeof(struct sockaddr);    int bindfd;    int clientfd;    cli_client_t* client;    port = *(uint16_t*)pport;    free( pport );    /* create a socket to listen for connections on */    bindfd = socket( AF_INET, SOCK_STREAM, 0 );    if( bindfd == -1 ) {        die( "Error: unable to create a real IPv4 TCP socket" );    }    /* allow reuse of the port */    int reuse = 1;    if( setsockopt( bindfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse) ) )        die( "Error: SO_REUSEADDR failed" );    /* bind to the requested port */    addr.sin_port = htons(port);    addr.sin_addr.s_addr = 0;    memset(&(addr.sin_zero), 0, sizeof(addr.sin_zero));    if( bind(bindfd, (struct sockaddr*)&addr, sizeof(struct sockaddr)) ) {        die( "Error: unable to bind to local port %u", port );    }    /* listen for clients */    listen( bindfd, 10 );    while( !cli_is_time_to_shutdown() ) {        /* wait for a new client */        clientfd = accept(bindfd, &client_addr, &sock_len);        if( clientfd == - 1 ) {            if( errno == EINTR ) {                /* Interrupt received, going back to real accept() */                continue;            }            /* some error */            fprintf( stderr, "Warrning: real accept() returned an error code (%d)", errno );            continue;        }        /* create a client record */        client = (cli_client_t*)malloc_or_die( sizeof(cli_client_t) );        client->fd = -clientfd; /* negative means use the real sockets */        search_state_init( &client->state, CLI_INIT_BUF, CLI_MAX_BUF );        /* spawn a new thread to handle the client */        sys_thread_new( cli_client_handler_main, client );    }    exit( 0 );}

/*-----------------------------------------------------------------------------------*/voidtcpip_init(void (* initfunc)(void *), void *arg){  tcpip_init_done = initfunc;  tcpip_init_done_arg = arg;  mbox = sys_mbox_new();  sys_thread_new((void *)tcpip_thread, NULL);}

/**  * @brief  Initialize the HTTP server (start its thread)   * @param  None  * @retval None  */void http_init(){  nPageHits = 0;  if(HTTP_Task_Handle == NULL)  {    HTTP_Task_Handle = sys_thread_new("HTTP", http_ipcam_thread, NULL, HTTP_THREAD_STACK_SIZE, HTTP_THREAD_PRIO);  }}

voidtcpip_init(void (* initfunc)(void *), void *arg){  tcpip_init_done = initfunc;  tcpip_init_done_arg = arg;  tcp_mbox = sys_mbox_new();  sys_thread_new(tcpip_thread, NULL, TCPIP_THREAD_PRIO);}

/** * In this function, the hardware should be initialized. * Called from ethernetif_init(). * * @param netif the already initialized lwip network interface structure *        for this ethernetif */static voidlow_level_init(struct netif *netif){#ifdef FREERTOS_USED  unsigned portBASE_TYPE uxPriority;#endif  /* set MAC hardware address length */  netif->hwaddr_len = ETHARP_HWADDR_LEN;  /* set MAC hardware address */	netif->hwaddr[0] = cMACAddress[0];	netif->hwaddr[1] = cMACAddress[1];	netif->hwaddr[2] = cMACAddress[2];	netif->hwaddr[3] = cMACAddress[3];	netif->hwaddr[4] = cMACAddress[4];	netif->hwaddr[5] = cMACAddress[5];  /* maximum transfer unit */  netif->mtu = 1500;  /* device capabilities */  /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */  netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP#if defined(DHCP_USED)    | NETIF_FLAG_DHCP#endif  ;  /* Do whatever else is needed to initialize interface. */  /* Initialise the MACB. */#ifdef FREERTOS_USED  // NOTE: This routine contains code that polls status bits. If the Ethernet  // cable is not plugged in then this can take a considerable time.  To prevent  // this from starving lower priority tasks of processing time we lower our  // priority prior to the call, then raise it back again once the initialization  // is complete.  // Read the priority of the current task.  uxPriority = uxTaskPriorityGet( NULL );  // Set the priority of the current task to the lowest possible.  vTaskPrioritySet( NULL, tskIDLE_PRIORITY );#endif  // Init the MACB interface.  while( xMACBInit(&AVR32_MACB) == false )  {    __asm__ __volatile__ ( "nop" );  }#ifdef FREERTOS_USED  // Restore the priority of the current task.  vTaskPrioritySet( NULL, uxPriority );  /* Create the task that handles the MACB input packets. */  sys_thread_new( "ETHINT", ethernetif_input, netif, netifINTERFACE_TASK_STACK_SIZE,                  netifINTERFACE_TASK_PRIORITY );#endif}

/*! /brief create ethernet task, for ethernet management. * *  /param uxPriority   Input. priority for the task, it should be low * */portTASK_FUNCTION( vStartEthernetTask, pvParameters ){   static const gpio_map_t MACB_GPIO_MAP =   {      {EXTPHY_MACB_MDC_PIN,     EXTPHY_MACB_MDC_FUNCTION   },      {EXTPHY_MACB_MDIO_PIN,    EXTPHY_MACB_MDIO_FUNCTION  },      {EXTPHY_MACB_RXD_0_PIN,   EXTPHY_MACB_RXD_0_FUNCTION },      {EXTPHY_MACB_TXD_0_PIN,   EXTPHY_MACB_TXD_0_FUNCTION },      {EXTPHY_MACB_RXD_1_PIN,   EXTPHY_MACB_RXD_1_FUNCTION },      {EXTPHY_MACB_TXD_1_PIN,   EXTPHY_MACB_TXD_1_FUNCTION },      {EXTPHY_MACB_TX_EN_PIN,   EXTPHY_MACB_TX_EN_FUNCTION },      {EXTPHY_MACB_RX_ER_PIN,   EXTPHY_MACB_RX_ER_FUNCTION },      {EXTPHY_MACB_RX_DV_PIN,   EXTPHY_MACB_RX_DV_FUNCTION },      {EXTPHY_MACB_TX_CLK_PIN,  EXTPHY_MACB_TX_CLK_FUNCTION}   };   // Assign GPIO to MACB   gpio_enable_module(MACB_GPIO_MAP, sizeof(MACB_GPIO_MAP) / sizeof(MACB_GPIO_MAP[0]));   /* Setup lwIP. */   prvlwIPInit();#if (HTTP_USED == 1)   /* Create the WEB server task.  This uses the lwIP RTOS abstraction layer.*/   sys_thread_new( "WEB", vBasicWEBServer, ( void * ) NULL,                   lwipBASIC_WEB_SERVER_STACK_SIZE,                   lwipBASIC_WEB_SERVER_PRIORITY );#endif#if (TFTP_USED == 1)   /* Create the TFTP server task.  This uses the lwIP RTOS abstraction layer.*/   sys_thread_new( "TFTP", vBasicTFTPServer, ( void * ) NULL,                   lwipBASIC_TFTP_SERVER_STACK_SIZE,                   lwipBASIC_TFTP_SERVER_PRIORITY );#endif#if (SMTP_USED == 1)   /* Create the SMTP Client task.  This uses the lwIP RTOS abstraction layer.*/   sys_thread_new( "SMTP", vBasicSMTPClient, ( void * ) NULL,                   lwipBASIC_SMTP_CLIENT_STACK_SIZE,                   lwipBASIC_SMTP_CLIENT_PRIORITY );#endif  // Kill this task.  vTaskDelete(NULL);}

voidping_init(void){#if PING_USE_SOCKETS  sys_thread_new("ping_thread", ping_thread, NULL, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);#else /* PING_USE_SOCKETS */  ping_raw_init();#endif /* PING_USE_SOCKETS */}

/* Called from the TCP/IP thread. */void lwIPAppsInit( void *pvArgument ){ip_addr_t xIPAddr, xNetMask, xGateway;extern err_t xemacpsif_init( struct netif *netif );extern void xemacif_input_thread( void *netif );static struct netif xNetIf;	( void ) pvArgument;	/* Set up the network interface. */	ip_addr_set_zero( &xGateway );	ip_addr_set_zero( &xIPAddr );	ip_addr_set_zero( &xNetMask );	LWIP_PORT_INIT_GW(&xGateway);	LWIP_PORT_INIT_IPADDR( &xIPAddr );	LWIP_PORT_INIT_NETMASK(&xNetMask);	/* Set mac address */	xNetIf.hwaddr_len = 6;	xNetIf.hwaddr[ 0 ] = configMAC_ADDR0;	xNetIf.hwaddr[ 1 ] = configMAC_ADDR1;	xNetIf.hwaddr[ 2 ] = configMAC_ADDR2;	xNetIf.hwaddr[ 3 ] = configMAC_ADDR3;	xNetIf.hwaddr[ 4 ] = configMAC_ADDR4;	xNetIf.hwaddr[ 5 ] = configMAC_ADDR5;	netif_set_default( netif_add( &xNetIf, &xIPAddr, &xNetMask, &xGateway, ( void * ) XPAR_XEMACPS_0_BASEADDR, xemacpsif_init, tcpip_input ) );	netif_set_status_callback( &xNetIf, vStatusCallback );	#if LWIP_DHCP	{		dhcp_start( &xNetIf );	}	#else	{		netif_set_up( &xNetIf );	}	#endif	/* Install the server side include handler. */	http_set_ssi_handler( uslwIPAppsSSIHandler, pccSSITags, sizeof( pccSSITags ) / sizeof( char * ) );	/* Create the mutex used to ensure mutual exclusive access to the Tx 	buffer. */	xTxBufferMutex = xSemaphoreCreateMutex();	configASSERT( xTxBufferMutex );	/* Create the httpd server from the standard lwIP code.  This demonstrates	use of the lwIP raw API. */	httpd_init();	sys_thread_new( "lwIP_In", xemacif_input_thread, &xNetIf, configMINIMAL_STACK_SIZE, configMAC_INPUT_TASK_PRIORITY );	/* Create the FreeRTOS defined basic command server.  This demonstrates use	of the lwIP sockets API. */	xTaskCreate( vBasicSocketsCommandInterpreterTask, "CmdInt", configMINIMAL_STACK_SIZE * 5, NULL, configCLI_TASK_PRIORITY, NULL );}

/** * Add a network interface */void apps_init( void ){	vSerialPutString("INIT/n");	vSerialPutString(".../n");	if( sys_thread_new( "demo-apps", vDemoAppsTask, NULL, 1024, (tskIDLE_PRIORITY + 1) ) == NULL )		printf( "apps_init: create task failed!/n");	vSerialPutString("OK/n");}

voidlaunch_app_threads(){    /* start echo server thread */    if (INCLUDE_ECHO_SERVER)        sys_thread_new("echod", echo_application_thread, 0,            THREAD_STACKSIZE,            DEFAULT_THREAD_PRIO);}

/*! /brief create ethernet task, for ethernet management. * *  /param uxPriority   Input. priority for the task, it should be low * */portTASK_FUNCTION(vStartEthernetTask, pvParameters){	/* Setup lwIP. */	prvlwIPInit();	/* Create the WEB server task.  This uses the lwIP RTOS abstraction layer. */	sys_thread_new("WEB", vBasicWEBServer, (void *)NULL,					lwipBASIC_WEB_SERVER_STACK_SIZE,					lwipBASIC_WEB_SERVER_PRIORITY);	/* Create the Socket Server task.  This uses the lwIP RTOS abstraction layer. */	sys_thread_new("NETS", vNetHandle, (void *)NULL,					TASK_TCP_SERVER_STACK_SIZE,					TASK_TCP_SERVER_PRIORITY);	/* Kill this task. */	vTaskDelete(NULL);}