void Network::init(void)
{
// two timers for tcp/ip
timer_set(&periodic_timer, CLOCK_SECOND / 2); /* 0.5s */
timer_set(&arp_timer, CLOCK_SECOND * 10); /* 10s */
// Initialize the uIP TCP/IP stack.
uip_init();
uip_setethaddr(mac_address);
if (!use_dhcp) { // manual setup of ip
uip_ipaddr_t tip; /* local IP address */
uip_ipaddr(tip, ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
uip_sethostaddr(tip); /* host IP address */
printf("IP Addr: %d.%d.%d.%d\n", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
uip_ipaddr(tip, ipgw[0], ipgw[1], ipgw[2], ipgw[3]);
uip_setdraddr(tip); /* router IP address */
printf("IP GW: %d.%d.%d.%d\n", ipgw[0], ipgw[1], ipgw[2], ipgw[3]);
uip_ipaddr(tip, ipmask[0], ipmask[1], ipmask[2], ipmask[3]);
uip_setnetmask(tip); /* mask */
printf("IP mask: %d.%d.%d.%d\n", ipmask[0], ipmask[1], ipmask[2], ipmask[3]);
setup_servers();
}else{
#if UIP_CONF_UDP
dhcpc_init(mac_address, sizeof(mac_address));
dhcpc_request();
printf("Getting IP address....\n");
#endif
}
}
void
dhcpc_renew(void)
{
uip_ipaddr_t addr;
#if defined PORT_APP_MAPPER
if (dhcpc_running)
return;
dhcpc_running = 1;
#else
if (s.state != STATE_CONFIG_RECEIVED)
{
return;
}
#endif
//sendString("\r\ndhcpc renew called");
// if no server ip then we have to do a full request
if (s.serverid[0] == 0)
{
dhcpc_init(s.mac_addr, s.mac_len);
return;
}
// unicast to dhcp server
uip_ipaddr(addr, s.serverid[0], s.serverid[1], s.serverid[2], s.serverid[3]);
s.conn = uip_udp_new(&addr, HTONS(DHCPC_SERVER_PORT));
if(s.conn != NULL) {
uip_udp_bind(s.conn, HTONS(DHCPC_CLIENT_PORT));
}
s.state = STATE_RENEW;
PT_INIT(&s.pt);
}
/*****************************************************************************
函 数 名 : uip_app_init
功能描述 : the uip appliacation function
输入参数 : void
输出参数 : 无
返 回 值 :
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2017年4月17日
作 者 : QSWWD
修改内容 : 新生成函数
*****************************************************************************/
void uip_app_init(void)
{
uip_ipaddr_t ipaddr;
uip_ipaddr(ipaddr, 8,8,8,8);
/* hello_world_init();*/
/*
resolv_init();
uip_ipaddr(ipaddr, 195,54,122,204);
resolv_conf(ipaddr);
resolv_query("www.sics.se");*/
example1_init();
example2_init();
telnetd_init();
smtp_init();
uip_ipaddr(ipaddr, 127,0,0,1);
smtp_configure("localhost", ipaddr);
SMTP_SEND("*****@*****.**", NULL, "*****@*****.**",
"Testing SMTP from uIP",
"Test message sent by uIP\r\n");
hello_world_init();
httpd_init();
#if UIP_UDP
my_udp8899_init();
dhcpc_init(&uip_ethaddr,6);
resolv_init();
resolv_conf(ipaddr);
resolv_query("www.baidu.com");
#endif
}
/**
* Initialize demo application
*/
static void _app_init(void)
{
printf("P: telnetd application init\n\r");
telnetd_init();
#ifdef __DHCPC_H__
printf("P: DHCPC Init\n\r");
dhcpc_init(MacAddress.addr, 6);
#endif
}
/**
* Initialize demo application
*/
static void _app_init(void)
{
printf("P: hello-world application init\n\r");
hello_world_init();
#ifdef __DHCPC_H__
printf("P: DHCPC Init\n\r");
dhcpc_init(MacAddress.addr, 6);
#endif
}
//配置网卡硬件，并设置MAC地址
//返回值：0，正常；1，失败；
u8 tapdev_init(void)
{
u32 wait_count;
u8 i, res = 0;
#ifndef DHCP_ENABLE
uip_ipaddr_t ipaddr;
#endif
res = ENC28J60_Init((u8*)Modbus.mac_addr); //初始化ENC28J60
//把IP地址和MAC地址写入缓存区
for (i = 0; i < 6; i++)
{
uip_ethaddr.addr[i] = Modbus.mac_addr[i];
}
//指示灯状态:0x476 is PHLCON LEDA(绿)=links status, LEDB(红)=receive/transmit
//PHLCON：PHY 模块LED 控制寄存器
ENC28J60_PHY_Write(PHLCON, 0x0476);
uip_init(); //uIP初始化
if(Modbus.tcp_type == 0)
{
U8_T temp[4];
uip_ipaddr(ipaddr, Modbus.ip_addr[0], Modbus.ip_addr[1], Modbus.ip_addr[2], Modbus.ip_addr[3]); //设置本地设置IP地址
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, Modbus.getway[0], Modbus.getway[1], Modbus.getway[2], Modbus.getway[3]); //设置网关IP地址(其实就是你路由器的IP地址)
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, Modbus.subnet[0], Modbus.subnet[1], Modbus.subnet[2], Modbus.subnet[3]); //设置网络掩码
uip_setnetmask(ipaddr);
// flag_dhcp_configured = 2;
temp[0] = Modbus.ip_addr[0];
temp[1] = Modbus.ip_addr[1];
temp[2] = Modbus.ip_addr[2];
temp[3] = Modbus.ip_addr[3];
temp[0] |= (255 - Modbus.subnet[0]);
temp[1] |= (255 - Modbus.subnet[1]);
temp[2] |= (255 - Modbus.subnet[2]);
temp[3] |= (255 - Modbus.subnet[3]);
uip_ipaddr(uip_hostaddr_submask,temp[0], temp[1],temp[2] ,temp[3]);
delay_ms(1);
}
else // DHCP
{
// flag_dhcp_configured = 0;
dhcpc_init(Modbus.mac_addr, 6);
dhcpc_request();
}
// printf("res=%u\n\r",res);
return res;
}
void uip_server_init(chanend xtcp[], int num_xtcp, xtcp_ipconfig_t* ipconfig, unsigned char mac_address[6])
{
if (ipconfig != NULL)
memcpy(&uip_static_ipconfig, ipconfig, sizeof(xtcp_ipconfig_t));
memcpy(&uip_ethaddr, mac_address, 6);
uip_init();
#if UIP_IGMP
igmp_init();
#endif
if (ipconfig != NULL && (*((int*)ipconfig->ipaddr) != 0)) {
uip_static_ip = 1;
}
if (ipconfig == NULL)
{
uip_ipaddr_t ipaddr;
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_sethostaddr(ipaddr);
uip_setdraddr(ipaddr);
uip_setnetmask(ipaddr);
uip_setsubnetaddr();
} else {
uip_sethostaddr(ipconfig->ipaddr);
uip_setdraddr(ipconfig->gateway);
uip_setnetmask(ipconfig->netmask);
uip_setsubnetaddr();
#ifdef XTCP_VERBOSE_DEBUG
printstr("Address: ");uip_printip4(uip_hostaddr);printstr("\n");
printstr("Gateway: ");uip_printip4(uip_draddr);printstr("\n");
printstr("Netmask: ");uip_printip4(uip_netmask);printstr("\n");
#endif
}
{
#if UIP_USE_AUTOIP
int hwsum = mac_address[0] + mac_address[1] + mac_address[2]
+ mac_address[3] + mac_address[4] + mac_address[5];
autoip_init(hwsum + (hwsum << 16) + (hwsum << 24));
#endif
#if UIP_USE_DHCP
dhcpc_init(uip_ethaddr.addr, 6);
#endif
xtcpd_init(xtcp, num_xtcp);
}
}
void IP_config(void) {
#if UIP_UDP
// if DHCP is enabled, then initialize via DHCP, else use static settings
if (config.dhcpenable) {
dhcpc_init();
}
else {
uip_sethostaddr(config.ipaddr);
uip_setnetmask(config.netmask);
uip_setdraddr(config.gateway);
}
#else // UIP_UDP
// configure the interface with static settings
uip_sethostaddr(config.ipaddr);
uip_setnetmask(config.netmask);
uip_setdraddr(config.gateway);
#endif // UIP_UDP
}
void
ethernet_init(void)
{
// reset Ethernet
ENC28J60_RESET_DDR |= _BV( ENC28J60_RESET_BIT );
ENC28J60_RESET_PORT &= ~_BV( ENC28J60_RESET_BIT );
my_delay_ms( 200 );
// unreset Ethernet
ENC28J60_RESET_PORT |= _BV( ENC28J60_RESET_BIT );
my_delay_ms( 200 );
network_init();
mac.addr[0] = erb(EE_MAC_ADDR+0);
mac.addr[1] = erb(EE_MAC_ADDR+1);
mac.addr[2] = erb(EE_MAC_ADDR+2);
mac.addr[3] = erb(EE_MAC_ADDR+3);
mac.addr[4] = erb(EE_MAC_ADDR+4);
mac.addr[5] = erb(EE_MAC_ADDR+5);
network_set_MAC(mac.addr);
uip_setethaddr(mac);
uip_init();
ntp_conn = 0;
// setup two periodic timers
timer_set(&periodic_timer, CLOCK_SECOND / 4);
timer_set(&arp_timer, CLOCK_SECOND * 10);
if(erb(EE_USE_DHCP)) {
network_set_led(0x4A6);// LED A: Link Status LED B: Blink slow
dhcpc_init(&mac);
dhcp_state = PT_WAITING;
} else {
dhcp_state = PT_ENDED;
set_eeprom_addr();
}
}
void protocol_switcher_app_init(void)
{
telnet_client_init();
siemensTCP_app_init();
specserver_app_init();
webclient_init();
httpd_init();
resolv_init();
#ifndef USE_STATIC_IP
// Initialize the DHCP Client Application.
static struct uip_eth_addr sTempAddr;
uip_getethaddr(sTempAddr);
dhcpc_init(&sTempAddr.addr[0], 6);
dhcpc_request();
#else
uip_ip4addr_t uip_dnsaddr;
uip_ipaddr(uip_dnsaddr, DNS_IP1, DNS_IP2, DNS_IP3, DNS_IP4 );
resolv_conf(uip_dnsaddr);
#endif
}
/*! \brief Inicia aplicação */
void appInit(void)
{
u16_t dns[2];
//Verifica se o botão de reset está pressionado
if(checkResetBt())
{
appEraseFlashData();
}
//Adquire os dados da memória não volátil
appReadFlashData();
//Verifica a consistência dos dados armazenados na memória flash
appCheckFlashData();
if(memoryData.ipTipo == '0')
{
//Inicia o DHCP
ethaddr.addr[0] = ENC28J60_MAC0;
ethaddr.addr[1] = ENC28J60_MAC1;
ethaddr.addr[2] = MAC_CONC[0];
ethaddr.addr[3] = MAC_CONC[1];
ethaddr.addr[4] = MAC_CONC[2];
ethaddr.addr[5] = MAC_CONC[3];
uip_setethaddr(ethaddr);
dhcpc_init(ðaddr, sizeof(ethaddr));
}
else
{
//Inicia com ip fixo
appInitHostIp();
dns[0] = memoryData.dnsAddr[0];
dns[1] = memoryData.dnsAddr[1];
appSetDnsAddr(dns);
appSendConnect();
}
ciclos = memoryData.tempoPacote/5;
}
// Init application
void elua_uip_init( const struct uip_eth_addr *paddr )
{
// Set hardware address
uip_setethaddr( (*paddr) );
// Initialize the uIP TCP/IP stack.
uip_init();
uip_arp_init();
#ifdef BUILD_DHCPC
dhcpc_init( paddr->addr, sizeof( *paddr ) );
dhcpc_request();
#else
elua_uip_conf_static();
#endif
resolv_init();
#ifdef BUILD_CON_TCP
uip_listen( HTONS( ELUA_NET_TELNET_PORT ) );
#endif
}
int main(void)
{
network_init();
//CLKPR = (1<<CLKPCE); //Change prescaler
//CLKPR = (1<<CLKPS0); //Use prescaler 2
//clock_prescale_set(clock_div_2);
enc28j60Write(ECOCON, 1 & 0x7); //Get a 25MHz signal from enc28j60
uartInit();
uartSetBaudRate(9600);
rprintfInit(uartSendByte);
int i;
uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
clock_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
uip_init();
struct uip_eth_addr mac = {UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5};
uip_setethaddr(mac);
// set up the udp data stream
// configure the target system ip and port
uip_ipaddr_t target_ipaddr;
uip_ipaddr(&target_ipaddr, 192,168,0,10);
udpds_conf(&target_ipaddr, 1000, 1);
#ifdef __DHCPC_H__
dhcpc_init(&mac, 6);
#else
uip_ipaddr(ipaddr, 192,168,0,1);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,168,0,1);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
#endif /*__DHCPC_H__*/
while(1){
uip_len = network_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)){
uip_arp_ipin();
uip_input();
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}else if(BUF->type == htons(UIP_ETHTYPE_ARP)){
uip_arp_arpin();
if(uip_len > 0){
network_send();
}
}
}else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
}
//*****************************************************************************
//
// This example demonstrates the use of the Ethernet Controller with the uIP
// TCP/IP stack.
//
//*****************************************************************************
int
main(void)
{
uip_ipaddr_t ipaddr;
static struct uip_eth_addr sTempAddr;
long lPeriodicTimer, lARPTimer, lPacketLength;
unsigned long ulUser0, ulUser1;
unsigned long ulTemp;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Initialize the OLED display.
//
RIT128x96x4Init(1000000);
RIT128x96x4StringDraw("Ethernet with uIP", 12, 0, 15);
//
// Enable and Reset the Ethernet Controller.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH);
SysCtlPeripheralReset(SYSCTL_PERIPH_ETH);
//
// Enable Port F for Ethernet LEDs.
// LED0 Bit 3 Output
// LED1 Bit 2 Output
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3);
//
// Configure SysTick for a periodic interrupt.
//
SysTickPeriodSet(SysCtlClockGet() / SYSTICKHZ);
SysTickEnable();
SysTickIntEnable();
//
// Intialize the Ethernet Controller and disable all Ethernet Controller
// interrupt sources.
//
EthernetIntDisable(ETH_BASE, (ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER |
ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | ETH_INT_RX));
ulTemp = EthernetIntStatus(ETH_BASE, false);
EthernetIntClear(ETH_BASE, ulTemp);
//
// Initialize the Ethernet Controller for operation.
//
EthernetInitExpClk(ETH_BASE, SysCtlClockGet());
//
// Configure the Ethernet Controller for normal operation.
// - Full Duplex
// - TX CRC Auto Generation
// - TX Padding Enabled
//
EthernetConfigSet(ETH_BASE, (ETH_CFG_TX_DPLXEN | ETH_CFG_TX_CRCEN |
ETH_CFG_TX_PADEN));
//
// Wait for the link to become active.
//
RIT128x96x4StringDraw("Waiting for Link", 12, 8, 15);
ulTemp = EthernetPHYRead(ETH_BASE, PHY_MR1);
while((ulTemp & 0x0004) == 0)
{
ulTemp = EthernetPHYRead(ETH_BASE, PHY_MR1);
}
RIT128x96x4StringDraw("Link Established", 12, 16, 15);
//
// Enable the Ethernet Controller.
//
EthernetEnable(ETH_BASE);
//
// Enable the Ethernet interrupt.
//
IntEnable(INT_ETH);
//
// Enable the Ethernet RX Packet interrupt source.
//
EthernetIntEnable(ETH_BASE, ETH_INT_RX);
//
// Enable all processor interrupts.
//
IntMasterEnable();
//
// Initialize the uIP TCP/IP stack.
//
uip_init();
#ifdef USE_STATIC_IP
uip_ipaddr(ipaddr, DEFAULT_IPADDR0, DEFAULT_IPADDR1, DEFAULT_IPADDR2,
DEFAULT_IPADDR3);
uip_sethostaddr(ipaddr);
DisplayIPAddress(ipaddr, 18, 24);
uip_ipaddr(ipaddr, DEFAULT_NETMASK0, DEFAULT_NETMASK1, DEFAULT_NETMASK2,
DEFAULT_NETMASK3);
uip_setnetmask(ipaddr);
#else
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_sethostaddr(ipaddr);
DisplayIPAddress(ipaddr, 18, 24);
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_setnetmask(ipaddr);
#endif
//
// Configure the hardware MAC address for Ethernet Controller filtering of
// incoming packets.
//
// For the Ethernet Eval Kits, the MAC address will be stored in the
// non-volatile USER0 and USER1 registers. These registers can be read
// using the FlashUserGet function, as illustrated below.
//
FlashUserGet(&ulUser0, &ulUser1);
if((ulUser0 == 0xffffffff) || (ulUser1 == 0xffffffff))
{
//
// We should never get here. This is an error if the MAC address has
// not been programmed into the device. Exit the program.
//
RIT128x96x4StringDraw("MAC Address", 0, 16, 15);
RIT128x96x4StringDraw("Not Programmed!", 0, 24, 15);
while(1)
{
}
}
//
// Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC
// address needed to program the hardware registers, then program the MAC
// address into the Ethernet Controller registers.
//
sTempAddr.addr[0] = ((ulUser0 >> 0) & 0xff);
sTempAddr.addr[1] = ((ulUser0 >> 8) & 0xff);
sTempAddr.addr[2] = ((ulUser0 >> 16) & 0xff);
sTempAddr.addr[3] = ((ulUser1 >> 0) & 0xff);
sTempAddr.addr[4] = ((ulUser1 >> 8) & 0xff);
sTempAddr.addr[5] = ((ulUser1 >> 16) & 0xff);
//
// Program the hardware with it's MAC address (for filtering).
//
EthernetMACAddrSet(ETH_BASE, (unsigned char *)&sTempAddr);
uip_setethaddr(sTempAddr);
//
// Initialize the TCP/IP Application (e.g. web server).
//
httpd_init();
#ifndef USE_STATIC_IP
//
// Initialize the DHCP Client Application.
//
dhcpc_init(&sTempAddr.addr[0], 6);
dhcpc_request();
#endif
//
// Main Application Loop.
//
lPeriodicTimer = 0;
lARPTimer = 0;
while(true)
{
//
// Wait for an event to occur. This can be either a System Tick event,
// or an RX Packet event.
//
while(!g_ulFlags)
{
}
//
// If SysTick, Clear the SysTick interrupt flag and increment the
// timers.
//
if(HWREGBITW(&g_ulFlags, FLAG_SYSTICK) == 1)
{
HWREGBITW(&g_ulFlags, FLAG_SYSTICK) = 0;
lPeriodicTimer += SYSTICKMS;
lARPTimer += SYSTICKMS;
}
//
// Check for an RX Packet and read it.
//
lPacketLength = EthernetPacketGetNonBlocking(ETH_BASE, uip_buf,
sizeof(uip_buf));
if(lPacketLength > 0)
{
//
// Set uip_len for uIP stack usage.
//
uip_len = (unsigned short)lPacketLength;
//
// Clear the RX Packet event and renable RX Packet interrupts.
//
if(HWREGBITW(&g_ulFlags, FLAG_RXPKT) == 1)
{
HWREGBITW(&g_ulFlags, FLAG_RXPKT) = 0;
EthernetIntEnable(ETH_BASE, ETH_INT_RX);
}
//
// Process incoming IP packets here.
//
if(BUF->type == htons(UIP_ETHTYPE_IP))
{
uip_arp_ipin();
uip_input();
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0)
{
uip_arp_out();
EthernetPacketPut(ETH_BASE, uip_buf, uip_len);
uip_len = 0;
}
}
//
// Process incoming ARP packets here.
//
else if(BUF->type == htons(UIP_ETHTYPE_ARP))
{
uip_arp_arpin();
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0)
{
EthernetPacketPut(ETH_BASE, uip_buf, uip_len);
uip_len = 0;
}
}
}
//
// Process TCP/IP Periodic Timer here.
//
if(lPeriodicTimer > UIP_PERIODIC_TIMER_MS)
{
lPeriodicTimer = 0;
for(ulTemp = 0; ulTemp < UIP_CONNS; ulTemp++)
{
uip_periodic(ulTemp);
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0)
{
uip_arp_out();
EthernetPacketPut(ETH_BASE, uip_buf, uip_len);
uip_len = 0;
}
}
#if UIP_UDP
for(ulTemp = 0; ulTemp < UIP_UDP_CONNS; ulTemp++)
{
uip_udp_periodic(ulTemp);
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0)
{
uip_arp_out();
EthernetPacketPut(ETH_BASE, uip_buf, uip_len);
uip_len = 0;
}
}
#endif // UIP_UDP
}
//
// Process ARP Timer here.
//
if(lARPTimer > UIP_ARP_TIMER_MS)
{
lARPTimer = 0;
uip_arp_timer();
}
}
}
/////////////////////////////////////////////////////////////////////////////
// Configure DHCP mode (can be changed during runtime)
/////////////////////////////////////////////////////////////////////////////
s32 UIP_TASK_DHCP_EnableSet(u8 _dhcp_enabled)
{
uip_ipaddr_t ipaddr;
dhcp_enabled = _dhcp_enabled;
// branch depending on DHCP mode
if( dhcp_enabled ) {
// stop all services, will be started once we got the IP
UIP_TASK_StopServices();
// IP address/netmask/router must be 0
uip_ipaddr(ipaddr, 0x00, 0x00, 0x00, 0x00);
uip_sethostaddr(ipaddr);
uip_setnetmask(ipaddr);
uip_setdraddr(ipaddr);
dhcpc_init(uip_ethaddr.addr, sizeof(uip_ethaddr.addr));
#if DEBUG_VERBOSE_LEVEL >= 1
if( network_device_available() ) { // don't print message if ethernet device is not available, the message could confuse "normal users"
UIP_TASK_MUTEX_MIDIOUT_TAKE;
DEBUG_MSG("[UIP_TASK] DHCP Client requests the IP settings...\n");
UIP_TASK_MUTEX_MIDIOUT_GIVE;
}
#endif
} else {
// set my IP address
uip_ipaddr(ipaddr,
((my_ip_address)>>24) & 0xff,
((my_ip_address)>>16) & 0xff,
((my_ip_address)>> 8) & 0xff,
((my_ip_address)>> 0) & 0xff);
uip_sethostaddr(ipaddr);
// set my netmask
uip_ipaddr(ipaddr,
((my_netmask)>>24) & 0xff,
((my_netmask)>>16) & 0xff,
((my_netmask)>> 8) & 0xff,
((my_netmask)>> 0) & 0xff);
uip_setnetmask(ipaddr);
// default router
uip_ipaddr(ipaddr,
((my_gateway)>>24) & 0xff,
((my_gateway)>>16) & 0xff,
((my_gateway)>> 8) & 0xff,
((my_gateway)>> 0) & 0xff);
uip_setdraddr(ipaddr);
#if DEBUG_VERBOSE_LEVEL >= 1
if( network_device_available() ) { // don't print message if ethernet device is not available, the message could confuse "normal users"
UIP_TASK_MUTEX_MIDIOUT_TAKE;
DEBUG_MSG("[UIP_TASK] IP Address statically set:\n");
UIP_TASK_MUTEX_MIDIOUT_GIVE;
}
#endif
// start services immediately
UIP_TASK_StartServices();
}
return 0; // no error
}
/* -----------------------------------------------------------------------------
* Initialise the uip_server
* -------------------------------------------------------------------------- */
void uip_server_init(chanend xtcp[], int num_xtcp,
xtcp_ipconfig_t *ipconfig,
unsigned char *mac_address)
{
if (ipconfig != NULL)
memcpy(&uip_static_ipconfig, ipconfig, sizeof(xtcp_ipconfig_t));
/* set the mac_adress */
memcpy(&uip_lladdr, mac_address, 6);
#if 0 //XXX CHSC: not necessary? Be carefully with erasing the mac address...
/* The following line sets the uIP's link-layer address. This must be done
* before the tcpip_process is started since in its initialisation
* routine the function uip_netif_init() will be called from inside
* uip_init()and there the default IPv6 address will be set by combining
* the link local prefix (fe80::/64)and the link layer address. */
rimeaddr_copy((rimeaddr_t*) &uip_lladdr.addr, &rimeaddr_node_addr);
#endif
//TODO chsc: port the rtimer module (if really needed)
// /* rtimers needed for radio cycling */
// rtimer_init();
/* Initialise the process module */
process_init();
/* etimers must be started before ctimer_init */
process_start(&etimer_process, NULL);
ctimer_init();
/* this calls have to be made before the uip_init
* not exactely proved why. CHSC
* */
etimer_request_poll();
process_run();
uip_init();
#if UIP_CONF_IPV6 && UIP_CONF_IPV6_RPL
rpl_init();
#endif /* UIP_CONF_IPV6_RPL */
#if UIP_IGMP
igmp_init();
#endif /* UIP_IGMP */
if (ipconfig != NULL && (*((int*)ipconfig->ipaddr.u8) != 0)) {
uip_static_ip = 1;
}
if (ipconfig == NULL)
{
uip_ipaddr_t ipaddr;
#if UIP_CONF_IPV4
uip_ipaddr(&ipaddr, 0, 0, 0, 0);
uip_sethostaddr(&ipaddr);
uip_setdraddr(&ipaddr);
uip_setnetmask(&ipaddr);
#elif UIP_CONF_IPV6
uip_ip6addr(&ipaddr, 0, 0, 0, 0
, 0, 0, 0, 0);
#endif /* UIP_CONF_IPVx */
} else {
#if UIP_CONF_IPV4
uip_sethostaddr(&ipconfig->ipaddr);
uip_setdraddr(&ipconfig->gateway);
uip_setnetmask(&ipconfig->netmask);
#ifdef XTCP_VERBOSE_DEBUG
printf("Address: ");uip_printip4(uip_hostaddr);printf("\n");
printf("Gateway: ");uip_printip4(uip_draddr);printf("\n");
printf("Netmask: ");uip_printip4(uip_netmask);printf("\n");
#endif /* XTCP_VERBOSE_DEBUG */
#elif UIP_CONF_IPV6
#endif /* UIP_CONF_IPVx */
}
#if UIP_CONF_IPV4
{
#if UIP_USE_AUTOIP
int hwsum = mac_address[0] + mac_address[1] + mac_address[2]
+ mac_address[3] + mac_address[4] + mac_address[5];
autoip_init(hwsum + (hwsum << 16) + (hwsum << 24));
#endif
#if UIP_USE_DHCP
dhcpc_init(uip_lladdr.addr, 6);
#endif
}
#endif /* UIP_CONF_IPV4 */
xtcpd_init(xtcp, num_xtcp);
}
int main(void)
{
network_init();
#if MY_DEBUG
uartInit();
uartSetBaudRate(9600);
rprintfInit(uartSendByte);
#endif
int i;
uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
clock_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
uip_init();
struct uip_eth_addr mac = {UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5};
uip_setethaddr(mac);
telnetd_init();
#ifdef __DHCPC_H__
dhcpc_init(&mac, 6);
#else
uip_ipaddr(ipaddr, 192,168,0,1);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,168,0,1);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
#endif /*__DHCPC_H__*/
while(1){
uip_len = network_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)){
uip_arp_ipin();
uip_input();
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}else if(BUF->type == htons(UIP_ETHTYPE_ARP)){
uip_arp_arpin();
if(uip_len > 0){
network_send();
}
}
}else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
}
void udp_apps_init(void)
{
#ifdef UIP_DHCP
dhcpc_init( my_eth_addr.addr, UIP_LLADDR_LEN);
#endif // UIP_DHCP
}
/*----------------------------------------------------------------------------*/
int
main(void)
{
int i;
// Renesas -- uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
struct uip_eth_addr my_mac;
uint32_t ch = 0;
// Renesas ++
InitialiseLCD();
DisplayuIPDemo();
timer_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
Exosite_Get_MAC((unsigned char *)&my_mac);
// Renesas -- network_device_init();
/* Wait until Ether device initailize succesfully.
Make sure Ethernet cable is plugged in. */
while (R_ETHER_ERROR == R_Ether_Open(ch, (uint8_t*)&my_mac));
// Renesas ++ set Ethernet address
uip_setethaddr(my_mac);
uip_init();
// Renesas --
//uip_ipaddr(ipaddr, 192,168,0,2);
//uip_sethostaddr(ipaddr);
dhcpc_init(&my_mac, 6);
if (!Exosite_Init(APP_NAME, APP_VERSION)) DisplayLCD(LCD_LINE8, "==NEED CIK==");
while (1)
{
// Renesas -- uip_len = network_device_read();
uip_len = R_Ether_Read(ch, (void *)uip_buf);
if (uip_len > 0)
{
if (BUF->type == htons(UIP_ETHTYPE_IP))
{
uip_arp_ipin();
uip_input();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if (uip_len > 0)
{
uip_arp_out();
// Renesas -- network_device_send();
R_Ether_Write(ch, (void *)uip_buf, (uint32_t)uip_len);
}
}
else if (BUF->type == htons(UIP_ETHTYPE_ARP))
{
uip_arp_arpin();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if (uip_len > 0)
{
// Renesas -- network_device_send();
R_Ether_Write(ch, (void *)uip_buf, (uint32_t)uip_len);
}
}
}
else if (timer_expired(&periodic_timer))
{
timer_reset(&periodic_timer);
for (i = 0; i < UIP_CONNS; i++)
{
uip_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if (uip_len > 0)
{
uip_arp_out();
// Renesas -- network_device_send();
R_Ether_Write(ch, (void *)uip_buf, (uint32_t)uip_len);
}
}
#if UIP_UDP
for (i = 0; i < UIP_UDP_CONNS; i++)
{
uip_udp_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if (uip_len > 0)
{
uip_arp_out();
// Renesas -- network_device_send();
R_Ether_Write(ch, (void *)uip_buf, (uint32_t)uip_len);
}
}
#endif /* UIP_UDP */
/* Call the ARP timer function every 10 seconds. */
if (timer_expired(&arp_timer))
{
timer_reset(&arp_timer);
uip_arp_timer();
}
}
// Insert user aplications here.
// Call WEB application that controls LEDs on the target board.
user_app();
}
return 0;
}
/*! \brief Executa a aplicação que controla a conexão de rede */
void appCall(void)
{
//Se conexão foi abortada envia reset e reboot do pc
if(uip_aborted())
{
reboot = 1;
connected = 0;
dataSent = 0;
}
//Verifica se houve algum problema na conexão
if(uip_timedout())
{
//Flag que indica erro na conexão
connected = 0;
//lcdPutString("D",1,15);
dataSent = 0;
enc28j60_init();
//appSendConnect();
if(memoryData.ipTipo == '0')
{
//Inicia o DHCP
ethaddr.addr[0] = ENC28J60_MAC0;
ethaddr.addr[1] = ENC28J60_MAC1;
ethaddr.addr[2] = MAC_CONC[0];
ethaddr.addr[3] = MAC_CONC[1];
ethaddr.addr[4] = MAC_CONC[2];
ethaddr.addr[5] = MAC_CONC[3];
uip_setethaddr(ethaddr);
dhcpc_init(ðaddr, sizeof(ethaddr));
}
else
{
u16_t dns[2];
//Inicia com ip fixo
appInitHostIp();
dns[0] = memoryData.dnsAddr[0];
dns[1] = memoryData.dnsAddr[1];
appSetDnsAddr(dns);
appSendConnect();
}
}
if(uip_closed())
{
WDTCTL = 0;
}
//Caso a conexão com o servidor acabou de ocorrer
if(uip_connected())
{
connected = 1;
//lcdPutString("C",1,15);
dataSent = 0;
}
//Recebe os dados enviados pelo servidor
if(uip_newdata() && connected)
{
rcvSensorData(uip_appdata,uip_len);
}
if(connected && (uip_acked()) && dataSent && (!repetAck))
{
dataSent = 0;
//Diz que valor dos sensores já foi enviado
sensorClear();
}
if(uip_rexmit() && connected && (uip_len == 0))
{
//Evita travamento da interface de rede
enc28j60_init();
//Envia os dados do sensor no caso de retransmissão
sendSensorData();
return;
}
//Transmite dados para o servidor
if(uip_poll() && connected && (uip_len==0))
{
//Envia os dados dos sensores caso seja modo síncrono
if(memoryData.tempoPacote != 0)
{
if(ciclos >= 1)
{
if(countBaud >= (ciclos -1))
{
countBaud = 0;
sendSensorData();
dataSent = 1;
}
else
{
countBaud++;
}
}
}
}
}
void main(void) {
static struct uip_eth_addr eth_addr;
uip_ipaddr_t ipaddr;
cpu_init();
uart_init();
printf("Welcome\n");
spi_init();
enc28j60_comm_init();
printf("Welcome\n");
enc_init(mac_addr);
//
// Configure SysTick for a periodic interrupt.
//
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / SYSTICKHZ);
MAP_SysTickEnable();
MAP_SysTickIntEnable();
//MAP_IntEnable(INT_GPIOA);
MAP_IntEnable(INT_GPIOE);
MAP_IntMasterEnable();
MAP_SysCtlPeripheralClockGating(false);
printf("int enabled\n");
MAP_GPIOIntTypeSet(GPIO_PORTE_BASE, ENC_INT, GPIO_FALLING_EDGE);
MAP_GPIOPinIntClear(GPIO_PORTE_BASE, ENC_INT);
MAP_GPIOPinIntEnable(GPIO_PORTE_BASE, ENC_INT);
uip_init();
eth_addr.addr[0] = mac_addr[0];
eth_addr.addr[1] = mac_addr[1];
eth_addr.addr[2] = mac_addr[2];
eth_addr.addr[3] = mac_addr[3];
eth_addr.addr[4] = mac_addr[4];
eth_addr.addr[5] = mac_addr[5];
uip_setethaddr(eth_addr);
#define DEFAULT_IPADDR0 10
#define DEFAULT_IPADDR1 0
#define DEFAULT_IPADDR2 0
#define DEFAULT_IPADDR3 201
#define DEFAULT_NETMASK0 255
#define DEFAULT_NETMASK1 255
#define DEFAULT_NETMASK2 255
#define DEFAULT_NETMASK3 0
#undef STATIC_IP
#ifdef STATIC_IP
uip_ipaddr(ipaddr, DEFAULT_IPADDR0, DEFAULT_IPADDR1, DEFAULT_IPADDR2,
DEFAULT_IPADDR3);
uip_sethostaddr(ipaddr);
printf("IP: %d.%d.%d.%d\n", DEFAULT_IPADDR0, DEFAULT_IPADDR1,
DEFAULT_IPADDR2, DEFAULT_IPADDR3);
uip_ipaddr(ipaddr, DEFAULT_NETMASK0, DEFAULT_NETMASK1, DEFAULT_NETMASK2,
DEFAULT_NETMASK3);
uip_setnetmask(ipaddr);
#else
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_sethostaddr(ipaddr);
printf("Waiting for IP address...\n");
uip_ipaddr(ipaddr, 0, 0, 0, 0);
uip_setnetmask(ipaddr);
#endif
httpd_init();
#ifndef STATIC_IP
dhcpc_init(mac_addr, 6);
dhcpc_request();
#endif
long lPeriodicTimer, lARPTimer;
lPeriodicTimer = lARPTimer = 0;
int i; // = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
while(true) {
//MAP_IntDisable(INT_UART0);
MAP_SysCtlSleep();
//MAP_IntEnable(INT_UART0);
//i = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
/*while(i != 0 && g_ulFlags == 0) {
i = MAP_GPIOPinRead(GPIO_PORTA_BASE, ENC_INT) & ENC_INT;
}*/
if( HWREGBITW(&g_ulFlags, FLAG_ENC_INT) == 1 ) {
HWREGBITW(&g_ulFlags, FLAG_ENC_INT) = 0;
enc_action();
}
if(HWREGBITW(&g_ulFlags, FLAG_SYSTICK) == 1) {
HWREGBITW(&g_ulFlags, FLAG_SYSTICK) = 0;
lPeriodicTimer += SYSTICKMS;
lARPTimer += SYSTICKMS;
//printf("%d %d\n", lPeriodicTimer, lARPTimer);
}
if( lPeriodicTimer > UIP_PERIODIC_TIMER_MS ) {
lPeriodicTimer = 0;
int l;
for(l = 0; l < UIP_CONNS; l++) {
uip_periodic(l);
//
// If the above function invocation resulted in data that
// should be sent out on the network, the global variable
// uip_len is set to a value > 0.
//
if(uip_len > 0) {
uip_arp_out();
enc_send_packet(uip_buf, uip_len);
uip_len = 0;
}
}
for(l = 0; l < UIP_UDP_CONNS; l++) {
uip_udp_periodic(l);
if( uip_len > 0) {
uip_arp_out();
enc_send_packet(uip_buf, uip_len);
uip_len = 0;
}
}
}
if( lARPTimer > UIP_ARP_TIMER_MS) {
lARPTimer = 0;
uip_arp_timer();
}
}
}
/////////////////////////////////////////////////////////////////////////////
// The uIP Task is executed each mS
/////////////////////////////////////////////////////////////////////////////
static void UIP_TASK_Handler(void *pvParameters)
{
int i;
struct timer periodic_timer, arp_timer;
// Initialise the xLastExecutionTime variable on task entry
portTickType xLastExecutionTime = xTaskGetTickCount();
// take over exclusive access to UIP functions
MUTEX_UIP_TAKE;
// init uIP timers
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
// init the network driver
network_device_init();
// init uIP
uip_init();
uip_arp_init();
// set my ethernet address
unsigned char *mac_addr = network_device_mac_addr();
{
int i;
for(i=0; i<6; ++i)
uip_ethaddr.addr[i] = mac_addr[i];
}
#ifndef DONT_USE_DHCP
dhcpc_init(uip_ethaddr.addr, sizeof(uip_ethaddr.addr));
MIOS32_MIDI_SendDebugMessage("[UIP_TASK] DHCP Client requests the IP settings...\n");
#else
uip_ipaddr_t ipaddr;
// set my IP address
uip_ipaddr(ipaddr,
((MY_IP_ADDRESS)>>24) & 0xff,
((MY_IP_ADDRESS)>>16) & 0xff,
((MY_IP_ADDRESS)>> 8) & 0xff,
((MY_IP_ADDRESS)>> 0) & 0xff);
uip_sethostaddr(ipaddr);
// set my netmask
uip_ipaddr(ipaddr,
((MY_NETMASK)>>24) & 0xff,
((MY_NETMASK)>>16) & 0xff,
((MY_NETMASK)>> 8) & 0xff,
((MY_NETMASK)>> 0) & 0xff);
uip_setnetmask(ipaddr);
// default router
uip_ipaddr(ipaddr,
((MY_GATEWAY)>>24) & 0xff,
((MY_GATEWAY)>>16) & 0xff,
((MY_GATEWAY)>> 8) & 0xff,
((MY_GATEWAY)>> 0) & 0xff);
uip_setdraddr(ipaddr);
MIOS32_MIDI_SendDebugMessage("[UIP_TASK] IP Address statically set:\n");
// start services immediately
UIP_TASK_StartServices();
#endif
// release exclusive access to UIP functions
MUTEX_UIP_GIVE;
// endless loop
while( 1 ) {
vTaskDelayUntil(&xLastExecutionTime, 1 / portTICK_RATE_MS);
// take over exclusive access to UIP functions
MUTEX_UIP_TAKE;
if( !(clock_time_tick() % 100) ) {
// each 100 mS: check availablility of network device
network_device_check();
}
if( network_device_available() ) {
uip_len = network_device_read();
if( uip_len > 0 ) {
if(BUF->type == htons(UIP_ETHTYPE_IP) ) {
uip_arp_ipin();
uip_input();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if( uip_len > 0 ) {
uip_arp_out();
network_device_send();
}
} else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
uip_arp_arpin();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
network_device_send();
}
}
} else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
network_device_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
network_device_send();
}
}
#endif /* UIP_UDP */
/* Call the ARP timer function every 10 seconds. */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
// release exclusive access to UIP functions
MUTEX_UIP_GIVE;
}
}
int main(void)
{
network_init();
// network.c
// enc28j60Init();
// enc28j60PhyWrite(PHLCON,0x476);
//CLKPR = (1<<CLKPCE); //Change prescaler
//CLKPR = (1<<CLKPS0); //Use prescaler 2
//clock_prescale_set(clock_div_2);
enc28j60Write(ECOCON, 1 & 0x7);
// enc28j60.c
//Get a 25MHz signal from enc28j60
#ifdef MY_DEBUG
uartInit();
uartSetBaudRate(9600);
rprintfInit(uartSendByte);
#endif
int i;
uip_ipaddr_t ipaddr; // uip.h
// typedef u16_t uip_ip4addr_t[2];
// typedef uip_ip4addr_t uip_ipaddr_t;
struct timer periodic_timer, arp_timer;
clock_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
uip_init();
// uip.c
//uip_arp_init();
// uip_arp.c
// must be done or sometimes arp doesn't work
struct uip_eth_addr mac = {UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5};
uip_setethaddr(mac);
simple_httpd_init();
#ifdef __DHCPC_H__
dhcpc_init(&mac, 6);
#else
uip_ipaddr(ipaddr, 192,168,0,1); // uip.h
uip_sethostaddr(ipaddr); // uip.h
// #define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))
uip_ipaddr(ipaddr, 192,168,0,1);
uip_setdraddr(ipaddr);
// #define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
// #define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))
#endif /*__DHCPC_H__*/
while(1){
uip_len = network_read();
// uip.c : u16_t uip_len;
// network.c : return ((unt16_t) enc28j60PacketReceive(UIP_BUFSIZE, (uint8_t *)uip_buf));
// enc28j60.c : enc28j60PacketReceive
// uip.c : uint8_t uip_buf[UIP_BUFSIZE+2];
// uipconf.h : UIP_BUFSIZE:300
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)){
#ifdef MY_DEBUG
//rprintf("eth in : uip_len = %d, proto = %d\n", uip_len, uip_buf[23]);
//debugPrintHexTable(uip_len, uip_buf);
#endif
// struct uip_eth_hdr {
// struct uip_eth_addr dest;
// struct uip_eth_addr src;
// u16_t type;
// };
// struct uip_eth_addr { // Representation of a 48-bit Ethernet address
// u8_t addr[6];
// };
// http://www.netmanias.com/ko/post/blog/5372/ethernet-ip-tcp-ip/packet-header-ethernet-ip-tcp-ip
// UIP_ETHTYPE_IP(0x0800) : IPv4 Packet(ICMP, TCP, UDP)
uip_arp_ipin();
#ifdef MY_DEBUG
//rprintf("ip in : uip_len = %d, proto = %d\n", uip_len, uip_buf[23]);
//debugPrintHexTable(uip_len, uip_buf+14);
#endif
// uip_arp.c
// #define IPBUF ((struct ethip_hdr *)&uip_buf[0])
// struct ethip_hdr {
// struct uip_eth_hdr ethhdr;
// // IP header
// u8_t vhl,
// tos,
// len[2],
// ipid[2],
// ipoffset[2],
// ttl,
// proto; // ICMP: 1, TCP: 6, UDP: 17
// u16_t ipchksum;
// u16_t srcipaddr[2],
// destipaddr[2];
// }
// if ((IBUF->srcipaddr & uip_netmask) != uip_hostaddr & (uip_netmask)) return;
// uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
uip_input();
#ifdef MY_DEBUG
//rprintf("ip out : uip_len = %d, proto = %d\n", uip_len, uip_buf[23]);
//debugPrintHexTable(uip_len, uip_buf+14);
#endif
// ip out packet
// eg ICMP
// uip_len : 84
// source ip <-> destination ip
// type : 8 (Echo (ping) request) -> 0 (Echo (ping) reply)
// uip.h
// #define uip_input() uip_process(UIP_DATA) // UIP_DATA(1) : Tells uIP that there is incoming
// uip_process : The actual uIP function which does all the work.
if(uip_len > 0) {
uip_arp_out();
#ifdef MY_DEBUG
//rprintf("ip out : uip_len = %d, proto = %d\n", uip_len, uip_buf[23]);
//debugPrintHexTable(uip_len, uip_buf);
#endif
// Destination MAC Address <=> Source MAC Address
// w/o Ethernet CRC
// uip_arp.c
network_send();
// network.c
// if(uip_len <= UIP_LLH_LEN + 40){ // UIP_LLH_LEN : 14
// enc28j60PacketSend(uip_len, (uint8_t *)uip_buf, 0, 0);
// }else{
// enc28j60PacketSend(54, (uint8_t *)uip_buf , uip_len - UIP_LLH_LEN - 40, (uint8_t*)uip_appdata);
// }
}
}else if(BUF->type == htons(UIP_ETHTYPE_ARP)){
// UIP_ETHYPE_ARP(0x0806)
#ifdef MY_DEBUG
//rprintf("arp in : uip_len = %d\n", uip_len);
//debugPrintHexTable(uip_len, uip_buf);
#endif
// arp in : 64 bytes
uip_arp_arpin();
if(uip_len > 0){ // always uip_len > 0
#ifdef MY_DEBUG
//rprintf("ip in : uip_len = %d\n", uip_len);
//debugPrintHexTable(uip_len, uip_buf);
#endif
// arp out : 42 bytes
// 64 - Ethernet_padding(18) - Ethernet_CRC(4)
// Send MAC address <--> Target MAC address
// Send IP address <--> Target IP address
// uip_arp.c
network_send();
}
}
}else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
// uip.h
// #define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
// uip_process(UIP_UDP_TIMER); } while (0) // UIP_UDP_TIMER : 5
// uip.c; uip_process
// if(flag == UIP_UDP_TIMER) {
// if(uip_udp_conn->lport != 0) {
// uip_conn = NULL;
// uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
// uip_len = uip_slen = 0;
// uip_flags = UIP_POLL;
// UIP_UDP_APPCALL();
// goto udp_send;
// }
// } else {
// goto drop;
// }
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
}
boolean NanodeUIP::start_dhcp(dhcp_status_fn *callback) {
dhcp_status_callback=callback;
return dhcpc_init(&uip_ethaddr, 6);
}
/*-----------------------------------------------------------------------------------*/
PROCESS_THREAD(dhcp_process, ev, data)
{
PROCESS_BEGIN();
ctk_window_new(&window, 29, 14, "DHCP client");
CTK_WIDGET_ADD(&window, &requestbutton);
CTK_WIDGET_ADD(&window, &statuslabel);
CTK_WIDGET_ADD(&window, &ipaddrlabel);
CTK_WIDGET_ADD(&window, &ipaddrtextentry);
CTK_WIDGET_ADD(&window, &netmasklabel);
CTK_WIDGET_ADD(&window, &netmasktextentry);
CTK_WIDGET_ADD(&window, &gatewaylabel);
CTK_WIDGET_ADD(&window, &gatewaytextentry);
#if WITH_DNS
CTK_WIDGET_ADD(&window, &dnsserverlabel);
CTK_WIDGET_ADD(&window, &dnsservertextentry);
#endif /* WITH_DNS */
CTK_WIDGET_ADD(&window, &savebutton);
CTK_WIDGET_ADD(&window, &cancelbutton);
CTK_WIDGET_FOCUS(&window, &requestbutton);
ctk_window_open(&window);
/* Allow resolver to set DNS server address. */
process_post(PROCESS_CURRENT(), PROCESS_EVENT_MSG, NULL);
dhcpc_init(uip_ethaddr.addr, sizeof(uip_ethaddr.addr));
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_MSG) {
makestrings();
ctk_window_redraw(&window);
} else if(ev == tcpip_event) {
dhcpc_appcall(ev, data);
} else if(ev == ctk_signal_button_activate) {
if(data == (process_data_t)&requestbutton) {
dhcpc_request();
set_statustext("Requesting...");
}
if(data == (process_data_t)&savebutton) {
apply_tcpipconfig();
app_quit();
}
if(data == (process_data_t)&cancelbutton) {
app_quit();
}
} else if(
#if CTK_CONF_WINDOWCLOSE
ev == ctk_signal_window_close ||
#endif
ev == PROCESS_EVENT_EXIT) {
app_quit();
}
}
PROCESS_END();
}
int main(void)
{
led_conf();
int i;
uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
WDTCSR |= _BV(_WD_CHANGE_BIT) | _BV(WDE);
WDTCSR = 0;
network_init();
clock_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
uip_init();
phys_init();
// must be done or sometimes arp doesn't work
uip_arp_init();
_enable_dhcp=eeprom_read_byte(&ee_enable_dhcp);
if ((_enable_dhcp != 1) && (_enable_dhcp != 0))
{ // if the setting is invalid, enable by default
_enable_dhcp = 1;
eeprom_write_byte(&ee_enable_dhcp,_enable_dhcp);
}
eeprom_read_block ((void *)_eth_addr, (const void *)&ee_eth_addr,6);
// if the mac address in eeprom looks good, use it.
if((_eth_addr[0] != 255) && (_eth_addr[0] != 0))
{
my_eth_addr.addr[0] = _eth_addr[0];
my_eth_addr.addr[1] = _eth_addr[1];
my_eth_addr.addr[2] = _eth_addr[2];
my_eth_addr.addr[3] = _eth_addr[3];
my_eth_addr.addr[4] = _eth_addr[4];
my_eth_addr.addr[5] = _eth_addr[5];
}
uip_setethaddr(my_eth_addr);
_enable_dhcp = 1;
if (_enable_dhcp)
{
#ifdef __DHCPC_H__
// setup the dhcp renew timer the make the first request
timer_set(&dhcp_timer, CLOCK_SECOND * 600);
dhcpc_init(&my_eth_addr, 6);
dhcpc_request();
#endif
}
else
{
eeprom_read_block ((void *)_ip_addr, (const void *)&ee_ip_addr,4);
eeprom_read_block ((void *)_net_mask,(const void *)&ee_net_mask,4);
eeprom_read_block ((void *)_gateway, (const void *)&ee_gateway,4);
// if the IP looks good in flash, use it
if ((_ip_addr[0] != 255) && (_ip_addr[0] != 0))
{
uip_ipaddr(ipaddr, _ip_addr[0], _ip_addr[1], _ip_addr[2], _ip_addr[3]);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, _gateway[0], _gateway[1], _gateway[2], _gateway[3]);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, _net_mask[0], _net_mask[1], _net_mask[2], _net_mask[3]);
uip_setnetmask(ipaddr);
}
else
{ // ip in flash didn't look good... use default
uip_ipaddr(ipaddr, UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, UIP_NETMASK0, UIP_NETMASK1, UIP_NETMASK2, UIP_NETMASK3);
uip_setnetmask(ipaddr);
}
}
jsoncmd_init();
while (1) {
uip_len = network_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP))
{
led_on(5);
uip_arp_ipin(); // arp seems to have issues w/o this
uip_input();
if(uip_len > 0)
{
uip_arp_out();
network_send();
}
}
else if(BUF->type == htons(UIP_ETHTYPE_ARP))
{
led_on(4);
uip_arp_arpin(); // this is correct
if(uip_len > 0)
{
network_send();
}
}
}
else if(timer_expired(&periodic_timer))
{
led_off(4);
led_off(5);
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++)
{
uip_periodic(i);
if(uip_len > 0)
{
uip_arp_out();
network_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++)
{
uip_udp_periodic(i);
if(uip_len > 0)
{
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if(timer_expired(&arp_timer))
{
timer_reset(&arp_timer);
uip_arp_timer();
}
}
else if (_enable_dhcp && timer_expired(&dhcp_timer))
{
#ifdef __DHCPC_H__
led_on(3);
// for now turn off the led when we start the dhcp process
dhcpc_renew();
timer_reset(&dhcp_timer);
#endif
}
}
return 0;
}
int main(int argc, char *argv[]) {
uip_ipaddr_t ipaddr;
int i;
struct timer periodic_timer, arp_timer;
if(connect_pci() < 0) return 1;
printf("Starting up stack!\n");
uip_init();
uip_ipaddr(ipaddr, 192,168,1,8);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,168,1,1);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
uip_setethaddr(rtl8139_mac);
resolv_init();
dhcpc_init(rtl8139_mac, 6);
// httpd_init();
resolv_query("grindars.org.ru");
printf("Stack started\n");
while(1) {
uip_len = rtl8139_poll();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)) {
uip_arp_ipin();
uip_input();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
rtl8139_transmit();
}
} else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
uip_arp_arpin();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
rtl8139_transmit();
}
}
} else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
rtl8139_transmit();
}
}
//#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
rtl8139_transmit();
}
}
//#endif /* UIP_UDP */
/* Call the ARP timer function every 10 seconds. */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
}
int main(void)
{
led_conf();
network_init();
CLKPR = (1<<CLKPCE); //Change prescaler
CLKPR = (1<<CLKPS0); //Use prescaler 2
//clock_prescale_set(2);
enc28j60Write(ECOCON, 1 & 0x7); //Get a 25MHz signal from enc28j60
int i;
uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
clock_init();
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
uip_init();
struct uip_eth_addr mac = {UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5};
uip_setethaddr(mac);
simple_httpd_init();
// httpd_init();
#ifdef __DHCPC_H__
dhcpc_init(&mac, 6);
#else
uip_ipaddr(ipaddr, 192,168,2,55);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,168,2,1);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
/* uip_ipaddr(ipaddr, 192,167,0,255);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,167,0,254);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,0,0);
uip_setnetmask(ipaddr);
*/
#endif /*__DHCPC_H__*/
while(1){
uip_len = network_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)){
uip_arp_ipin();
uip_input();
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}else if(BUF->type == htons(UIP_ETHTYPE_ARP)){
uip_arp_arpin();
if(uip_len > 0){
network_send();
}
}
}else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
led_blink();
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
if(uip_len > 0) {
uip_arp_out();
network_send();
}
}
#endif /* UIP_UDP */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
}
