void
main(int argc, char **argv)
{
contiki_argc = argc;
contiki_argv = argv;
#else /* WITH_ARGS */
void
main(void)
{
#endif /* WITH_ARGS */
process_init();
#if 1
ethernet_config = config_read("contiki.cfg");
#else
{
static struct ethernet_config config = {0xDE08, "cs8900a.eth"};
uip_ipaddr_t addr;
uip_ipaddr(&addr, 192,168,0,128);
uip_sethostaddr(&addr);
uip_ipaddr(&addr, 255,255,255,0);
uip_setnetmask(&addr);
uip_ipaddr(&addr, 192,168,0,1);
uip_setdraddr(&addr);
uip_ipaddr(&addr, 192,168,0,1);
uip_nameserver_update(&addr, UIP_NAMESERVER_INFINITE_LIFETIME);
ethernet_config = &config;
}
#endif
procinit_init();
process_start((struct process *)ðernet_process, (void *)ethernet_config);
autostart_start(autostart_processes);
log_message("Contiki up and running ...", "");
while(1) {
process_run();
etimer_request_poll();
}
}
void
dhcpc_configured(const struct dhcpc_state *s)
{
uip_sethostaddr(s->ipaddr);
uip_setnetmask(s->netmask);
uip_setdraddr(s->default_router);
#if CFG_SUPPORT_DNS
resolv_conf(s->dnsaddr);
resolv_query("www.baidu.com");
#endif
}
/*-----------------------------------------------------------------------------------*/
void
main(void)
{
struct ethernet_config *ethernet_config;
#if WITH_REBOOT
rebootafterexit();
#endif /* WITH_REBOOT */
videomode(VIDEOMODE_80COL);
process_init();
#if 1
ethernet_config = config_read("contiki.cfg");
#else
{
static struct ethernet_config config = {0xC0B0, "cs8900a.eth"};
uip_ipaddr_t addr;
uip_ipaddr(&addr, 192,168,0,128);
uip_sethostaddr(&addr);
uip_ipaddr(&addr, 255,255,255,0);
uip_setnetmask(&addr);
uip_ipaddr(&addr, 192,168,0,1);
uip_setdraddr(&addr);
uip_ipaddr(&addr, 192,168,0,1);
resolv_conf(&addr);
ethernet_config = &config;
}
#endif
procinit_init();
process_start((struct process *)ðernet_process, (char *)ethernet_config);
autostart_start(autostart_processes);
log_message("Contiki up and running ...", "");
while(1) {
process_run();
etimer_request_poll();
clock_update();
}
}
int sendmail_main(int argc, char *argv[])
{
struct in_addr addr;
#if defined(CONFIG_EXAMPLES_SENDMAIL_NOMAC)
uint8_t mac[IFHWADDRLEN];
#endif
void *handle;
printf("sendmail: To: %s\n", g_recipient);
printf("sendmail: From: %s\n", g_sender);
printf("sendmail: Subject: %s\n", g_subject);
printf("sendmail: Body: %s\n", g_msg_body);
/* Many embedded network interfaces must have a software assigned MAC */
#ifdef CONFIG_EXAMPLES_SENDMAIL_NOMAC
mac[0] = 0x00;
mac[1] = 0xe0;
mac[2] = 0xde;
mac[3] = 0xad;
mac[4] = 0xbe;
mac[5] = 0xef;
uip_setmacaddr("eth0", mac);
#endif
/* Set up our host address */
addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_IPADDR);
uip_sethostaddr("eth0", &addr);
/* Set up the default router address */
addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_DRIPADDR);
uip_setdraddr("eth0", &addr);
/* Setup the subnet mask */
addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_NETMASK);
uip_setnetmask("eth0", &addr);
/* Then send the mail */
uip_ipaddr(addr.s_addr, 127, 0, 0, 1);
handle = smtp_open();
if (handle)
{
smtp_configure(handle, g_host_name, &addr.s_addr);
smtp_send(handle, g_recipient, NULL, g_sender, g_subject,
g_msg_body, strlen(g_msg_body));
smtp_close(handle);
}
return 0;
}
void Network::dhcpc_configured(uint32_t ipaddr, uint32_t ipmask, uint32_t ipgw)
{
memcpy(this->ipaddr, &ipaddr, 4);
memcpy(this->ipmask, &ipmask, 4);
memcpy(this->ipgw, &ipgw, 4);
uip_sethostaddr((u16_t*)this->ipaddr);
uip_setnetmask((u16_t*)this->ipmask);
uip_setdraddr((u16_t*)this->ipgw);
setup_servers();
}
void netif_set_addr(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask,
struct ip_addr *gw)
{
uip_ipaddr_t hipaddr;
uip_ipaddr(hipaddr, RT_LWIP_IPADDR0,RT_LWIP_IPADDR1,RT_LWIP_IPADDR2,RT_LWIP_IPADDR3);
uip_sethostaddr(hipaddr);
uip_ipaddr(hipaddr, RT_LWIP_GWADDR0,RT_LWIP_GWADDR1,RT_LWIP_GWADDR2,RT_LWIP_GWADDR3);
uip_setdraddr(hipaddr);
uip_ipaddr(hipaddr, RT_LWIP_MSKADDR0,RT_LWIP_MSKADDR1,RT_LWIP_MSKADDR2,RT_LWIP_MSKADDR3);
uip_setnetmask(hipaddr);
return ;
}
/*---------------------------------------------------------------------------*/
void
dhcpc_configured(const struct dhcpc_state *s)
{
uip_sethostaddr(s->ipaddr);
uip_setdraddr(s->default_router);
uip_setnetmask(s->netmask);
// uip_udp_remove(s->conn);
#ifdef TDTP_SOCKAPP
tdtp_init();
#endif
}
void dhcpc_configured(const struct dhcpc_state *s)
{
#ifdef MY_DEBUG
//rprintf("IP : %d.%d.%d.%d\n", uip_ipaddr1(s->ipaddr), uip_ipaddr2(s->ipaddr), uip_ipaddr3(s->ipaddr), uip_ipaddr4(s->ipaddr));
//rprintf("NM : %d.%d.%d.%d\n", uip_ipaddr1(s->netmask), uip_ipaddr2(s->netmask), uip_ipaddr3(s->netmask), uip_ipaddr4(s->netmask));
//rprintf("GW : %d.%d.%d.%d\n", uip_ipaddr1(s->default_router), uip_ipaddr2(s->default_router), uip_ipaddr3(s->default_router), uip_ipaddr4(s->default_router));
#endif
uip_sethostaddr(s->ipaddr);
uip_setnetmask(s->netmask);
uip_setdraddr(s->default_router);
}
void dhcpc_configured(const struct dhcpc_state *s) {
#ifdef XTCP_VERBOSE_DEBUG
printf("dhcp: ");uip_printip4(s->ipaddr);printf("\n");
#endif
#if UIP_USE_AUTOIP
autoip_stop();
#endif
uip_sethostaddr(s->ipaddr);
uip_setdraddr(s->default_router);
uip_setnetmask(s->netmask);
uip_xtcp_up();
dhcp_done = 1;
}
/*-----------------------------------------------------------------------------------*/
void
dhcpc_configured(const struct dhcpc_state *s)
{
uip_sethostaddr(&s->ipaddr);
uip_setnetmask(&s->netmask);
uip_setdraddr(&s->default_router);
#if WITH_DNS
resolv_conf(&s->dnsaddr);
#endif /* WITH_DNS */
set_statustext("Configured.");
process_post(PROCESS_CURRENT(), PROCESS_EVENT_MSG, NULL);
}
void dhcpc_configured(const struct dhcpc_state *s)
{
if( s->ipaddr[ 0 ] != 0 )
{
uip_sethostaddr( s->ipaddr );
uip_setnetmask( s->netmask );
uip_setdraddr( s->default_router );
resolv_conf( ( u16_t* )s->dnsaddr );
elua_uip_configured = 1;
}
else
elua_uip_conf_static();
}
static void elua_uip_conf_static()
{
uip_ipaddr_t ipaddr;
uip_ipaddr( ipaddr, ELUA_CONF_IPADDR0, ELUA_CONF_IPADDR1, ELUA_CONF_IPADDR2, ELUA_CONF_IPADDR3 );
uip_sethostaddr( ipaddr );
uip_ipaddr( ipaddr, ELUA_CONF_NETMASK0, ELUA_CONF_NETMASK1, ELUA_CONF_NETMASK2, ELUA_CONF_NETMASK3 );
uip_setnetmask( ipaddr );
uip_ipaddr( ipaddr, ELUA_CONF_DEFGW0, ELUA_CONF_DEFGW1, ELUA_CONF_DEFGW2, ELUA_CONF_DEFGW3 );
uip_setdraddr( ipaddr );
uip_ipaddr( ipaddr, ELUA_CONF_DNS0, ELUA_CONF_DNS1, ELUA_CONF_DNS2, ELUA_CONF_DNS3 );
resolv_conf( ipaddr );
elua_uip_configured = 1;
}
/*-----------------------------------------------------------------------------------*/
struct ethernet_config * CC_FASTCALL
config_read(char *filename)
{
static struct {
uip_ipaddr_t hostaddr;
uip_ipaddr_t netmask;
uip_ipaddr_t draddr;
uip_ipaddr_t resolvaddr;
struct ethernet_config ethernetcfg;
} config;
int file;
file = cfs_open(filename, CFS_READ);
if(file < 0) {
log_message(filename, ": File not found");
error_exit();
}
if(cfs_read(file, &config, sizeof(config)) < sizeof(config)
- sizeof(config.ethernetcfg.name)) {
log_message(filename, ": No config file");
error_exit();
}
cfs_close(file);
log_message("IP Address: ", ipaddrtoa(&config.hostaddr, uip_buf));
log_message("Subnet Mask: ", ipaddrtoa(&config.netmask, uip_buf));
log_message("Def. Router: ", ipaddrtoa(&config.draddr, uip_buf));
log_message("DNS Server: ", ipaddrtoa(&config.resolvaddr, uip_buf));
#ifndef ETHERNET
log_message("Eth. Driver: ", config.ethernetcfg.name);
#else /* !ETHERNET */
#define _stringize(arg) #arg
#define stringize(arg) _stringize(arg)
log_message("Eth. Driver: ", stringize(ETHERNET));
#undef _stringize
#undef stringize
#endif /* !ETHERNET */
log_message("Driver Port: $", utoa(config.ethernetcfg.addr, uip_buf, 16));
uip_sethostaddr(&config.hostaddr);
uip_setnetmask(&config.netmask);
uip_setdraddr(&config.draddr);
#if WITH_DNS
resolv_conf(&config.resolvaddr);
#endif /* WITH_DNS */
return &config.ethernetcfg;
}
void net_conf_uip_set(void)
{
uip_ipaddr_t ipaddr;
uip_ipaddr(ipaddr, net_conf_ip_addr[0], net_conf_ip_addr[1],
net_conf_ip_addr[2], net_conf_ip_addr[3]);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, net_conf_gateway[0], net_conf_gateway[1],
net_conf_gateway[2], net_conf_gateway[3]);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, net_conf_net_mask[0], net_conf_net_mask[1],
net_conf_net_mask[2], net_conf_net_mask[3]);
uip_setnetmask(ipaddr);
}
void dhcpc_configured(const struct dhcpc_state *s) {
uip_sethostaddr(&s->ipaddr);
uip_setnetmask(&s->netmask);
uip_setdraddr(&s->default_router);
/* We don't call resolv_conf here, because that would drag in all
the resolver code and state whether or not it's used by the
sketch. Instead we pass the address of the DNS server to the
DHCP status callback code provided by the sketch and allow that
to initialise the resolver if desired. */
// resolv_conf(s->dnsaddr);
if (uip.dhcp_status_callback!=NULL) {
uip.dhcp_status_callback(DHCP_STATUS_OK, &s->dnsaddr);
}
}
void
dhcpc_configured(const struct dhcpc_state *s)
{
if(s == 0) {
set_eeprom_addr();
return;
}
ewip(s->ipaddr, EE_IP4_ADDR); uip_sethostaddr(s->ipaddr);
ewip(s->default_router, EE_IP4_GATEWAY); uip_setdraddr(s->default_router);
ewip(s->netmask, EE_IP4_NETMASK); uip_setnetmask(s->netmask);
//resolv_conf(s->dnsaddr);
uip_udp_remove(s->conn);
ip_initialized();
}
s32 UIP_TASK_NetmaskSet(u32 mask)
{
uip_ipaddr_t ipaddr;
my_netmask = mask;
uip_ipaddr(ipaddr,
((mask)>>24) & 0xff,
((mask)>>16) & 0xff,
((mask)>> 8) & 0xff,
((mask)>> 0) & 0xff);
uip_setnetmask(ipaddr);
return 0; // no error
}
/*-----------------------------------------------------------------------------------*/
void
main(void)
{
struct ethernet_config *ethernet_config;
clrscr();
bordercolor(BORDERCOLOR);
bgcolor(SCREENCOLOR);
process_init();
#if 1
ethernet_config = config_read("contiki.cfg");
#else
{
static struct ethernet_config config = {0xD500, "cs8900a.eth"};
uip_ipaddr_t addr;
uip_ipaddr(&addr, 192,168,0,128);
uip_sethostaddr(&addr);
uip_ipaddr(&addr, 255,255,255,0);
uip_setnetmask(&addr);
uip_ipaddr(&addr, 192,168,0,1);
uip_setdraddr(&addr);
uip_ipaddr(&addr, 192,168,0,1);
resolv_conf(&addr);
ethernet_config = &config;
}
#endif
procinit_init();
process_start((struct process *)ðernet_process, (char *)ethernet_config);
autostart_start(autostart_processes);
log_message("Contiki up and running ...", "");
while(1) {
process_run();
etimer_request_poll();
}
}
void
zbus_stack_init (void)
{
uip_ipaddr_t ip;
set_CONF_ZBUS_IP(&ip);
uip_sethostaddr(&ip);
#ifdef IPV6_SUPPORT
uip_setprefixlen(CONF_ZBUS_IP6_PREFIX_LEN);
#else
set_CONF_ZBUS_IP4_NETMASK(&ip);
uip_setnetmask(&ip);
#endif
}
void SerialIPStack::begin(IP_ADDR myIP, IP_ADDR subnet)
{
uip_ipaddr_t ipaddr;
timer_set(&this->periodic_timer, CLOCK_SECOND / 4);
slipdev_init();
uip_init();
uip_ipaddr(ipaddr, myIP.a, myIP.b, myIP.c, myIP.d);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, subnet.a, subnet.b, subnet.c, subnet.d);
uip_setnetmask(ipaddr);
}
/*-----------------------------------------------------------------------------------*/
void
dhcpc_unconfigured(const struct dhcpc_state *s)
{
static uip_ipaddr_t nulladdr;
uip_sethostaddr(&nulladdr);
uip_setnetmask(&nulladdr);
uip_setdraddr(&nulladdr);
#if WITH_DNS
resolv_conf(&nulladdr);
#endif /* WITH_DNS */
set_statustext("Unconfigured.");
process_post(PROCESS_CURRENT(), PROCESS_EVENT_MSG, NULL);
}
/*-----------------------------------------------------------------------------------*/
void
config_read(char *filename)
{
int file;
file = cfs_open(filename, CFS_READ);
if(file < 0) {
log_message(filename, ": File not found");
error_exit();
}
if(cfs_read(file, &config, sizeof(config)) < sizeof(uip_ipaddr_t) * 4
+ sizeof(uint16_t)) {
log_message(filename, ": No config file");
error_exit();
}
cfs_close(file);
log_message("IP Address: ", ipaddrtoa(&config.hostaddr, uip_buf));
log_message("Subnet Mask: ", ipaddrtoa(&config.netmask, uip_buf));
log_message("Def. Router: ", ipaddrtoa(&config.draddr, uip_buf));
log_message("DNS Server: ", ipaddrtoa(&config.resolvaddr, uip_buf));
#ifdef STATIC_DRIVER
#define _stringize(arg) #arg
#define stringize(arg) _stringize(arg)
#if WITH_SLIP
log_message("SLIP Driver: ", stringize(STATIC_DRIVER));
#else /* WITH_SLIP */
log_message("Eth. Driver: ", stringize(STATIC_DRIVER));
#endif /* WITH_SLIP */
#undef _stringize
#undef stringize
#else /* STATIC_DRIVER */
log_message("Eth. Driver: ", config.ethernet.name);
#endif /* STATIC_DRIVER */
#if !WITH_SLIP
log_message("Driver Port: $", utoa(config.ethernet.addr, uip_buf, 16));
#endif /* !WITH_SLIP */
uip_sethostaddr(&config.hostaddr);
uip_setnetmask(&config.netmask);
uip_setdraddr(&config.draddr);
#if WITH_DNS
uip_nameserver_update(&config.resolvaddr, UIP_NAMESERVER_INFINITE_LIFETIME);
#endif /* WITH_DNS */
}
/*---------------------------------------------------------------------------*/
int
main(void)
{
DBGMCU_Config(DBGMCU_SLEEP | DBGMCU_STOP | DBGMCU_STANDBY, ENABLE);
leds_init();
//printf("\rStarting Contiki on STM32VL Discovery...\n\r");
clock_init();
process_init();
uip_init();
uip_fw_init();
process_start(&tcpip_process, NULL);
process_start(&uip_fw_process, NULL);
uip_ipaddr(&hostaddr, 172, 16, 0, 3);
uip_sethostaddr(&hostaddr);
uip_ipaddr(&netmask, 255, 255, 0, 0);
uip_setnetmask(&netmask);
uip_ipaddr(&netmask, 172, 16, 0, 1);
uip_setdraddr(&draddr);
process_start(&etimer_process, NULL);
ctimer_init();
/* Networking stack. */
NETSTACK_RADIO.init();
NETSTACK_RDC.init();
NETSTACK_MAC.init();
NETSTACK_NETWORK.init();
{
rimeaddr_t rimeaddr;
rimeaddr.u8[0] = 0x02;
rimeaddr.u8[1] = 0x00;
rimeaddr_set_node_addr(&rimeaddr);
}
autostart_start(autostart_processes);
while (1)
{
process_run();
}
return 0;
}
void autoip_configured(uip_ipaddr_t autoip_ipaddr) {
if (!dhcp_done) {
uip_ipaddr_t ipaddr;
#ifdef XTCP_VERBOSE_DEBUG
printf("ipv4ll: ");
uip_printip4(autoip_ipaddr);
printf("\n");
#endif /* XTCP_VERBOSE_DEBUG */
uip_sethostaddr(autoip_ipaddr);
uip_ipaddr(ipaddr, 255, 255, 0, 0);
uip_setnetmask(ipaddr);
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_setdraddr(ipaddr);
uip_xtcp_up();
}
}
/**
* \brief Initialize the uIP startup settings
* \param void There are no parameters needed.
* \return No return values.
*/
void
ip_init(void)
{
uip_ipaddr_t ip_addr, subnet;
/*Init uIP Stack*/
uip_init();
/*Set IPv4 Address*/
uip_ipaddr(&ip_addr, 192, 168, 2, 2);
uip_sethostaddr(&ip_addr);
/*Set (IPv4) Subnet*/
uip_ipaddr(&subnet, 255, 255, 255, 0);
uip_setnetmask(&subnet);
}
/////////////////////////////////////////////////////////////////////////////
// Called by DHCP client once it got IP addresses
/////////////////////////////////////////////////////////////////////////////
void dhcpc_configured(const struct dhcpc_state *s)
{
// set IP settings
uip_sethostaddr(s->ipaddr);
uip_setnetmask(s->netmask);
uip_setdraddr(s->default_router);
// start services
UIP_TASK_StartServices();
// print unused settings
MIOS32_MIDI_SendDebugMessage("[UIP_TASK] Got DNS server %d.%d.%d.%d\n",
uip_ipaddr1(s->dnsaddr), uip_ipaddr2(s->dnsaddr),
uip_ipaddr3(s->dnsaddr), uip_ipaddr4(s->dnsaddr));
MIOS32_MIDI_SendDebugMessage("[UIP_TASK] Lease expires in %d hours\n",
(ntohs(s->lease_time[0])*65536ul + ntohs(s->lease_time[1]))/3600);
}
/*! \brief Inicia as estruturas com os dados armazenados na memória interna não-volátil */
void appInitHostIp(void)
{
volatile u16_t addr[2];
//Configura endereço ip local
addr[0] = HTONS((((u16_t)memoryData.ipEstatico[0])<< 8) + memoryData.ipEstatico[1]);
addr[1] = HTONS((((u16_t)memoryData.ipEstatico[2])<< 8) + memoryData.ipEstatico[3]);
uip_sethostaddr(addr);
addr[0] = HTONS((((u16_t)memoryData.netMask[0])<< 8) + memoryData.netMask[1]);
addr[1] = HTONS((((u16_t)memoryData.netMask[2])<< 8) + memoryData.netMask[3]);
uip_setnetmask(addr);
addr[0] = memoryData.drAddr[0];
addr[1] = memoryData.drAddr[1];
uip_setdraddr(addr);
}
void dhcpc_configured(const struct dhcpc_state *s)
{
uip_ipaddr_t addr;
// byte swap the network info
_ip_addr[0] = (s->ipaddr[0]);
_ip_addr[1] = (s->ipaddr[0]) >> 8;
_ip_addr[2] = (s->ipaddr[1]);
_ip_addr[3] = (s->ipaddr[1]) >> 8;
_net_mask[0] = (s->netmask[0]);
_net_mask[1] = (s->netmask[0]) >> 8;
_net_mask[2] = (s->netmask[1]);
_net_mask[3] = (s->netmask[1]) >> 8;
_gateway[0] = (s->default_router[0]);
_gateway[1] = (s->default_router[0]) >> 8;
_gateway[2] = (s->default_router[1]);
_gateway[3] = (s->default_router[1]) >> 8;
#ifdef DHCP_DEBUG
eeprom_write_block (_ip_addr, &ee_ip_addr, 4);
eeprom_write_block (_net_mask,&ee_net_mask,4);
eeprom_write_block (_gateway, &ee_gateway, 4);
#endif
// re-init just in case
uip_setethaddr(my_eth_addr);
// set ip
uip_ipaddr(&addr, _ip_addr[0], _ip_addr[1], _ip_addr[2], _ip_addr[3]);
uip_sethostaddr(&addr);
// set netmask
uip_ipaddr(&addr,_net_mask[0], _net_mask[1], _net_mask[2], _net_mask[3]);
uip_setnetmask(&addr);
// set gateway
uip_ipaddr(&addr,_gateway[0], _gateway[1], _gateway[2], _gateway[3]);
uip_setdraddr(&addr);
// code to use dhcp server lease time removed due to uint16_t overflow
// issues with calculating the time. Just use 5 minutes instead.
timer_set(&dhcp_timer, 5 * 60 * CLOCK_SECOND);
}
/*-----------------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
uip_ipaddr_t addr;
gtk_init(&argc, &argv);
process_init();
procinit_init();
uip_ipaddr(&addr, 192,168,2,2);
uip_sethostaddr(&addr);
uip_ipaddr(&addr, 192,168,2,1);
uip_setdraddr(&addr);
uip_ipaddr(&addr, 255,255,255,0);
uip_setnetmask(&addr);
/* program_handler_add(&netconf_dsc, "Network setup", 1);
program_handler_add(&ftp_dsc, "FTP client", 1);
program_handler_add(&editor_dsc, "Editor", 1);
program_handler_add(&www_dsc, "Web browser", 1);
program_handler_add(&processes_dsc, "Processes", 1);
program_handler_add(&shell_dsc, "Command shell", 1);
program_handler_add(&calc_dsc, "Calculator", 1);*/
/* program_handler_add(&email_dsc, "E-mail", 1);*/
/* program_handler_add(&irc_dsc, "IRC", 1);*/
/* program_handler_add(&vnc_dsc, "VNC client", 1);*/
/* program_handler_add(&dhcp_dsc, "DHCP client", 1);*/
uip_fw_default(&tapif);
gtk_timeout_add(20, idle_callback, NULL);
gtk_main();
return 0;
argv = argv;
argc = argc;
}
/**
* @brief Configure Network
* @param None
* @retval None
*/
void Network_Configuration(void)
{
struct uip_eth_addr mac = {{ 0xeb, 0xa0, 0x00, 0x00, 0x00, 0x00 }};
enc28j60_init(mac.addr);
uip_init();
uip_arp_init();
uip_setethaddr(mac);
uip_ipaddr_t ipaddr;
uip_ipaddr(ipaddr, 192, 168, 0, 100);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 255, 255, 255, 0);
uip_setnetmask(ipaddr);
uip_ipaddr(ipaddr, 192, 168, 0, 1);
uip_setdraddr(ipaddr);
uip_listen(HTONS(4000));
}
