err_t ethernetif_init(struct netif *netif)
{
LWIP_ASSERT("netif != NULL", (netif != NULL));
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
// don't touch netif->state here, the field is used internally in the ESP SDK layers
netif->name[0] = 'e';
netif->name[1] = 'n';
netif->output = etharp_output;
netif->linkoutput = low_level_output;
/* low_level_init components */
netif->hwaddr_len = 6;
/* hwaddr seems to be set elsewhere, or (more likely) is set on tx by MAC layer */
netif->mtu = 1500;
netif->flags = NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
err_t
ethernetif_init(struct netif *netif)
{
static int ethernetif_index;
int local_index;
SYS_ARCH_DECL_PROTECT(lev);
SYS_ARCH_PROTECT(lev);
local_index = ethernetif_index++;
SYS_ARCH_UNPROTECT(lev);
netif->name[0] = IFNAME0;
netif->name[1] = (char)(IFNAME1 + local_index);
netif->linkoutput = low_level_output;
#if LWIP_ARP
netif->output = etharp_output;
#else /* LWIP_ARP */
netif->output = NULL; /* not used for PPPoE */
#endif /* LWIP_ARP */
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif_set_hostname(netif, "lwip");
#endif /* LWIP_NETIF_HOSTNAME */
netif->mtu = 1500;
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
netif->hwaddr_len = ETHARP_HWADDR_LEN;
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
/* sets link up or down based on current status */
low_level_init(netif);
return ERR_OK;
}
err_t eth_init(struct netif *netif) {
LWIP_ASSERT("netif != NULL", (netif != NULL));
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 0x2EA);
/* maximum transfer unit */
netif->mtu = 0x2EA;
/* device capabilities */
/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP | NETIF_FLAG_IGMP;
netif->state = NULL;
eth_netif = netif;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = eth_output;
if (!pEth) pEth = new Ethernet(); // only create Ethernet object if required
return ERR_OK;
}
/*
* Initialization.
*/
static err_t ethernetif_init(struct netif *netif) {
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LWIP_LINK_SPEED);
netif->state = NULL;
netif->name[0] = LWIP_IFNAME0;
netif->name[1] = LWIP_IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
/* initialize the hardware */
low_level_init(netif);
return ERR_OK;
}
/**
* 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_t
slipif_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;
}
/**
* 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_MEM if no memory could be allocated,
* 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). If netif->state is != NULL, it is interpreted as an
* u8_t pointer pointing to the serial port number instead of netif->num.
*
*/
err_t
slipif_init(struct netif *netif)
{
struct slipif_priv *priv;
u8_t sio_num;
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)netif->num));
/* Allocate private data */
priv = (struct slipif_priv *)mem_malloc(sizeof(struct slipif_priv));
if (!priv) {
return ERR_MEM;
}
netif->name[0] = 's';
netif->name[1] = 'l';
netif->output = slipif_output_v4;
#if LWIP_IPV6
netif->output_ip6 = slipif_output_v6;
#endif /* LWIP_IPV6 */
netif->mtu = SLIP_MAX_SIZE;
/* netif->state or netif->num contain the port number */
if (netif->state != NULL) {
sio_num = *(u8_t*)netif->state;
} else {
sio_num = netif->num;
}
/* Try to open the serial port. */
priv->sd = sio_open(sio_num);
if (!priv->sd) {
/* Opening the serial port failed. */
mem_free(priv);
return ERR_IF;
}
/* Initialize private data */
priv->p = NULL;
priv->q = NULL;
priv->state = SLIP_RECV_NORMAL;
priv->i = 0;
priv->recved = 0;
#if SLIP_RX_FROM_ISR
priv->rxpackets = NULL;
#endif
netif->flags |= NETIF_FLAG_POINTTOPOINT;
netif->state = priv;
/* initialize the snmp variables and counters inside the struct netif */
NETIF_INIT_SNMP(netif, snmp_ifType_slip, SLIP_SIO_SPEED(priv->sd));
#if SLIP_USE_RX_THREAD
/* Create a thread to poll the serial line. */
sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif,
SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);
#endif /* SLIP_USE_RX_THREAD */
return ERR_OK;
}
/**
* Should be called at the beginning of the program to set up the
* network interface. It calls the function low_level_init() to do the
* actual setup of the hardware.
*
* This function should be passed as a parameter to netif_add().
*
* @param netif the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
* any other err_t on error
*/
err_t
wlanif_init(struct netif *netif)
{
LWIP_ASSERT("netif != NULL", (netif != NULL));
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
#ifdef LWIP_ESP8266
//TO_DO
/*
if ((struct netif *)wifi_get_netif(STATION_IF) == netif) {
if (default_hostname == 1) {
wifi_station_set_default_hostname(netif->hwaddr);
}
netif->hostname = hostname;
} else {
netif->hostname = NULL;
}
*/
sprintf(hostname, "ESP_%02X%02X%02X", netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]);
netif->hostname = hostname;
#else
sprintf(hostname, "ESP_%02X%02X%02X", netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]);
netif->hostname = hostname;
#endif
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
#if LWIP_IPV6
netif->output_ip6 = ethip6_output;
#endif /* LWIP_IPV6 */
netif->linkoutput = low_level_output;
/* initialize the hardware */
low_level_init(netif);
return ERR_OK;
}
/**
* Initialize a lwip network interface structure for a loopback interface
*
* @param netif the lwip network interface structure for this loopif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
*/
static int8_t netif_loopif_init(struct netif *netif)
{
/* initialize the snmp variables and counters inside the struct netif
* ifSpeed: no assumption can be made!
*/
NETIF_INIT_SNMP(netif, snmp_ifType_softwareLoopback, 0);
netif->name[0] = 'l';
netif->name[1] = 'o';
netif->output = netif_loop_output;
return ERR_OK;
}
/**
* Should be called at the beginning of the program to set up the
* network interface. It calls the function low_level_init() to do the
* actual setup of the hardware.
*
* This function should be passed as a parameter to netif_add().
*
* @param netif the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
* any other err_t on error
*/
err_t
ethernetif_init(struct netif *netif)
{
/* struct ethernetif *ethernetif; */
LWIP_ASSERT("netif != NULL", (netif != NULL));
/*ethernetif = (struct ethernetif *)mem_malloc(sizeof(struct ethernetif));
if (ethernetif == NULL)
{
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
return ERR_MEM;
}*/
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
#if LWIP_SNMP
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
#endif /* LWIP_SNMP */
netif->state = NULL; /* ethernetif;
ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]); */
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
/* initialize the hardware */
low_level_init(netif);
/* DONE BY THE LWIP TASK.
// Initializes the ARP table and queue.
etharp_init();
// You must call etharp_tmr at a ARP_TMR_INTERVAL (5 seconds) regular interval
// after this initialization.
sys_timeout(ARP_TMR_INTERVAL, (sys_timeout_handler)arp_timer, NULL);
*/
return ERR_OK;
}
/**
* Should be called at the beginning of the program to set up the
* network interface. It calls the function low_level_init() to do the
* actual setup of the hardware.
*
* This function should be passed as a parameter to netif_add().
*
* @param netif the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
* any other err_t on error
*/
err_t ethernetif_init(struct netif *netif)
{
struct ethernetif *ethernetif;
LWIP_ASSERT("netif != NULL", (netif != NULL));
ethernetif = mem_malloc(sizeof(struct ethernetif));
if (ethernetif == NULL)
{
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
return ERR_MEM;
}
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
netif->state = ethernetif;
netif->hwaddr_len = 6;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
netif->mtu = 1500;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...)
*/
netif->output = etharp_output;
netif->linkoutput = low_level_output;
ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
/* initialize the hardware */
low_level_init(netif);
etharp_init();
if (!sys_thread_new((char *)"eth_thread", ethernetif_loop, netif,
DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO))
{
LWIP_DEBUGF(NETIF_DEBUG,
("ethernetif_init: max number of threads exceeded\n"));
mem_free(ethernetif);
return ERR_MEM;
}
return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
err_t
tapif_init(struct netif *netif)
{
struct ethernetif *ethernetif;
LWIP_ASSERT("netif != NULL", (netif != NULL));
ethernetif = mem_malloc(sizeof(struct ethernetif));
if (ethernetif == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
return ERR_MEM;
}
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
netif->state = ethernetif;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
/* initialize the hardware */
low_level_init(netif);
return ERR_OK;
//初始化mac地址 然后调用can初始化函数
if (!can_hardware_init())
{
return ERR_IF;
}
return ERR_OK;
}
/**
* Should be called at the beginning of the program to set up the
* network interface. It calls the function init() to do the
* actual setup of the hardware.
*
* This function should be passed as a parameter to netif_add().
*
* @param netif the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
* any other err_t on error
*/
static err_t init(struct netif *netif)
{
struct ethernetif *ethernetif;
LWIP_ASSERT("netif != NULL", (netif != NULL));
LWIP_ASSERT("state != NULL", (netif->state != NULL));
ethernetif = netif->state;
#if LWIP_NETIF_HOSTNAME
// Initialize interface hostname.
netif->hostname = "lwip";
#endif // LWIP_NETIF_HOSTNAME
/* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
#ifdef LINK_SPEED_OF_YOUR_NETIF_IN_BPS // RICH: Where to get this?
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd,
LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
#endif
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...).
*/
netif->output = etharp_output;
#if LWIP_IPV6
netif->output_ip6 = ethip6_output;
#endif // LWIP_IPV6
netif->linkoutput = linkoutput;
// Device capabilities.
// Don't set NETIF_FLAG_ETHARP if this device is not an ethernet one.
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
// Initialize the hardware and send back the Mac address.
int s = ethernetif->ops->init(ethernetif->priv,
&netif->hwaddr_len, netif->hwaddr,
&netif->mtu, NULL);
if (s < 0) {
return ERR_ARG; // RICH: Better error?
}
return ERR_OK;
}
/**
* 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_MEM if no memory could be allocated,
* 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_t
slipif_init(struct netif *netif)
{
struct slipif_priv *priv;
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)netif->num));
/* Allocate private data */
priv = mem_malloc(sizeof(struct slipif_priv));
if (!priv) {
return ERR_MEM;
}
netif->name[0] = 's';
netif->name[1] = 'l';
netif->output = slipif_output;
netif->mtu = SLIP_MAX_SIZE;
netif->flags |= NETIF_FLAG_POINTTOPOINT;
/* Try to open the serial port (netif->num contains the port number). */
priv->sd = sio_open(netif->num);
if (!priv->sd) {
/* Opening the serial port failed. */
mem_free(priv);
return ERR_IF;
}
/* Initialize private data */
priv->p = NULL;
priv->q = NULL;
priv->state = SLIP_RECV_NORMAL;
priv->i = 0;
priv->recved = 0;
netif->state = priv;
/* 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);
#if !NO_SYS
/* Create a thread to poll the serial line. */
sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif,
SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);
#endif
return ERR_OK;
}
err_t ethernetif_init( struct netif *netif )
{
struct ethernetif *ethernetif;
LWIP_ASSERT( "netif != NULL", ( netif != NULL ) );
ethernetif = mem_malloc( sizeof(struct ethernetif ) );
if ( ethernetif == NULL )
{
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
return ERR_MEM;
}
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "swet";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP( netif, snmp_ifType_ethernet_csmacd, 100 );
netif->state = ethernetif;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...)
*/
netif->output = etharp_output;
netif->linkoutput = low_level_output;
ethernetif->ethaddr = (struct eth_addr *)&( netif->hwaddr[ 0 ] );
low_level_init( netif );
// Configure Ethernet service interrupt
//ConfigINT3( EXT_INT_ENABLE | FALLING_EDGE_INT | EXT_INT_PRI_2 );
return ERR_OK;
}
/**
* Initialize a lwip network interface structure for a loopback interface
*
* @param netif the lwip network interface structure for this loopif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
*/
static err_t
netif_loopif_init(struct netif *netif)
{
/* initialize the snmp variables and counters inside the struct netif
* ifSpeed: no assumption can be made!
*/
NETIF_INIT_SNMP(netif, snmp_ifType_softwareLoopback, 0);
netif->name[0] = 'l';
netif->name[1] = 'o';
#if LWIP_IPV4
netif->output = netif_loop_output_ipv4;
#endif
#if LWIP_IPV6
netif->output_ip6 = netif_loop_output_ipv6;
#endif
return ERR_OK;
}
/**
* Should be called at the beginning of the program to set up the
* network interface. It calls the function low_level_init() to do the
* actual setup of the hardware.
*
* This function should be passed as a parameter to netif_add().
*
* @param netif the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated
* any other err_t on error
*/
err_t ethernetif_init(struct netif *netif)
{
LWIP_DRIVER_DATA* drv_data = (LWIP_DRIVER_DATA*)netif;
LWIP_ASSERT("netif != NULL", (netif != NULL));
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 1000000);
// netif->state = ðernetif_data;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
// drv_data->ethaddr = (struct eth_addr *) &(netif->hwaddr[0]);
drv_data->txq.qread = drv_data->txq.qwrite = 0;
drv_data->txq.overflow = 0;
drv_data->rxq.qread = drv_data->rxq.qwrite = 0;
drv_data->rxq.overflow = 0;
/* initialize the hardware */
low_level_init(netif);
return (ERR_OK);
}
err_t
lpc17xx_if_init(struct netif *netif)
{
LWIP_ASSERT("netif != NULL", (netif != NULL));
/* We only have one EMAC on the lpc17xx, so... */
if (!__sync_bool_compare_and_swap(&lpc17xx_if_got_init, 0, 1))
return ERR_VAL;
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 746);
netif->state = NULL;
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
/* initialize the hardware */
if (!low_level_init(netif)) {
lpc17xx_if_got_init = 0;
return ERR_IF;
}
return ERR_OK;
}
//A local helper routine,called by lwIP to initialize a netif object.
static err_t _ethernet_if_init(struct netif *netif)
{
__ETHERNET_INTERFACE* pEthInt = NULL;
if (NULL == netif)
{
return !ERR_OK;
}
pEthInt = netif->state;
if (NULL == pEthInt)
{
return !ERR_OK;
}
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 10000000);
netif->name[0] = pEthInt->ethName[0];
netif->name[1] = pEthInt->ethName[1];
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->hwaddr_len = ETH_MAC_LEN;
netif->linkoutput = eth_level_output;
/* maximum transfer unit */
netif->mtu = ETH_DEFAULT_MTU;
/* device capabilities */
/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
//Set the MAC address of this interface.
memcpy(netif->hwaddr, pEthInt->ethMac, ETH_MAC_LEN);
return ERR_OK;
}
/**
* @brief main routine for example_lwip_tcpecho_sa_18xx43xx
* @return Function should not exit.
*/
int main(void)
{
uint32_t physts;
ip_addr_t ipaddr, netmask, gw;
prvSetupHardware();
/* Initialize LWIP */
lwip_init();
LWIP_DEBUGF(LWIP_DBG_ON, ("Starting LWIP TCP echo server...\n"));
/* Static IP assignment */
#if LWIP_DHCP
IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
#else
IP4_ADDR(&gw, 10, 1, 10, 1);
IP4_ADDR(&ipaddr, 10, 1, 10, 234);
IP4_ADDR(&netmask, 255, 255, 255, 0);
APP_PRINT_IP(&ipaddr);
#endif
/* Add netif interface for lpc17xx_8x */
netif_add(&lpc_netif, &ipaddr, &netmask, &gw, NULL, lpc_enetif_init,
ethernet_input);
netif_set_default(&lpc_netif);
netif_set_up(&lpc_netif);
#if LWIP_DHCP
dhcp_start(&lpc_netif);
#endif
/* Initialize and start application */
echo_init();
/* This could be done in the sysTick ISR, but may stay in IRQ context
too long, so do this stuff with a background loop. */
while (1) {
/* Handle packets as part of this loop, not in the IRQ handler */
lpc_enetif_input(&lpc_netif);
/* lpc_rx_queue will re-qeueu receive buffers. This normally occurs
automatically, but in systems were memory is constrained, pbufs
may not always be able to get allocated, so this function can be
optionally enabled to re-queue receive buffers. */
#if 0
while (lpc_rx_queue(&lpc_netif)) {}
#endif
/* Free TX buffers that are done sending */
lpc_tx_reclaim(&lpc_netif);
/* LWIP timers - ARP, DHCP, TCP, etc. */
sys_check_timeouts();
/* Call the PHY status update state machine once in a while
to keep the link status up-to-date */
physts = lpcPHYStsPoll();
/* Only check for connection state when the PHY status has changed */
if (physts & PHY_LINK_CHANGED) {
if (physts & PHY_LINK_CONNECTED) {
Board_LED_Set(0, true);
/* Set interface speed and duplex */
if (physts & PHY_LINK_SPEED100) {
Chip_ENET_SetSpeed(LPC_ETHERNET, 1);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
Chip_ENET_SetSpeed(LPC_ETHERNET, 0);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 10000000);
}
if (physts & PHY_LINK_FULLDUPLX) {
Chip_ENET_SetDuplex(LPC_ETHERNET, true);
}
else {
Chip_ENET_SetDuplex(LPC_ETHERNET, false);
}
netif_set_link_up(&lpc_netif);
}
else {
Board_LED_Set(0, false);
netif_set_link_down(&lpc_netif);
}
DEBUGOUT("Link connect status: %d\r\n", ((physts & PHY_LINK_CONNECTED) != 0));
}
}
/* Never returns, for warning only */
return 0;
}
/**
* Initializes and sets up a netfront interface for lwIP.
* This function should be passed as a parameter to netfrontif_add().
*
* @param netif
* the lwip network interface structure for this netfrontif
* @return
* ERR_OK if the interface was successfully initialized;
* An err_t value otherwise
*/
err_t netfrontif_init(struct netif *netif)
{
struct netfrontif *nfi;
static uint8_t netfrontif_id = 0;
LWIP_ASSERT("netif != NULL", (netif != NULL));
if (!(netif->state)) {
nfi = mem_calloc(1, sizeof(*nfi));
if (!nfi) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: "
"Could not allocate \n"));
goto err_out;
}
netif->state = nfi;
nfi->_state_is_private = 1;
nfi->_dev_is_private = 1;
nfi->_hwaddr_is_private = 1;
} else {
nfi = netif->state;
nfi->_state_is_private = 0;
nfi->_dev_is_private = !(nfi->dev);
nfi->_hwaddr_is_private = eth_addr_cmp(&nfi->hwaddr, ðzero);
}
/* Netfront */
if (nfi->_dev_is_private) {
/* user did not provide an opened netfront, we need to do it here */
if (!nfi->_state_is_private) {
/* use vif_id to open an specific NIC interface */
/* Note: netfront will duplicate the passed nodename */
char nodename[128];
snprintf(nodename, sizeof(nodename), "device/vif/%u", nfi->vif_id);
nfi->dev = init_netfront(nodename, NULL, NULL, NULL);
} else {
/* open the next available net interface */
nfi->dev = init_netfront(NULL, NULL, NULL, NULL);
}
if (!nfi->dev) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: "
"Could not init netfront\n"));
goto err_free_nfi;
}
}
netfront_set_rx_pbuf_handler(nfi->dev, netfrontif_rx_handler, netif);
/* Interface identifier */
netif->name[0] = NETFRONTIF_NPREFIX;
netif->name[1] = '0' + netfrontif_id;
netfrontif_id++;
/* We directly use etharp_output() here to save a function call.
* Instead, there could be function declared that calls etharp_output()
* only if there is a link is available... */
netif->output = etharp_output;
netif->linkoutput = netfrontif_transmit;
#if LWIP_NETIF_REMOVE_CALLBACK
netif->remove_callback = netfrontif_exit;
#endif /* CONFIG_NETIF_REMOVE_CALLBACK */
/* Hardware address */
if (nfi->_hwaddr_is_private) {
if (!netfront_get_hwaddr(nfi->dev, &nfi->hwaddr)) {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: "
"Could not retrieve hardware address\n",
netif->name[0], netif->name[1]));
goto err_shutdown_netfront;
}
} else {
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: "
"Overwriting hardware address\n",
netif->name[0], netif->name[1]));
}
SMEMCPY(&netif->hwaddr, &nfi->hwaddr, ETHARP_HWADDR_LEN);
netif->hwaddr_len = ETHARP_HWADDR_LEN;
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: hardware address: "
"%02x:%02x:%02x:%02x:%02x:%02x\n",
netif->name[0], netif->name[1],
netif->hwaddr[0],
netif->hwaddr[1],
netif->hwaddr[2],
netif->hwaddr[3],
netif->hwaddr[4],
netif->hwaddr[5]));
/* Initialize the snmp variables and counters inside the struct netif.
* The last argument is the link speed, in units of bits per second. */
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, NETFRONTIF_SPEED);
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: Link speed: %llu bps\n",
netif->name[0], netif->name[1], NETFRONTIF_SPEED));
/* Device capabilities */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
/* Maximum transfer unit */
netif->mtu = NETFRONTIF_MTU;
LWIP_DEBUGF(NETIF_DEBUG, ("netfrontif_init: %c%c: MTU: %u\n",
netif->name[0], netif->name[1], netif->mtu));
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
if (!netif->hostname)
netif->hostname = NULL;
#endif /* LWIP_NETIF_HOSTNAME */
#ifndef CONFIG_LWIP_NOTHREADS
nfi->_thread_exit = 0;
nfi->_thread_name[0] = netif->name[0];
nfi->_thread_name[1] = netif->name[1];
nfi->_thread_name[2] = '-';
nfi->_thread_name[3] = 'r';
nfi->_thread_name[4] = 'x';
nfi->_thread_name[5] = '\0';
create_thread(nfi->_thread_name, netfrontif_thread, netif);
#endif /* CONFIG_LWIP_NOTHREADS */
return ERR_OK;
err_shutdown_netfront:
if (nfi->_dev_is_private) {
shutdown_netfront(nfi->dev);
nfi->dev = NULL;
}
err_free_nfi:
if (nfi->_state_is_private) {
mem_free(nfi);
netif->state = NULL;
}
err_out:
return ERR_IF;
}
/** \brief Update PHY status from passed value
*
* This function updates the current PHY status based on the
* passed PHY status word. The PHY status indicate if the link
* is active, the connection speed, and duplex.
*
* \param[in] netif NETIF structure
* \param[in] linksts Status word from PHY
* \return 1 if the status has changed, otherwise 0
*/
static s32_t lpc_update_phy_sts(struct netif *netif, u32_t linksts)
{
s32_t changed = 0;
/* Update link active status */
if (linksts & DP8_VALID_LINK)
physts.phy_link_active = 1;
else
physts.phy_link_active = 0;
/* Full or half duplex */
if (linksts & DP8_FULLDUPLEX)
physts.phy_full_duplex = 1;
else
physts.phy_full_duplex = 0;
/* Configure 100MBit/10MBit mode. */
if (linksts & DP8_SPEED10MBPS)
physts.phy_speed_100mbs = 0;
else
physts.phy_speed_100mbs = 1;
if (physts.phy_speed_100mbs != olddphysts.phy_speed_100mbs) {
changed = 1;
if (physts.phy_speed_100mbs) {
/* 100MBit mode. */
lpc_emac_set_speed(1);
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
/* 10MBit mode. */
lpc_emac_set_speed(0);
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 10000000);
}
olddphysts.phy_speed_100mbs = physts.phy_speed_100mbs;
}
if (physts.phy_full_duplex != olddphysts.phy_full_duplex) {
changed = 1;
if (physts.phy_full_duplex)
lpc_emac_set_duplex(1);
else
lpc_emac_set_duplex(0);
olddphysts.phy_full_duplex = physts.phy_full_duplex;
}
if (physts.phy_link_active != olddphysts.phy_link_active) {
changed = 1;
#if NO_SYS == 1
if (physts.phy_link_active)
netif_set_link_up(netif);
else
netif_set_link_down(netif);
#else
if (physts.phy_link_active)
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up,
(void*) netif, 1);
else
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down,
(void*) netif, 1);
#endif
olddphysts.phy_link_active = physts.phy_link_active;
}
return changed;
}
/** \brief Update PHY status from passed value
*
* This function updates the current PHY status based on the
* passed PHY status word. The PHY status indicate if the link
* is active, the connection speed, and duplex.
*
* \param[in] netif NETIF structure
* \param[in] linksts Status word with link state
* \param[in] sdsts Status word with speed and duplex states
* \return 1 if the status has changed, otherwise 0
*/
static s32_t lpc_update_phy_sts(struct netif *netif, u32_t linksts, u32_t sdsts)
{
s32_t changed = 0;
/* Update link active status */
if (linksts & LAN8_LINK_STATUS)
physts.phy_link_active = 1;
else
physts.phy_link_active = 0;
switch (sdsts & LAN8_SPEEDMASK) {
case LAN8_SPEED100F:
default:
physts.phy_speed_100mbs = 1;
physts.phy_full_duplex = 1;
break;
case LAN8_SPEED10F:
physts.phy_speed_100mbs = 0;
physts.phy_full_duplex = 1;
break;
case LAN8_SPEED100H:
physts.phy_speed_100mbs = 1;
physts.phy_full_duplex = 0;
break;
case LAN8_SPEED10H:
physts.phy_speed_100mbs = 0;
physts.phy_full_duplex = 0;
break;
}
if (physts.phy_speed_100mbs != olddphysts.phy_speed_100mbs) {
changed = 1;
if (physts.phy_speed_100mbs) {
/* 100MBit mode. */
lpc_emac_set_speed(1);
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
/* 10MBit mode. */
lpc_emac_set_speed(0);
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 10000000);
}
olddphysts.phy_speed_100mbs = physts.phy_speed_100mbs;
}
if (physts.phy_full_duplex != olddphysts.phy_full_duplex) {
changed = 1;
if (physts.phy_full_duplex)
lpc_emac_set_duplex(1);
else
lpc_emac_set_duplex(0);
olddphysts.phy_full_duplex = physts.phy_full_duplex;
}
if (physts.phy_link_active != olddphysts.phy_link_active) {
changed = 1;
#if NO_SYS == 1
if (physts.phy_link_active)
netif_set_link_up(netif);
else
netif_set_link_down(netif);
#else
if (physts.phy_link_active)
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up,
(void*) netif, 1);
else
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down,
(void*) netif, 1);
#endif
olddphysts.phy_link_active = physts.phy_link_active;
}
return changed;
}
/*..........................................................................*/
struct netif *eth_driver_init(QActive *active,
enum_t base_sig,
u8_t macaddr[NETIF_MAX_HWADDR_LEN])
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
lwip_init(); /* nitialize the lwIP stack */
/* set MAC address in the network interface... */
l_netif.hwaddr_len = NETIF_MAX_HWADDR_LEN;
memcpy(&l_netif.hwaddr[0], macaddr, NETIF_MAX_HWADDR_LEN);
l_active = active; /*save the active object associated with this driver */
/* set up the static events issed by this driver... */
l_lwipEvt[LWIP_RX_READY_OFFSET] .sig = base_sig + LWIP_RX_READY_OFFSET;
l_lwipEvt[LWIP_TX_READY_OFFSET] .sig = base_sig + LWIP_TX_READY_OFFSET;
l_lwipEvt[LWIP_RX_OVERRUN_OFFSET].sig = base_sig + LWIP_RX_OVERRUN_OFFSET;
#if LWIP_NETIF_HOSTNAME
l_netif.hostname = "lwIP"; /* initialize interface hostname */
#endif
l_netif.name[0] = 'Q';
l_netif.name[1] = 'P';
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(&l_netif, snmp_ifType_ethernet_csmacd, 1000000);
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
l_netif.output = ðarp_output;
l_netif.linkoutput = ðernetif_output;
#if (LWIP_DHCP == 0) && (LWIP_AUTOIP == 0)
/* No mechanism of obtaining IP address specified, use static IP: */
IP4_ADDR(&ipaddr, STATIC_IPADDR0, STATIC_IPADDR1,
STATIC_IPADDR2, STATIC_IPADDR3);
IP4_ADDR(&netmask, STATIC_NET_MASK0, STATIC_NET_MASK1,
STATIC_NET_MASK2, STATIC_NET_MASK3);
IP4_ADDR(&gwaddr, STATIC_GW_IPADDR0, STATIC_GW_IPADDR1,
STATIC_GW_IPADDR2, STATIC_GW_IPADDR3);
#else
/* either DHCP or AUTOIP are configured, start with zero IP addresses: */
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
IP4_ADDR(&gw, 0, 0, 0, 0);
#endif
/* add and configure the Ethernet interface with default settings */
netif_add(&l_netif,
&ipaddr, &netmask, &gw, /* configured IP addresses */
active, /* use this active object as the state */
ðernetif_init, /* Ethernet interface initialization */
&ip_input); /* standard IP input processing */
netif_set_default(&l_netif);
netif_set_up(&l_netif); /* bring the interface up */
#if (LWIP_DHCP != 0)
dhcp_start(&l_netif); /* start DHCP if configured in lwipopts.h */
/* NOTE: If LWIP_AUTOIP is configured in lwipopts.h and
* LWIP_DHCP_AUTOIP_COOP is set as well, the DHCP process will start
* AutoIP after DHCP fails for 59 seconds.
*/
#elif (LWIP_AUTOIP != 0)
autoip_start(&l_netif); /* start AutoIP if configured in lwipopts.h */
#endif
/* Enable Ethernet TX and RX Packet Interrupts. */
ETH->IM |= (ETH_INT_RX | ETH_INT_TX);
#if LINK_STATS
ETH->IM |= ETH_INT_RXOF;
#endif
QS_OBJ_DICTIONARY(&l_Ethernet_IRQHandler);
return &l_netif;
}
/**
* Update PHY status from passed value
*
* This function updates the current PHY status based on the
* passed PHY status word. The PHY status indicate if the link
* is active, the connection speed, and duplex.
*
* \param [in] netif NETIF structure
* \param [in] linksts Status word with link state
* \param [in] sdsts Status word with speed and duplex states
* \return 1 if the status has changed, otherwise 0
*/
static s32_t lpc_update_phy_sts(struct netif *netif, u32_t linksts, u32_t sdsts) {
s32_t changed = 0;
/* Update link active status */
if (linksts & LAN8_LINK_STATUS)
physts.phy_link_active = 1;
else
physts.phy_link_active = 0;
switch (sdsts & LAN8_SPEEDMASK) {
case LAN8_SPEED100F:
default:
physts.phy_speed_100mbs = 1;
physts.phy_full_duplex = 1;
break;
case LAN8_SPEED10F:
physts.phy_speed_100mbs = 0;
physts.phy_full_duplex = 1;
break;
case LAN8_SPEED100H:
physts.phy_speed_100mbs = 1;
physts.phy_full_duplex = 0;
break;
case LAN8_SPEED10H:
physts.phy_speed_100mbs = 0;
physts.phy_full_duplex = 0;
break;
}
if (physts.phy_speed_100mbs != olddphysts.phy_speed_100mbs) {
changed = 1;
if (physts.phy_speed_100mbs) {
/* 100MBit mode. */
LPC_EMAC->SUPP |= EMAC_SUPP_SPEED;
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
/* 10MBit mode. */
LPC_EMAC->SUPP &= ~EMAC_SUPP_SPEED;
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 10000000);
}
olddphysts.phy_speed_100mbs = physts.phy_speed_100mbs;
}
if (physts.phy_full_duplex != olddphysts.phy_full_duplex) {
changed = 1;
if (physts.phy_full_duplex) {
/* Full duplex */
LPC_EMAC->MAC2 |= EMAC_MAC2_FULL_DUP;
LPC_EMAC->Command |= EMAC_CR_FULL_DUP;
LPC_EMAC->IPGT = EMAC_IPGT_FULL_DUP;
}
else {
/* Half duplex mode. */
LPC_EMAC->MAC2 &= ~EMAC_MAC2_FULL_DUP;
LPC_EMAC->Command &= ~EMAC_CR_FULL_DUP;
LPC_EMAC->IPGT = EMAC_IPGT_HALF_DUP;
}
olddphysts.phy_full_duplex = physts.phy_full_duplex;
}
if (physts.phy_link_active != olddphysts.phy_link_active) {
changed = 1;
if (physts.phy_link_active)
netif_set_link_up(netif);
else
netif_set_link_down(netif);
olddphysts.phy_link_active = physts.phy_link_active;
}
return changed;
}
/**
* @brief main routine for example_lwip_tcpecho_sa_17xx40xx
* @return Function should not exit.
*/
int main(void)
{
uint32_t physts;
ip_addr_t ipaddr, netmask, gw;
static int prt_ip = 0;
prvSetupHardware();
/* Initialize LWIP */
lwip_init();
///LWIP_DEBUGF(LWIP_DBG_ON, ("Starting LWIP TCP echo server...\n"));
/* Static IP assignment */
IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
/* Add netif interface for lpc17xx_8x */
netif_add(&lpc_netif, &ipaddr, &netmask, &gw, NULL, lpc_enetif_init, ethernet_input);
netif_set_default(&lpc_netif);
netif_set_up(&lpc_netif);
dhcp_start(&lpc_netif);
uint8_t fl = 0 ;
while (1)
{
/* Handle packets as part of this loop, not in the IRQ handler */
lpc_enetif_input(&lpc_netif);
/* lpc_rx_queue will re-qeueu receive buffers. This normally occurs
automatically, but in systems were memory is constrained, pbufs
may not always be able to get allocated, so this function can be
optionally enabled to re-queue receive buffers. */
#if 0
while (lpc_rx_queue(&lpc_netif)) {}
#endif
/* Free TX buffers that are done sending */
lpc_tx_reclaim(&lpc_netif);
/* LWIP timers - ARP, DHCP, TCP, etc. */
sys_check_timeouts();
/* Call the PHY status update state machine once in a while
to keep the link status up-to-date */
physts = lpcPHYStsPoll();
/* Only check for connection state when the PHY status has changed */
if (physts & PHY_LINK_CHANGED)
{
if (physts & PHY_LINK_CONNECTED)
{
prt_ip = 0;
/* Set interface speed and duplex */
if (physts & PHY_LINK_SPEED100)
{
Chip_ENET_Set100Mbps(LPC_ETHERNET);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else
{
Chip_ENET_Set10Mbps(LPC_ETHERNET);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 10000000);
}
if (physts & PHY_LINK_FULLDUPLX) {
Chip_ENET_SetFullDuplex(LPC_ETHERNET);
}
else {
Chip_ENET_SetHalfDuplex(LPC_ETHERNET);
}
netif_set_link_up(&lpc_netif);
}
else
{
netif_set_link_down(&lpc_netif);
}
DEBUGOUT("Link connect status: %d\r\n", ((physts & PHY_LINK_CONNECTED) != 0));
}
/* Print IP address info */
if (!prt_ip)
{
if (lpc_netif.ip_addr.addr)
{
static char tmp_buff[16];
DEBUGOUT("IP_ADDR : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.ip_addr, tmp_buff, 16));
DEBUGOUT("NET_MASK : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.netmask, tmp_buff, 16));
DEBUGOUT("GATEWAY_IP : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.gw, tmp_buff, 16));
prt_ip = 1;
mqttAppInit();
mqttAppConnect();
////// mqttAppDisconnect();
}
}
if(mqttIsConnected()==1)
{
mqttAppHandle();
if (fl == 0)
{
mqttAppSubscribe("lpc/#");
mqttAppSubscribe("lpc/teste");
fl = 1;
}
}
}
return 0;
}
/**
* Network interface setup function
* (Only used in case of FreeRTOS/uCOS-III configuration)
*/
static void vSetupIFTask(void *pvParameters)
{
ip_addr_t ipaddr, netmask, gw;
volatile s32_t tcpipdone = 0;
uint32_t physts;
static int prt_ip = 0;
/* Wait until the TCP/IP thread is finished before
continuing or wierd things may happen */
DEBUGSTR("Waiting for TCPIP thread to initialize...\r\n");
tcpip_init(tcpip_init_done_signal, (void *) &tcpipdone);
while (!tcpipdone) ;
DEBUGSTR("Starting LWIP HTTP server...\r\n");
/* Static IP assignment */
#if LWIP_DHCP
IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
#else
IP4_ADDR(&gw, 192, 168, 200, 1);
IP4_ADDR(&ipaddr, 192, 168, 200, 99);
IP4_ADDR(&netmask, 255, 255, 255, 0);
#endif
/* Add netif interface for lpc17xx_8x */
memset(&lpc_netif, 0, sizeof(lpc_netif));
if (!netif_add(&lpc_netif, &ipaddr, &netmask, &gw, NULL, lpc_enetif_init,
tcpip_input)) {
DEBUGSTR("Net interface failed to initialize ..\r\n");
while (1) ;
}
netif_set_default(&lpc_netif);
netif_set_up(&lpc_netif);
/* Enable MAC interrupts only after LWIP is ready */
NVIC_SetPriority(ETHERNET_IRQn, IRQ_PRIO_ETHERNET);
NVIC_EnableIRQ(ETHERNET_IRQn);
#if LWIP_DHCP
dhcp_start(&lpc_netif);
#endif
/* Initialize and start application */
//http_server_netconn_init();
/* This loop monitors the PHY link and will handle cable events
via the PHY driver. */
while (1) {
/* Call the PHY status update state machine once in a while
to keep the link status up-to-date */
physts = lpcPHYStsPoll();
/* Only check for connection state when the PHY status has changed */
if (physts & PHY_LINK_CHANGED) {
if (physts & PHY_LINK_CONNECTED) {
/* Set interface speed and duplex */
if (physts & PHY_LINK_SPEED100) {
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 10000000);
}
if (physts & PHY_LINK_FULLDUPLX) {
Chip_ENET_SetDuplex(LPC_ETHERNET, true);
}
else {
Chip_ENET_SetDuplex(LPC_ETHERNET, false);
}
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up,
(void *) &lpc_netif, 1);
}
else {
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down,
(void *) &lpc_netif, 1);
}
}
// DEBUGOUT("Link connect status: %d\n", ((physts & PHY_LINK_CONNECTED) != 0));
/* Delay for link detection */
msDelay(250);
if (!prt_ip && lpc_netif.ip_addr.addr) {
prt_ip = 1;
ip_addr_changed(&lpc_netif);
}
}
}
/* LWIP kickoff and PHY link monitor thread */
static void vSetupIFTask(void *pvParameters) {
ip_addr_t ipaddr, netmask, gw;
volatile s32_t tcpipdone = 0;
uint32_t physts;
static int prt_ip = 0;
DEBUGSTR("LWIP HTTP Web Server FreeRTOS Demo...\r\n");
/* Wait until the TCP/IP thread is finished before
continuing or wierd things may happen */
DEBUGSTR("Waiting for TCPIP thread to initialize...\r\n");
tcpip_init(tcpip_init_done_signal, (void *) &tcpipdone);
while (!tcpipdone) {
msDelay(1);
}
DEBUGSTR("Starting LWIP HTTP server...\r\n");
/* Static IP assignment */
#if LWIP_DHCP
IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
#else
IP4_ADDR(&gw, 10, 1, 10, 1);
IP4_ADDR(&ipaddr, 10, 1, 10, 234);
IP4_ADDR(&netmask, 255, 255, 255, 0);
#endif
/* Add netif interface for lpc17xx_8x */
memset(&lpc_netif, 0, sizeof(lpc_netif));
if (!netif_add(&lpc_netif, &ipaddr, &netmask, &gw, NULL, lpc_enetif_init,
tcpip_input)) {
DEBUGSTR("Net interface failed to initialize\r\n");
while(1);
}
netif_set_default(&lpc_netif);
netif_set_up(&lpc_netif);
/* Enable MAC interrupts only after LWIP is ready */
NVIC_SetPriority(ETHERNET_IRQn, config_ETHERNET_INTERRUPT_PRIORITY);
NVIC_EnableIRQ(ETHERNET_IRQn);
#if LWIP_DHCP
dhcp_start(&lpc_netif);
#endif
/* Initialize and start application */
http_server_netconn_init();
/* This loop monitors the PHY link and will handle cable events
via the PHY driver. */
while (1) {
/* Call the PHY status update state machine once in a while
to keep the link status up-to-date */
physts = lpcPHYStsPoll();
/* Only check for connection state when the PHY status has changed */
if (physts & PHY_LINK_CHANGED) {
if (physts & PHY_LINK_CONNECTED) {
Board_LED_Set(0, true);
prt_ip = 0;
/* Set interface speed and duplex */
if (physts & PHY_LINK_SPEED100) {
Chip_ENET_Set100Mbps(LPC_ETHERNET);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 100000000);
}
else {
Chip_ENET_Set10Mbps(LPC_ETHERNET);
NETIF_INIT_SNMP(&lpc_netif, snmp_ifType_ethernet_csmacd, 10000000);
}
if (physts & PHY_LINK_FULLDUPLX) {
Chip_ENET_SetFullDuplex(LPC_ETHERNET);
}
else {
Chip_ENET_SetHalfDuplex(LPC_ETHERNET);
}
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up,
(void *) &lpc_netif, 1);
}
else {
Board_LED_Set(0, false);
tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down,
(void *) &lpc_netif, 1);
}
/* Delay for link detection (250mS) */
vTaskDelay(configTICK_RATE_HZ / 4);
}
/* Print IP address info */
if (!prt_ip) {
if (lpc_netif.ip_addr.addr) {
static char tmp_buff[16];
DEBUGOUT("IP_ADDR : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.ip_addr, tmp_buff, 16));
DEBUGOUT("NET_MASK : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.netmask, tmp_buff, 16));
DEBUGOUT("GATEWAY_IP : %s\r\n", ipaddr_ntoa_r((const ip_addr_t *) &lpc_netif.gw, tmp_buff, 16));
prt_ip = 1;
}
}
}
}
