Hi,
My goal is to receive data from the GPIO ports continuously, store it in dual buffers and feed this out the ethernet port continuously. I was hoping to use the enet-lwip example as a starting point but this does leave me with many questions and a steep learning curve. partially because the examples are generally web servers. Firstly I understand LWIP is driven by callback functions. One of which is declared as err_t (* accept) (void * arg, struct tcp_pcb *newpcb, err_t) It is not well documented what one is meant to do in these callback function although I have scoured the web and plagarised heavily as in the attached code. Secondly where do you write the code when it is meant to called by the ethernet interrupt. I placed my initial trial code in the lwIPHostTimerHandler as the code was jumping to there after the call to lwIPInit() however that is obviously not the spot to place it eventually if I am to achieve my aim. Thirdly my current problem aside from these issues is that I can establish a connection to a client that a colleague wrote for me however I cannot seem to send anything. Some help and guidance at this early stage would be much appreciated. Regards, Lee.
//***************************************************************************** // // enet_lwip.c - Sample WebServer Application using lwIP. // // Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. // Software License Agreement // // Texas Instruments (TI) is supplying this software for use solely and // exclusively on TI's microcontroller products. The software is owned by // TI and/or its suppliers, and is protected under applicable copyright // laws. You may not combine this software with "viral" open-source // software in order to form a larger program. // // THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. // NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT // NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY // CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL // DAMAGES, FOR ANY REASON WHATSOEVER. // // This is part of revision 2.1.0.12573 of the EK-TM4C1294XL Firmware Package. // //***************************************************************************** #include <stdbool.h> #include <stdint.h> //#include "data.h" #include "inc/hw_ints.h" #include "inc/hw_memmap.h" #include "driverlib/flash.h" #include "driverlib/interrupt.h" #include "driverlib/gpio.h" #include "driverlib/rom_map.h" #include "driverlib/sysctl.h" #include "driverlib/systick.h" #include "utils/locator.h" #include "utils/lwiplib.h" #include "utils/ustdlib.h" #include "utils/uartstdio.h" //#include "httpserver_raw/httpd.h" #include "drivers/pinout.h" //***************************************************************************** // //! \addtogroup example_list //! <h1>Ethernet with lwIP (enet_lwip)</h1> //! //! This example application demonstrates the operation of the Tiva //! Ethernet controller using the lwIP TCP/IP Stack. DHCP is used to obtain //! an Ethernet address. If DHCP times out without obtaining an address, //! AutoIP will be used to obtain a link-local address. The address that is //! selected will be shown on the UART. //! //! UART0, connected to the ICDI virtual COM port and running at 115,200, //! 8-N-1, is used to display messages from this application. Use the //! following command to re-build the any file system files that change. //! //! ../../../../tools/bin/makefsfile -i fs -o enet_fsdata.h -r -h -q //! //! For additional details on lwIP, refer to the lwIP web page at: //! http://savannah.nongnu.org/projects/lwip/ // //***************************************************************************** //***************************************************************************** // // Defines for setting up the system clock. // //***************************************************************************** #define SYSTICKHZ 100 #define SYSTICKMS (1000 / SYSTICKHZ) //***************************************************************************** // // Interrupt priority definitions. The top 3 bits of these values are // significant with lower values indicating higher priority interrupts. // //***************************************************************************** #define SYSTICK_INT_PRIORITY 0x80 #define ETHERNET_INT_PRIORITY 0xC0 const char *helloworld = "hello world\n"; struct tcp_pcb *test_pcb, *lpcb; err_t err, write_err,output_err; uint8_t dataBuffer[10] = {1,2,3,4,5,6,7,8,9,10}; u8_t *state; //***************************************************************************** // // The current IP address. // //***************************************************************************** uint32_t g_ui32IPAddress; //***************************************************************************** // // The system clock frequency. // //***************************************************************************** uint32_t g_ui32SysClock; //***************************************************************************** // // The error routine that is called if the driver library encounters an error. // //***************************************************************************** #ifdef DEBUG void __error__(char *pcFilename, uint32_t ui32Line) { } #endif //***************************************************************************** // // Display an lwIP type IP Address. // //***************************************************************************** void DisplayIPAddress(uint32_t ui32Addr) { char pcBuf[16]; // // Convert the IP Address into a string. // usprintf(pcBuf, "%d.%d.%d.%d", ui32Addr & 0xff, (ui32Addr >> 8) & 0xff, (ui32Addr >> 16) & 0xff, (ui32Addr >> 24) & 0xff); // // Display the string. // UARTprintf(pcBuf); } //***************************************************************************** // // Required by lwIP library to support any host-related timer functions. // //***************************************************************************** void test_end(struct tcp_pcb *pcb, u8_t *state) { tcp_err(pcb, NULL); tcp_recv(pcb, NULL); tcp_sent(pcb, NULL); tcp_poll(pcb, NULL, 0); mem_free(state); } //**************************************************************************** // // //**************************************************************************** void test_err(void *arg, err_t err) { mem_free(arg); } //*************************************************************************** // // //*************************************************************************** err_t hello_poll_close(void *arg, struct tcp_pcb *pcb) { u8_t *state = (u8_t *)arg; if (tcp_close(pcb) == ERR_OK) { if ((*state & 2) == 2) /* close received */ test_end(pcb, state); else /* close not yet received */ *state = 255; } return ERR_OK; } //**************************************************************************** // // //**************************************************************************** err_t test_connected(void *arg, struct tcp_pcb *pcb, err_t err) { tcp_write(pcb, helloworld, 12, 0); return ERR_OK; } // //**************************************************************************** err_t test_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) { u8_t *state = (u8_t *)arg; u16_t len; if (p == NULL) if (*state == 255) /* close send */ test_end(pcb, state); else /* close not yet send */ *state |= 2; else { len = p->tot_len; pbuf_free(p); tcp_recved(pcb,len); } return ERR_OK; } //***************************************************************************** static err_t test_accept(void *arg, struct tcp_pcb *pcb, err_t err){ LWIP_UNUSED_ARG(arg); LWIP_UNUSED_ARG(err); tcp_setprio(test_pcb, TCP_PRIO_MIN); tcp_recv(test_pcb, test_recv); tcp_err(test_pcb, NULL); //Don't care about error here tcp_poll(test_pcb, NULL, 4); //No polling here tcp_accepted(test_pcb); return ERR_OK; } //***************************************************************************** // // Required by lwIP library to support any host-related timer functions. // //***************************************************************************** void lwIPHostTimerHandler(void) { uint32_t ui32Idx, ui32NewIPAddress; // // Get the current IP address. // ui32NewIPAddress = lwIPLocalIPAddrGet(); // // See if the IP address has changed. // if(ui32NewIPAddress != g_ui32IPAddress) { // // See if there is an IP address assigned. // if(ui32NewIPAddress == 0xffffffff) { // // Indicate that there is no link. // UARTprintf("Waiting for link.\n"); } else if(ui32NewIPAddress == 0) { // // There is no IP address, so indicate that the DHCP process is // running. // UARTprintf("Waiting for IP address.\n"); } else { // // Display the new IP address. // UARTprintf("IP Address: "); DisplayIPAddress(ui32NewIPAddress); //UARTprintf("\nOpen a browser and enter the IP address.\n"); test_pcb = tcp_new(); if(test_pcb != NULL) { if (tcp_bind(test_pcb, IP_ADDR_ANY, 1234) != ERR_OK) { tcp_abort(test_pcb); UARTprintf("\nCannot bind pcb\n"); } if ((lpcb = tcp_listen(test_pcb)) == NULL) { tcp_abort(test_pcb); UARTprintf("\nCannot listen\n"); } tcp_arg(lpcb, NULL); tcp_setprio(lpcb, TCP_PRIO_NORMAL); tcp_accept(lpcb, test_accept); tcp_write(lpcb,dataBuffer,10,0);// try to send data tcp_output(lpcb);// try to send data } else { UARTprintf("\nCannot create pcb\n"); } } // // Save the new IP address. // g_ui32IPAddress = ui32NewIPAddress; // // Turn GPIO off. // MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1); } // // If there is not an IP address. // if((ui32NewIPAddress == 0) || (ui32NewIPAddress == 0xffffffff)) { // // Loop through the LED animation. // for(ui32Idx = 1; ui32Idx < 17; ui32Idx++) { // // Toggle the GPIO // MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, (MAP_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_1) ^ GPIO_PIN_1)); SysCtlDelay(g_ui32SysClock/(ui32Idx << 1)); } } } //***************************************************************************** // // The interrupt handler for the SysTick interrupt. // //***************************************************************************** void SysTickIntHandler(void) { // // Call the lwIP timer handler. // lwIPTimer(SYSTICKMS); } //***************************************************************************** // // //***************************************************************************** // // This example demonstrates the use of the Ethernet Controller. // //***************************************************************************** int main(void) { uint32_t ui32User0, ui32User1; uint8_t pui8MACArray[8]; // // Make sure the main oscillator is enabled because this is required by // the PHY. The system must have a 25MHz crystal attached to the OSC // pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal // frequency is 10MHz or higher. // SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ); // // Run from the PLL at 120 MHz. // g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // // Configure the device pins. // PinoutSet(true, false); // // Configure UART. // UARTStdioConfig(0, 115200, g_ui32SysClock); // // Clear the terminal and print banner. // UARTprintf("\033[2J\033[H"); UARTprintf("Ethernet lwIP example\n\n"); // // Configure Port N1 for as an output for the animation LED. // MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1); // // Initialize LED to OFF (0) // MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1); // // Configure SysTick for a periodic interrupt. // MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ); MAP_SysTickEnable(); MAP_SysTickIntEnable(); // // Configure the hardware MAC address for Ethernet Controller filtering of // incoming packets. The MAC address will be stored in the non-volatile // USER0 and USER1 registers. // MAP_FlashUserGet(&ui32User0, &ui32User1); if((ui32User0 == 0xffffffff) || (ui32User1 == 0xffffffff)) { // // We should never get here. This is an error if the MAC address has // not been programmed into the device. Exit the program. // Let the user know there is no MAC address // UARTprintf("No MAC programmed!\n"); while(1) { } } // // Tell the user what we are doing just now. // UARTprintf("Waiting for IP.\n"); // // 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. // pui8MACArray[0] = ((ui32User0 >> 0) & 0xff); pui8MACArray[1] = ((ui32User0 >> 8) & 0xff); pui8MACArray[2] = ((ui32User0 >> 16) & 0xff); pui8MACArray[3] = ((ui32User1 >> 0) & 0xff); pui8MACArray[4] = ((ui32User1 >> 8) & 0xff); pui8MACArray[5] = ((ui32User1 >> 16) & 0xff); // // Initialize the lwIP library, using DHCP. // // lwIPInit(g_ui32SysClock, pui8MACArray, 0, 0, 0, IPADDR_USE_DHCP); lwIPInit(g_ui32SysClock, pui8MACArray,0xC0A80002 ,0xFFFFFF0, 0xC0A80001 , IPADDR_USE_STATIC); // Setup the device locator service. // LocatorInit(); LocatorMACAddrSet(pui8MACArray); LocatorAppTitleSet("EK-TM4C1294XL enet_io"); // // Initialize a sample httpd server. // // httpd_init(); // tcp_connect( test_pcb, IP_ADDR_ANY, 1234, test_connected ); // UARTprintf("\%d\n",err); //write_err = tcp_write(pcb,&dataBuffer,10,0); // UARTprintf("\%d\n",write_err); //tcp_sent(pcb, tcp_sent_fn sent); //output_err = tcp_output(pcb); //UARTprintf("\%d\n",output_err); // // Set the interrupt priorities. We set the SysTick interrupt to a higher // priority than the Ethernet interrupt to ensure that the file system // tick is processed if SysTick occurs while the Ethernet handler is being // processed. This is very likely since all the TCP/IP and HTTP work is // done in the context of the Ethernet interrupt. // MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY); MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY); // // Loop forever. All the work is done in interrupt handlers. // while(1) { } }
_______________________________________________ lwip-users mailing list [email protected] https://lists.nongnu.org/mailman/listinfo/lwip-users
