uIP Embedded Web Server Demo
using CrossStudio and GCC on an LPC2368
[Embedded Ethernet Examples]
Please note: Due to problems in early LPC2368 devices the MAM (memory accelerator) mode must be set to zero in order for this
demo to execute correctly.
This page describes the FreeRTOS uIP demo running on the NXP LPC2368 ARM7 microcontroller. The demo creates a simple web server
that can be used to both view run time information, and write data to the LEDs and LCD display on the target hardware.
The demo uses:
Please note that uIP is licensed separately from FreeRTOS.org. Users must familiarise themselves with the uIP license.
FreeRTOS has made some modifications to the uIP stack since this demo was created. See the Embedded Ethernet Examples List page for more information.
An alternative demo targeted at the LPC2378 using the HiTOP development tools is available from Hitex.
IMPORTANT! Notes on using the LPC23xx Web Server Demo
Please read all the following points before using this RTOS port.
See also the FAQ My application does not run, what could be wrong?
- Source Code Organisation
- The Demo Application
- RTOS Configuration and Usage Details
Source Code Organisation
The FreeRTOS download contains the source code for all the FreeRTOS ports, so contains many more files than used by this demo.
See the Source Code Organization section for a description of the
downloaded files and information on creating a new project.
The CrossWorks solution (workspace) for the LPC2368 demo is located in the FreeRTOS/Demo/ARM7_LPC2368_ROWLEY directory.
The Demo Application
Demo application setup
Connect the MCB2300 development board to a computer running a web browser either directly using a point to point (crossover)
cable, or via a hub/router using a standard Ethernet cable. The prototyping board may also allow the use of a standard
Ethernet cable when connecting point to point, but I have not tried this configuration.
The IP address used by the demo is set by the constants uipIP_ADDR0 to
uipIP_ADDR3 within the file FreeRTOS/Demo/ARM7_LPC2368_Rowley/uIP_Task.c.
The IP addresses used by the web browser computer and the prototyping board must be compatible.
This can be ensured by making the first three octets of both IP addresses identical.
For example, if the web browser computer uses IP address
192.168.100.1, then the prototyping board can be given any address in the range 192.168.100.2 to 192.168.100.254 (barring
any addresses already present on the network).
The constants uipMAC_ADDR0 to uipMAC_ADDR5 within the same file define the MAC address used by the target hardware.
You must ensure that the configured MAC address is unique on the network to which the prototyping board is being connected.
The demo application uses the LEDs and LCD built onto the prototyping board so no other hardware setup is required.
Building the demo application
Three project configurations are provided. "THUMB Flash Debug" and "ARM Flash Debug" use minimal optimisation and can easily be used with the CrossConnect JTAG
debug interface. "ARM Flash Release" has more optimisation, is less debugger friendly, and will start up directly from a power on reset.
- Ensure you have the necessary LPC2000 and MCB2300 support packages for your CrossWorks
- Open the FreeRTOS/Demo/ARM7_LPC2368_Rowley/RTOSDemo.hzp project from within the CrossWorks IDE.
- Select the configuration to be used.
Selecting the configuration to build
- Select 'Build Solution' from the IDE 'Build' menu.
Running the demo application
Ensure the CrossConnect JTAG debug interface is connected and that the MCB2300 development board is power up.
Ensure an Ethernet cable is connected as described above.
- Connect the CrossConnect JTAG interface to the target by selecting 'Connect USB CrossConnect for ARM' from the
'Target' menu (this step can normally be skipped as the interface will be detected automatically).
Select 'Start Debugging' from the IDE 'Debug' menu.
The microcontroller Flash memory will be programmed with the demo application, and the debugger
will break at the start of the main() function.
- Select 'Go' from the IDE 'Debug' menu to start the application
The demo application creates 23 persistent tasks, and periodically dynamically creates and destroys another 4. These tasks consist predominantly of the standard
demo application tasks (see the demo application section for details of the individual tasks).
The following tasks are created in addition to the standard demo tasks:
- The uIP task
This task handles all the network processing. It will spend most of its time blocked on a semaphore - waiting to be woken by interrupts generated
by incoming network packets.
- An LCD task
This is a 'gatekeeper' task. It is the only task that is permitted to write to the LCD, thus ensuring consistent access. Other tasks wishing to write
to the LCD send the string to be displayed to the LCD task rather than accessing the LCD directly.
- The 'check' task
The 'check' task is responsible for ensuring that all the standard demo tasks are executing as expected. It only executes every five
seconds, but has the highest priority within the system so is guaranteed to get execution time. Any errors discovered by the check task
are latched until the processor is reset. At the end of each cycle the check task sends either a pass or fail message to the 'LCD' task for
display on the LCD.
When executing correctly the demo application will behave as follows:
- LEDs P2.0, P2.1 and P2.3 are under control of the 'flash' tasks. Each will flash at a constant frequency, with LED P2.0 being
the fastest and LED P2.3 being the slowest.
- The 'check' task will write "PASS" to the display every 5 seconds.
- The target hardware will serve the web pages described below to a standard web browser. To connect to the target:
- Open a web browser on the connected computer.
- Type "HTTP://" followed by the target IP address into the browsers address bar.
Entering the IP address into the web browser
(obviously use the correct IP address for your system)
Served Web Pages
The top of each served page includes a menu containing a link to every other page.
The served RTOS stats page
The RTOS stats page provides run time information on the state of each task within the system - including the stack high water mark (the minimum amount of stack
there has been available at any time since the task started executing). The page will reload approximately every two seconds - depending on network load.
This page is transmitted in three sections - the HTML header and menu, the dynamically generated content, then finally the HTML footer. This makes the page relatively
fast to load. It could be optimised further by transmitting the entire page in one go.
The continuous reloading can sometimes make navigating away from the RTOS stats page a little tricky.
The served IO page
The IO page provides a simple interface that permits data to be sent to the LEDs and LCD on the MCB2300 development board.
The three check boxes permit the state of the LEDs on outputs P2.5, P2.6 and P2.7 to be set and queried. The text box can be used to write a message to the LCD,
but does not query the text currently being display.
Changes are sent to the target hardware by clicking the "Update IO" button.
Note that the 'check' task updates the display every 5 seconds, so any text sent from a web client will soon be overwritten.
The TCP Stats and Connections pages display run time networking information. Note that these pages transmit each line individually so will not load quickly.
This demonstrates how memory usage can be optimised through the use of a small transmit buffer by sacrificing the achieved data throughput.
This demo uses the FreeRTOS LPC2000 GCC port - important usage information can be found on the standard LPC2000 GCC demo documentation page.
Copyright (C) Amazon Web Services, Inc. or its affiliates. All rights reserved.