/********************************************************************* * Function: void RebootTask(NET_CONFIG* pConfig) * * PreCondition: Stack is initialized() * * Input: pConfig - interface * * Output: None * * Side Effects: None * * Overview: Checks for incomming traffic on port 69. * Resets the PIC if a 'R' is received. * * Note: This module is primarily for use with the * Ethernet bootloader. By resetting, the Ethernet * bootloader can take control for a second and let * a firmware upgrade take place. ********************************************************************/ void RebootTask(NET_CONFIG* pConfig) { struct { uint8_t vMACAddress[6]; uint32_t dwIPAddress; uint16_t wChecksum; } BootloaderAddress; int netIx; netIx = _TCPIPStackNetIx(pConfig); if(MySocket[netIx] == INVALID_UDP_SOCKET) { MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,REBOOT_PORT,INVALID_UDP_PORT); if(MySocket[netIx] == INVALID_UDP_SOCKET) { return; } UDPSocketSetNet(MySocket[netIx], pConfig); } // Do nothing if no data is waiting if(!UDPIsGetReady(MySocket[netIx])) return; #if defined(REBOOT_SAME_SUBNET_ONLY) // Respond only to name requests sent to us from nodes on the same subnet if((remoteNode.IPAddr.Val & pConfig->MyMask.Val) != (pConfig->MyIPAddr.Val & pConfig->MyMask.Val)) { UDPDiscard(pConfig); return; } #endif // Get our MAC address, IP address, and compute a checksum of them memcpy((void*)&BootloaderAddress.vMACAddress[0], (void*)&pConfig->MyMACAddr.v[0], sizeof(pConfig->MyMACAddr)); BootloaderAddress.dwIPAddress = pConfig->MyIPAddr.Val; BootloaderAddress.wChecksum = CalcIPChecksum((uint8_t*)&BootloaderAddress, sizeof(BootloaderAddress) - sizeof(BootloaderAddress.wChecksum)); // To enter the bootloader, we reset the system SYS_OUT_MESSAGE("Bootloader Reset"); SYS_Reboot(); }
/********************************************************************* Function: bool SNMPSetVar(SNMP_ID var, SNMP_INDEX index, uint8_t ref, SNMP_VAL val) Summary: This routine Set the mib variable with the requested value. Description: This is a callback function called by module for the snmp SET request.User application must modify this function for the new variables address. Precondition: ProcessVariables() is called. Parameters: var - Variable id whose value is to be set ref - Variable reference used to transfer multi-byte data 0 if first byte is set otherwise nonzero value to indicate corresponding byte being set. val - Up to 4 byte data value. If var data type is uint8_t, variable value is in val->byte If var data type is uint16_t, variable value is in val->word If var data type is uint32_t, variable value is in val->dword. If var data type is IP_ADDRESS, COUNTER32, or GAUGE32, value is in val->dword If var data type is OCTET_STRING, ASCII_STRING value is in val->byte; multi-byte transfer will be performed to transfer remaining bytes of data. Return Values: true - if it is OK to set more byte(s). false - if otherwise. Remarks: This function may get called more than once depending on number of bytes in a specific set request for given variable. only dynamic read-write variables needs to be handled. ********************************************************************/ bool SNMPSetVar(SNMP_ID var, SNMP_INDEX index, uint8_t ref, SNMP_VAL val) { int lcdSize = 16*2+1; char message[lcdSize]; switch(var) { case LED_D5: LED2_IO = val.byte; return true; case LED_D6: LED1_IO = val.byte; return true; case TRAP_RECEIVER_IP: // Make sure that index is within our range. if ( index < trapInfo.Size ) { // This is just an update to an existing entry. trapInfo.table[index].IPAddress.Val = val.dword; return true; } else if ( index < (uint8_t)TRAP_TABLE_SIZE ) { // This is an addition to table. trapInfo.table[index].IPAddress.Val = val.dword; trapInfo.table[index].communityLen = 0; trapInfo.Size++; return true; } break; case TRAP_RECEIVER_ENABLED: // Make sure that index is within our range. if ( index < trapInfo.Size ) { // Value of '1' means Enabled". if ( val.byte == 1u ) trapInfo.table[index].Flags.bEnabled = 1; // Value of '0' means "Disabled. else if ( val.byte == 0u ) trapInfo.table[index].Flags.bEnabled = 0; else // This is unknown value. return false; return true; } // Given index is more than our current table size. // If it is within our range, treat it as an addition to table. else if ( index < (uint8_t)TRAP_TABLE_SIZE ) { // Treat this as an addition to table. trapInfo.Size++; trapInfo.table[index].communityLen = 0; } break; case TRAP_COMMUNITY: // Since this is a ASCII_STRING data type, SNMP will call with // SNMP_END_OF_VAR to indicate no more bytes. // Use this information to determine if we just added new row // or updated an existing one. if ( ref == SNMP_END_OF_VAR ) { // Index equal to table size means that we have new row. if ( index == trapInfo.Size ) trapInfo.Size++; // Length of string is one more than index. trapInfo.table[index].communityLen++; return true; } // Make sure that index is within our range. if ( index < trapInfo.Size ) { // Copy given value into local buffer. trapInfo.table[index].community[ref] = val.byte; // Keep track of length too. // This may not be NULL terminate string. trapInfo.table[index].communityLen = (uint8_t)ref; return true; } break; case LCD_DISPLAY: // Copy all bytes until all bytes are transferred if ( ref != SNMP_END_OF_VAR && ref+1 < lcdSize) { message[ref] = val.byte; message[ref+1] = 0; } else { SYS_OUT_MESSAGE(message); } return true; } return false; }
// // Main application entry point. // int main(void) { #if defined(APP_USE_IPERF) static uint8_t iperfOk = 0; #endif static SYS_TICK startTick = 0; static IP_ADDR dwLastIP[sizeof (TCPIP_HOSTS_CONFIGURATION) / sizeof (*TCPIP_HOSTS_CONFIGURATION)]; uint8_t i; // perform system initialization if(!SYS_Initialize()) { return 0; } SYS_CONSOLE_MESSAGE("\r\n\n\n --- Unified TCPIP Demo Starts! --- \r\n"); SYS_OUT_MESSAGE("TCPStack " TCPIP_STACK_VERSION " "" "); #if defined(TCPIP_STACK_USE_MPFS) || defined(TCPIP_STACK_USE_MPFS2) MPFSInit(); #endif // Initiates board setup process if button is depressed // on startup if(BUTTON0_IO == 0u) { #if defined(TCPIP_STACK_USE_STORAGE) && (defined(SPIFLASH_CS_TRIS) || defined(EEPROM_CS_TRIS)) // Invalidate the EEPROM contents if BUTTON0 is held down for more than 4 seconds SYS_TICK StartTime = SYS_TICK_Get(); LED_PUT(0x00); while(BUTTON0_IO == 0u) { if(SYS_TICK_Get() - StartTime > 4*SYS_TICK_TicksPerSecondGet()) { TCPIP_STORAGE_HANDLE hStorage; // just in case we execute this before the stack is initialized TCPIP_STORAGE_Init(0); hStorage = TCPIP_STORAGE_Open(0, false); // no refresh actually needed if(hStorage) { TCPIP_STORAGE_Erase(hStorage); SYS_CONSOLE_MESSAGE("\r\n\r\nBUTTON0 held for more than 4 seconds. Default settings restored.\r\n\r\n"); TCPIP_STORAGE_Close(hStorage); } else { SYS_ERROR(SYS_ERROR_WARN, "\r\n\r\nCould not restore the default settings!!!.\r\n\r\n"); } TCPIP_STORAGE_DeInit(0); LED_PUT(0x0F); // wait 4.5 seconds here then reset while((SYS_TICK_Get() - StartTime) <= (9*SYS_TICK_TicksPerSecondGet()/2)); LED_PUT(0x00); while(BUTTON0_IO == 0u); SYS_Reboot(); break; } } #endif // defined(TCPIP_STACK_USE_STORAGE) && (defined(SPIFLASH_CS_TRIS) || defined(EEPROM_CS_TRIS)) } // Initialize the TCPIP stack if(!TCPIP_STACK_Init(TCPIP_HOSTS_CONFIGURATION, sizeof(TCPIP_HOSTS_CONFIGURATION)/sizeof(*TCPIP_HOSTS_CONFIGURATION), TCPIP_STACK_MODULE_CONFIG_TBL, sizeof(TCPIP_STACK_MODULE_CONFIG_TBL)/sizeof(*TCPIP_STACK_MODULE_CONFIG_TBL) )) { return 0; } #if defined(TCPIP_STACK_USE_TELNET_SERVER) TelnetRegisterCallback(ProcessIO); #endif // defined(TCPIP_STACK_USE_TELNET_SERVER) #if defined (TCPIP_STACK_USE_IPV6) TCPIP_ICMPV6_RegisterCallback (ICMPv6Callback); #endif #if defined(TCPIP_STACK_USE_ICMP_CLIENT) || defined(TCPIP_STACK_USE_ICMP_SERVER) ICMPRegisterCallback (PingProcessIPv4); #endif #if defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) TCPIP_NET_HANDLE hWiFi = TCPIP_STACK_NetHandle("MRF24W"); if(hWiFi) { TCPIP_STACK_SetNotifyEvents(hWiFi, TCPIP_EV_RX_ALL|TCPIP_EV_TX_ALL|TCPIP_EV_RXTX_ERRORS); TCPIP_STACK_SetNotifyHandler(hWiFi, StackNotification, 0); } #endif // defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) #if defined(APP_USE_IPERF) IperfConsoleInit(); iperfOk = IperfAppInit(TCPIP_HOSTS_CONFIGURATION[0].interface); #endif // Now that all items are initialized, begin the co-operative // multitasking loop. This infinite loop will continuously // execute all stack-related tasks, as well as your own // application's functions. Custom functions should be added // at the end of this loop. // Note that this is a "co-operative mult-tasking" mechanism // where every task performs its tasks (whether all in one shot // or part of it) and returns so that other tasks can do their // job. // If a task needs very long time to do its job, it must be broken // down into smaller pieces so that other tasks can have CPU time. while(1) { // Blink LED0 (right most one) every second. if(SYS_TICK_Get() - startTick >= SYS_TICK_TicksPerSecondGet()/2ul) { startTick = SYS_TICK_Get(); LED0_IO ^= 1; } // This task performs normal stack task including checking // for incoming packet, type of packet and calling // appropriate stack entity to process it. TCPIP_STACK_Task(); // Process application specific tasks here. // For this demo app, this will include the Generic TCP // client and servers, and the SNMP, Ping, and SNMP Trap // demos. Following that, we will process any IO from // the inputs on the board itself. // Any custom modules or processing you need to do should // go here. #if defined(TCPIP_STACK_USE_GENERIC_TCP_CLIENT_EXAMPLE) GenericTCPClient(); #endif #if defined(TCPIP_STACK_USE_GENERIC_TCP_SERVER_EXAMPLE) GenericTCPServer(); #endif #if defined(TCPIP_STACK_USE_SMTP_CLIENT) SMTPDemo(); #endif #if defined(TCPIP_STACK_USE_ICMP_CLIENT) || defined (TCPIP_STACK_USE_ICMP_SERVER) || defined (TCPIP_STACK_USE_IPV6) // use ping on the default interface PingDemoTask(); #endif #if defined(TCPIP_STACK_USE_SNMP_SERVER) && !defined(SNMP_TRAP_DISABLED) //User should use one of the following SNMP demo // This routine demonstrates V1 or V2 trap formats with one variable binding. SNMPTrapDemo(); #if defined(SNMP_STACK_USE_V2_TRAP) || defined(SNMP_V1_V2_TRAP_WITH_SNMPV3) //This routine provides V2 format notifications with multiple (3) variable bindings //User should modify this routine to send v2 trap format notifications with the required varbinds. //SNMPV2TrapDemo(); #endif if(gSendTrapFlag) SNMPSendTrap(); #endif #if defined(TCPIP_STACK_USE_BERKELEY_API) BerkeleyTCPClientDemo(); BerkeleyTCPServerDemo(); BerkeleyUDPClientDemo(0); #endif #if defined(APP_USE_IPERF) IperfConsoleProcess(); if (iperfOk) IperfAppCall(); // Only running in case of init succeed IperfConsoleProcessEpilogue(); #endif // If the local IP address has changed (ex: due to DHCP lease change) // write the new IP address to the console display, UART, and Announce // service // We use the default interface for (i = 0; i < sizeof(TCPIP_HOSTS_CONFIGURATION)/sizeof(*TCPIP_HOSTS_CONFIGURATION); i++) { TCPIP_NET_HANDLE netH = TCPIP_STACK_NetHandle(TCPIP_HOSTS_CONFIGURATION[i].interface); if((uint32_t)dwLastIP[i].Val != TCPIP_STACK_NetAddress(netH)) { dwLastIP[i].Val = TCPIP_STACK_NetAddress(netH); SYS_CONSOLE_MESSAGE(TCPIP_HOSTS_CONFIGURATION[i].interface); SYS_CONSOLE_MESSAGE(" new IP Address: "); DisplayIPValue(dwLastIP[i]); SYS_CONSOLE_MESSAGE("\r\n"); } } #if defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) if(stackNotifyCnt) { stackNotifyCnt = 0; ProcessNotification(stackNotifyHandle); } #endif // defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) } }
// // Main application entry point. // int main(void) { #if defined(HOST_CM_TEST) DWORD t1 = 0; char st[80]; BOOL host_scan = FALSE; UINT16 scan_count = 0; #endif static IPV4_ADDR dwLastIP[sizeof (TCPIP_HOSTS_CONFIGURATION) / sizeof (*TCPIP_HOSTS_CONFIGURATION)]; int i, nNets; #if defined(SYS_USERIO_ENABLE) static SYS_TICK startTick = 0; int32_t LEDstate=SYS_USERIO_LED_DEASSERTED; #endif // defined(SYS_USERIO_ENABLE) TCPIP_NET_HANDLE netH; const char *netName=0; const char *netBiosName; #if defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) char mDNSServiceName[] = "MyWebServiceNameX "; // base name of the service Must not exceed 16 bytes long // the last digit will be incremented by interface #endif // defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) // perform system initialization if(!SYS_Initialize()) { return 0; } SYS_CONSOLE_MESSAGE("\r\n\n\n --- TCPIP Demo Starts! --- \r\n"); SYS_OUT_MESSAGE("TCPIPStack " TCPIP_STACK_VERSION " "" "); // Initialize the TCPIP stack if (!TCPIP_STACK_Init(TCPIP_HOSTS_CONFIGURATION, sizeof (TCPIP_HOSTS_CONFIGURATION) / sizeof (*TCPIP_HOSTS_CONFIGURATION), TCPIP_STACK_MODULE_CONFIG_TBL, sizeof (TCPIP_STACK_MODULE_CONFIG_TBL) / sizeof (*TCPIP_STACK_MODULE_CONFIG_TBL))) { return 0; } // Display the names associated with each interface // Perform mDNS registration if mDNS is enabled nNets = TCPIP_STACK_NetworksNo(); for(i = 0; i < nNets; i++) { netH = TCPIP_STACK_IxToNet(i); netName = TCPIP_STACK_NetName(netH); netBiosName = TCPIP_STACK_NetBIOSName(netH); #if defined(TCPIP_STACK_USE_NBNS) SYS_CONSOLE_PRINT(" Interface %s on host %s - NBNS enabled\r\n", netName, netBiosName); #else SYS_CONSOLE_PRINT(" Interface %s on host %s - NBNS disabled\r\n", netName, netBiosName); #endif // defined(TCPIP_STACK_USE_NBNS) #if defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) mDNSServiceName[sizeof(mDNSServiceName) - 2] = '1' + i; mDNSServiceRegister( netH , mDNSServiceName // name of the service ,"_http._tcp.local" // type of the service ,80 // TCP or UDP port, at which this service is available ,((const BYTE *)"path=/index.htm") // TXT info ,1 // auto rename the service when if needed ,NULL // no callback function ,NULL); // no application context #endif //TCPIP_STACK_USE_ZEROCONF_MDNS_SD } #if defined (TCPIP_STACK_USE_IPV6) TCPIP_ICMPV6_RegisterCallback(ICMPv6Callback); #endif #if defined(TCPIP_STACK_USE_ICMP_CLIENT) ICMPRegisterCallback(PingProcessIPv4); #endif #if defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) TCPIP_NET_HANDLE hWiFi = TCPIP_STACK_NetHandle("MRF24W"); if (hWiFi) { TCPIP_STACK_RegisterHandler(hWiFi, TCPIP_EV_RX_ALL | TCPIP_EV_TX_ALL | TCPIP_EV_RXTX_ERRORS, StackNotification, 0); } #endif // defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) #if defined(WF_UPDATE_FIRMWARE_UART_24G) extern bool WF_FirmwareUpdate_Uart_24G(void); WF_FirmwareUpdate_Uart_24G(); #endif // Now that all items are initialized, begin the co-operative // multitasking loop. This infinite loop will continuously // execute all stack-related tasks, as well as your own // application's functions. Custom functions should be added // at the end of this loop. // Note that this is a "co-operative mult-tasking" mechanism // where every task performs its tasks (whether all in one shot // or part of it) and returns so that other tasks can do their // job. // If a task needs very long time to do its job, it must be broken // down into smaller pieces so that other tasks can have CPU time. while (1) { SYS_Tasks(); #if defined(SYS_USERIO_ENABLE) // Blink LED0 (right most one) every second. if (SYS_TICK_Get() - startTick >= SYS_TICK_TicksPerSecondGet() / 2ul) { startTick = SYS_TICK_Get(); LEDstate ^= SYS_USERIO_LED_ASSERTED; SYS_USERIO_SetLED(SYS_USERIO_LED_0, LEDstate); } #endif // defined(SYS_USERIO_ENABLE) // This task performs normal stack task including checking // for incoming packet, type of packet and calling // appropriate stack entity to process it. TCPIP_STACK_Task(); // Process application specific tasks here. // For this demo app, this will include the Generic TCP // client and servers, and the SNMP, Ping, and SNMP Trap // demos. Following that, we will process any IO from // the inputs on the board itself. // Any custom modules or processing you need to do should // go here. #if defined(TCPIP_STACK_USE_TCP) && defined(APP_USE_FTP_CLIENT_DEMO) FTPClient(); #endif #if defined(TCPIP_STACK_USE_TCP) && defined(APP_USE_GENERIC_TCP_CLIENT_DEMO) GenericTCPClient(); #endif #if defined(TCPIP_STACK_USE_TCP) && defined(APP_USE_GENERIC_TCP_SERVER_DEMO) GenericTCPServer(); #endif #if defined(TCPIP_STACK_USE_SMTP_CLIENT) && defined(APP_USE_SMTP_CLIENT_DEMO) SMTPDemo(); #endif #if (defined(TCPIP_STACK_USE_ICMP_CLIENT) || defined (TCPIP_STACK_USE_IPV6)) && defined(APP_USE_PING_DEMO) // use ping on the default interface PingDemoTask(); #endif #if defined(TCPIP_STACK_USE_SNMP_SERVER) && !defined(SNMP_TRAP_DISABLED) // User should use one of the following SNMP demo // This routine demonstrates V1 or V2 trap formats with one variable binding. //SNMPTrapDemo(); //This function sends the both SNMP trap version1 and 2 type of notifications #if defined(SNMP_STACK_USE_V2_TRAP) || defined(SNMP_V1_V2_TRAP_WITH_SNMPV3) //This routine provides V2 format notifications with multiple (3) variable bindings //User should modify this routine to send v2 trap format notifications with the required varbinds. SNMPV2TrapDemo(); //This function sends the SNMP trap version 2 type of notifications #endif /* SNMPSendTrap() is used to send trap notification to previously configured ip address if trap notification is enabled. There are different trap notification code. The current implementation sends trap for authentication failure (4). PreCondition: If application defined event occurs to send the trap. Declare a notification flag and update as the event occurs. Uncomment the below function if the application requires. if(notification flag is updated by the application as a predefined event occured) { SNMPSendTrap(); } */ #endif #if defined(TCPIP_STACK_USE_BERKELEY_API) && defined(APP_USE_BERKELEY_API_DEMO) BerkeleyTCPClientDemo(); BerkeleyTCPServerDemo(); BerkeleyUDPClientDemo(0); #endif // If the local IP address has changed (ex: due to DHCP lease change) // write the new IP address to the console display, UART, and Announce // service // We use the default interface for (i = 0; i < sizeof (TCPIP_HOSTS_CONFIGURATION) / sizeof (*TCPIP_HOSTS_CONFIGURATION); i++) { netH = TCPIP_STACK_NetHandle(TCPIP_HOSTS_CONFIGURATION[i].interface); if ((uint32_t) dwLastIP[i].Val != TCPIP_STACK_NetAddress(netH)) { dwLastIP[i].Val = TCPIP_STACK_NetAddress(netH); SYS_CONSOLE_PRINT("Interface Name is: %s\r\n", TCPIP_HOSTS_CONFIGURATION[i].interface); SYS_CONSOLE_MESSAGE("New IP Address is: "); DisplayIPValue(dwLastIP[i]); SYS_CONSOLE_MESSAGE("\r\n"); } } #if defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) if (stackNotifyCnt) { stackNotifyCnt = 0; ProcessNotification(stackNotifyHandle); } #endif // defined(TCPIP_STACK_USE_EVENT_NOTIFICATION) #if defined(WF_UPDATE_FIRMWARE_TCPCLIENT_24G) void WF_FirmwareUpdate_TcpClient_24G(void); WF_FirmwareUpdate_TcpClient_24G(); #endif //defined(WF_UPDATE_FIRMWARE_TCPCLIENT_24G) #if defined(HOST_CM_TEST) switch (g_event) { case WF_EVENT_CONNECTION_PERMANENTLY_LOST: case WF_EVENT_CONNECTION_FAILED: g_event = 0xff; // clear current event // if host scan is active, it can be forced inactive by connection/re-connection process // so just reset host scan state to inactive. host_scan = FALSE; // host scan inactive SYS_CONSOLE_MESSAGE("Reconnecting....\r\n"); WF_Connect(); break; case WF_EVENT_CONNECTION_SUCCESSFUL: g_event = 0xff; // clear current event // if host scan is active, it can be forced inactive by connection/re-connection process // so just reset host scan state to inactive. host_scan = FALSE; // host scan inactive break; case WF_EVENT_SCAN_RESULTS_READY: g_event = 0xff; // clear current event host_scan = FALSE; // host scan inactive // Scan results are valid - OK to retrieve if (SCANCXT.numScanResults > 0) { SCAN_SET_DISPLAY(SCANCXT.scanState); SCANCXT.displayIdx = 0; while (IS_SCAN_STATE_DISPLAY(SCANCXT.scanState)) WFDisplayScanMgr(); } break; case WF_EVENT_CONNECTION_TEMPORARILY_LOST: // This event can happened when CM in module is enabled. g_event = 0xff; // clear current event // if host scan is active, it can be forced inactive by connection/re-connection process // so just reset host scan state to inactive. host_scan = FALSE; // host scan inactive break; default: //sprintf(st,"skip event = %d\r\n",g_event); //SYS_CONSOLE_MESSAGE(st); break; } if (g_DhcpSuccessful) { /* Send and Receive UDP packets */ if(UDPIsOpened(socket1)) { // UDP TX every 10 msec if(SYS_TICK_Get() - timeudp >= SYS_TICK_TicksPerSecondGet() / 100) { timeudp = SYS_TICK_Get(); tx_number++; LED0_IO ^= 1; sprintf(str,"rem=%12lu",tx_number); for(cntstr=16;cntstr<999;cntstr++) str[cntstr]=cntstr; str[999]=0; // Send tx_number (formatted in a string) if(UDPIsTxPutReady(socket1,1000)!=0) { UDPPutString(socket1,(BYTE *)str); UDPFlush(socket1); SYS_CONSOLE_MESSAGE("."); } } // UDP RX tx_number of remote board if(UDPIsGetReady(socket1)!=0) { LED1_IO ^= 1; UDPGetArray(socket1,(BYTE *)str,1000); str[16]=0; //sprintf((char*)LCDText,"%sloc=%12lu",str,tx_number); // Write on EXP16 LCD local and remote TX number //strcpypgm2ram(LCDText,str); //LCDUpdate(); SYS_CONSOLE_MESSAGE("Rx"); } } // Do host scan if((SYS_TICK_Get() - t1) >= SYS_TICK_TicksPerSecondGet() * 20) { t1 = SYS_TICK_Get(); if (!host_scan) // allow host scan if currently inactive { sprintf(st,"%d Scanning ..... event = %d\r\n",++scan_count, g_event); SYS_CONSOLE_MESSAGE(st); host_scan = TRUE; // host scan active WF_Scan(0xff); // scan on all channels } } } // DHCP status #endif //HOST_CM_TEST } }
// // Main application entry point. // int main(void) { static SYS_TICK startTick = 0; static IPV4_ADDR dwLastIP[2] = { {-1}, {-1} }; IPV4_ADDR ipAddr; SYS_USERIO_LED_STATE LEDstate = SYS_USERIO_LED_DEASSERTED; int i, nNets; TCPIP_NET_HANDLE netH; const char *netName, *netBiosName; #if defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) char mDNSServiceName[] = "MyWebServiceNameX "; // base name of the service Must not exceed 16 bytes long // the last digit will be incremented by interface #endif // defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) // perform system initialization SYS_Initialize(0); SYS_CONSOLE_MESSAGE("\r\n\n\n --- TCPIP Demo Starts! --- \r\n"); SYS_OUT_MESSAGE("TCPIPStack " TCPIP_STACK_VERSION " "" "); // Display the names associated with each interface nNets = TCPIP_STACK_NumberOfNetworksGet(); for(i = 0; i < nNets; i++) { netH = TCPIP_STACK_IndexToNet(i); netName = TCPIP_STACK_NetNameGet(netH); netBiosName = TCPIP_STACK_NetBIOSName(netH); #if defined(TCPIP_STACK_USE_NBNS) SYS_CONSOLE_PRINT(" Interface %s on host %s - NBNS enabled\r\n", netName, netBiosName); #else SYS_CONSOLE_PRINT(" Interface %s on host %s - NBNS disabled\r\n", netName, netBiosName); #endif // defined(TCPIP_STACK_USE_NBNS) #if defined (TCPIP_STACK_USE_ZEROCONF_MDNS_SD) mDNSServiceName[sizeof(mDNSServiceName) - 2] = '1' + i; TCPIP_MDNS_ServiceRegister( netH , mDNSServiceName // name of the service ,"_http._tcp.local" // type of the service ,80 // TCP or UDP port, at which this service is available ,((const uint8_t *)"path=/index.htm") // TXT info ,1 // auto rename the service when if needed ,NULL // no callback function ,NULL); // no application context #endif //TCPIP_STACK_USE_ZEROCONF_MDNS_SD } #if defined(WF_UPDATE_FIRMWARE_UART_24G) extern bool WF_FirmwareUpdate_Uart_24G(void); WF_FirmwareUpdate_Uart_24G(); #endif // Now that all items are initialized, begin the co-operative // multitasking loop. This infinite loop will continuously // execute all stack-related tasks, as well as your own // application's functions. Custom functions should be added // at the end of this loop. // Note that this is a "co-operative mult-tasking" mechanism // where every task performs its tasks (whether all in one shot // or part of it) and returns so that other tasks can do their // job. // If a task needs very long time to do its job, it must be broken // down into smaller pieces so that other tasks can have CPU time. while (1) { SYS_Tasks(); // Blink LED0 every second. if (SYS_TICK_Get() - startTick >= SYS_TICK_TicksPerSecondGet() / 2ul) { startTick = SYS_TICK_Get(); LEDstate ^= SYS_USERIO_LED_ASSERTED; SYS_USERIO_SetLED(SYS_USERIO_LED_0, LEDstate); } // if the IP address of an interface has changed // display the new value on the system console nNets = TCPIP_STACK_NumberOfNetworksGet(); for (i = 0; i < nNets; i++) { netH = TCPIP_STACK_IndexToNet(i); ipAddr.Val = TCPIP_STACK_NetAddress(netH); if(dwLastIP[i].Val != ipAddr.Val) { dwLastIP[i].Val = ipAddr.Val; SYS_CONSOLE_MESSAGE(TCPIP_STACK_NetNameGet(netH)); SYS_CONSOLE_MESSAGE(" IP Address: "); SYS_CONSOLE_PRINT("%d.%d.%d.%d \r\n", ipAddr.v[0], ipAddr.v[1], ipAddr.v[2], ipAddr.v[3]); } } #if (WF_DEFAULT_NETWORK_TYPE == WF_NETWORK_TYPE_SOFT_AP) if (g_scan_done) { if (g_prescan_waiting) { SYS_CONSOLE_MESSAGE((const char*)"\n SoftAP prescan results ........ \r\n\n"); SCANCXT.displayIdx = 0; extern void WFDisplayScanMgr(void); while (IS_SCAN_STATE_DISPLAY(SCANCXT.scanState)) { WFDisplayScanMgr(); } SYS_CONSOLE_MESSAGE((const char*)"\r\n "); #if defined(WF_CS_TRIS) Demo_Wifi_Connect(); #endif g_scan_done = 0; g_prescan_waiting = 0; } } #endif // (WF_DEFAULT_NETWORK_TYPE == WF_NETWORK_TYPE_SOFT_AP) #if defined(WF_UPDATE_FIRMWARE_UART_24G) WF_FirmwareUpdate_Uart_24G(); #endif #if defined(WF_UPDATE_FIRMWARE_TCPCLIENT_24G) WF_FirmwareUpdate_TcpClient_24G(); #endif } }
/******************************************************************************* Function: void SYS_Initialize ( void *data ) Summary: Initializes the board, services, drivers, application and other modules Description: This routine initializes the board, services, drivers, application and other modules as configured at build time. In a bare-metal environment (where no OS is supported), this routine should be called almost immediately after entering the "main" routine. Precondition: The C-language run-time environment and stack must have been initialized. Parameters: data - Pointer to the system initialzation data structure containing pointers to the board, system service, and driver initialization routines Returns: None. Example: <code> SYS_INT_Initialize(NULL); </code> Remarks: Basic System Initialization Sequence: 1. Initilize minimal board services and processor-specific items (enough to use the board to initialize drivers and services) 2. Initialize all supported system services 3. Initialize all supported modules (libraries, drivers, middleware, and application-level modules) 4. Initialize the main (static) application, if present. The order in which services and modules are initialized and started may be important. For a static system (a system not using the ISP's dynamic implementation of the initialization and "Tasks" services) this routine is implemented for the specific configuration of an application. */ void SYS_Initialize(void* data) { BSP_Initialize(); // cache configuration cache_enable(0); SetPic32MZIoPins(); /* Initializethe interrupt system */ SYS_INT_Initialize(); /* Remap the SPI pins */ PLIB_PORTS_RemapOutput(PORTS_ID_0, OTPUT_FUNC_SDO2, OUTPUT_PIN_RPG8); PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_SDI2, INPUT_PIN_RPD7); /* set priority for SPI interrupt source */ SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_TX, INT_PRIORITY_LEVEL3); SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_RX, INT_PRIORITY_LEVEL3); /* set sub-priority for SPI interrupt source */ SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_TX, INT_SUBPRIORITY_LEVEL1); SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_RX, INT_SUBPRIORITY_LEVEL1); clkObject.systemClock = 200000000L; //Turn ON the system clock if(!SYS_TICK_Initialize(clkObject.systemClock, SYS_TICKS_PER_SECOND)) { return; } SYS_INT_Enable(); /* Initialize the clock system service. This is used * by the SPI Driver. */ clkObject.MZperipheralClock[2] = 100000000L; clkObject.peripheralClock = 100000000L; /* Initialize the SPI driver */ appDrvObjects.drvSPIObject = DRV_SPI_Initialize(DRV_SPI_INDEX_0, (SYS_MODULE_INIT *)&drvSPIInit); /* Initialize the SDCARD driver*/ appDrvObjects.drvSDCARDObject = DRV_SDCARD_Initialize(DRV_SDCARD_INDEX_0, (SYS_MODULE_INIT *)&drvSDCARDInit); /* Initialize the SYS_FS Layer */ SYS_FS_Initialize( (const void *) sysFATFSInit ); if(!_SYS_DEBUG_INIT(SYS_DEBUG_PORT)) { return; } if(!_SYS_CONSOLE_INIT(SYS_CONSOLE_PORT)) { return; } if(!_SYS_RANDOM_INIT()) { return; } if (!_SYS_COMMAND_INIT()) { return; } if (!SYS_USERIO_Initialize(0)) { return; } // TCP/IP stack initialization SYS_OUT_MESSAGE("TCPStack " TCPIP_STACK_VERSION " "" "); // Initialize the TCPIP stack if (!TCPIP_STACK_Init()) { return; } APP_Initialize(); return; } //SYS_Initialize