len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-20 05:21:59 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update a few util functions in the common demo area.

Browse source
This commit is contained in:
Richard Barry 2011-08-01 08:34:05 +00:00
parent a548ef34f8
commit 1aa52c2a7a
5 changed files with 616 additions and 422 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

155
Demo/Common/Utils/CommandInterpreter.c Normal file
View file

@ -0,0 +1,155 @@
/*
FreeRTOS V7.0.1 - Copyright (C) 2011 Real Time Engineers Ltd.
***************************************************************************
* *
* FreeRTOS tutorial books are available in pdf and paperback. *
* Complete, revised, and edited pdf reference manuals are also *
* available. *
* *
* Purchasing FreeRTOS documentation will not only help you, by *
* ensuring you get running as quickly as possible and with an *
* in-depth knowledge of how to use FreeRTOS, it will also help *
* the FreeRTOS project to continue with its mission of providing *
* professional grade, cross platform, de facto standard solutions *
* for microcontrollers - completely free of charge! *
* *
* >>> See http://www.FreeRTOS.org/Documentation for details. <<< *
* *
* Thank you for using FreeRTOS, and thank you for your support! *
* *
***************************************************************************
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation AND MODIFIED BY the FreeRTOS exception.
>>>NOTE<<< The modification to the GPL is included to allow you to
distribute a combined work that includes FreeRTOS without being obliged to
provide the source code for proprietary components outside of the FreeRTOS
kernel. FreeRTOS is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details. You should have received a copy of the GNU General Public
License and the FreeRTOS license exception along with FreeRTOS; if not it
can be viewed here: http://www.freertos.org/a00114.html and also obtained
by writing to Richard Barry, contact details for whom are available on the
FreeRTOS WEB site.
1 tab == 4 spaces!
http://www.FreeRTOS.org - Documentation, latest information, license and
contact details.
http://www.SafeRTOS.com - A version that is certified for use in safety
critical systems.
http://www.OpenRTOS.com - Commercial support, development, porting,
licensing and training services.
*/
#include "FreeRTOS.h"
#include "task.h"
#include "CommandInterpreter.h"
/*
* The callback function that is executed when "help" is entered. This is the
* only default command that is always present.
*/
static const signed char *prvHelpCommand( void );
/* The definition of the "help" command. This command is always at the front
of the list of registered commands. */
const xCommandLineInput xHelpCommand =
{
"help",
"help: Lists all the registered commands\r\n",
prvHelpCommand,
NULL
};
/*-----------------------------------------------------------*/
void vCmdIntRegisterCommand( const xCommandLineInput *pxCommandToRegister )
{
/* Used to point to the last command in the list of registered command, just to
make registering commands faster. */
static xCommandLineInput *pxLastCommandInList = &xHelpCommand;
configASSERT( pxLastCommandInList );
pxLastCommandInList->pxNext = pxCommandToRegister;
pxLastCommandInLIst = pxCommandToRegister;
}
/*-----------------------------------------------------------*/
const signed char *pcCmdIntProcessCommand( const signed char *pcCommandInput )
{
static const xCommandLineInput *pxCommand = NULL;
signed const char *pcReturn = NULL;
if( pxCommand == NULL )
{
/* Search for the command string in the list of registered commands. */
for( pxCommand = &xHelpCommand; pxCommand != NULL; pxCommand = pxCommand->pxNext )
{
if( strcmp( ( const char * ) pcCommandInput, ( const char * ) pxCommand->pcCommand ) == 0 )
{
/* The command has been found, the loop can exit so the command
can be executed. */
break;
}
}
}
if( pxCommand != NULL )
{
pcReturn = pxCommand->pxCommandInterpreter();
/* If no strings were returned, then all the strings that are going to
be returned by the current command have already been returned, and
pxCommand can be reset to NULL ready to search for the next entered
command. */
if( pcReturn == NULL )
{
pxCommand = NULL;
}
}
else
{
pcReturn = "Command not recognised\r\n\r\n";
pxCommand = &xHelpCommand;
}
return pcReturn;
}
/*-----------------------------------------------------------*/
static const signed char *prvHelpCommand( void )
{
static const xCommandLineInput * pxCommand = &xHelpCommand;
signed const char *pcReturn;
/* pxCommand will be NULL if all the commands in the list have already been
returned. */
if( pxCommand != NULL )
{
/* Return the next command help string, before moving the pointer on to
the next command in the list. */
pcReturn = pxCommand->pcHelpString;
pxCommand = pxCommand->pxNext;
}
else
{
/* Reset the pointer back to the start of the list. */
pxCommand = &xHelpCommand;
/* Return NULL to show that there are no more strings to return. */
pcReturn = NULL;
}
return pcReturn;
}

107
Demo/Common/Utils/CommandInterpreter.h Normal file
View file

@ -0,0 +1,107 @@
/*
FreeRTOS V7.0.1 - Copyright (C) 2011 Real Time Engineers Ltd.
***************************************************************************
* *
* FreeRTOS tutorial books are available in pdf and paperback. *
* Complete, revised, and edited pdf reference manuals are also *
* available. *
* *
* Purchasing FreeRTOS documentation will not only help you, by *
* ensuring you get running as quickly as possible and with an *
* in-depth knowledge of how to use FreeRTOS, it will also help *
* the FreeRTOS project to continue with its mission of providing *
* professional grade, cross platform, de facto standard solutions *
* for microcontrollers - completely free of charge! *
* *
* >>> See http://www.FreeRTOS.org/Documentation for details. <<< *
* *
* Thank you for using FreeRTOS, and thank you for your support! *
* *
***************************************************************************
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation AND MODIFIED BY the FreeRTOS exception.
>>>NOTE<<< The modification to the GPL is included to allow you to
distribute a combined work that includes FreeRTOS without being obliged to
provide the source code for proprietary components outside of the FreeRTOS
kernel. FreeRTOS is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details. You should have received a copy of the GNU General Public
License and the FreeRTOS license exception along with FreeRTOS; if not it
can be viewed here: http://www.freertos.org/a00114.html and also obtained
by writing to Richard Barry, contact details for whom are available on the
FreeRTOS WEB site.
1 tab == 4 spaces!
http://www.FreeRTOS.org - Documentation, latest information, license and
contact details.
http://www.SafeRTOS.com - A version that is certified for use in safety
critical systems.
http://www.OpenRTOS.com - Commercial support, development, porting,
licensing and training services.
*/
#ifndef COMMAND_INTERPRETER_H
#define COMMAND_INTERPRETER_H
/* The prototype to which callback functions used to process command line
commands must comply. This type will change when commands with parameters
are included. */
typedef const signed char * (*pdCOMMAND_LINE_CALLBACK)( void );
/* The structure that defines command line commands. A command line command
should be defined by declaring a const structure of this type. */
typedef struct xCOMMAND_LINE_INPUT
{
const signed char * const pcCommand; /* The command that causes pxCommandInterpreter to be executed. For example "help". Must be all lower case. */
const signed char * const pcHelpString; /* String that describes how to use the command. Should start with the command itself, and end with "\r\n". For exxample "help: Returns a list of all the commands\r\n". */
pdCOMMAND_LINE_CALLBACK pxCommandInterpreter; /* A pointer to the callback function that will return the output generated by the command. */
const struct xCOMMAND_LINE_INPUT *pxNext; /* A pointer to the next xCommandLinInput structure. This should be NULL when the command is defined. It will get filled in automatically when the command is registered. */
} xCommandLineInput;
/*
* Register the command passed in using the pxCommandToRegister parameter.
* Registering a command adds the command to the list of commands that are
* handled by the command interpreter. Once a command has been registered it
* can be executed from the command line.
*/
void vCmdIntRegisterCommand( const xCommandLineInput *pxCommandToRegister );
/*
* Runns the command interpreter for the command string "pcCommandInput". If
* pcCommandInput is valid (the command has been registered) a string will be
* returned, and pcCmdIntProcessCommand must then be called repeatedly until
* NULL is returned. If pcCommand pcCommandInput is not valid (the command is
* not recognised as a registered command) then an error message will be
* returned - and again pcCmdIntProcessCommand() must be called repeatedly
* until NULL is returned.
*
* pcCmdIntProcessCommand is not reentrant. It must not be called from more
* than one task - or at least - by more than one task at a time.
*/
const signed char *pcCmdIntProcessCommand( const signed char *pcCommandInput );
#endif /* COMMAND_INTERPRETER_H */

236
Demo/Common/ethernet/lwip-1.4.0/ports/win32/ethernetif.c
View file

@ -69,7 +69,6 @@
#include <lwip/stats.h> #include <lwip/stats.h>
#include <lwip/snmp.h> #include <lwip/snmp.h>
#include "netif/etharp.h" #include "netif/etharp.h"
#include "netif/ppp_oe.h"
/* Define those to better describe your network interface. */ /* Define those to better describe your network interface. */
#define IFNAME0 'w' #define IFNAME0 'w'
@ -77,15 +76,32 @@
#define netifMAX_MTU 1500 #define netifMAX_MTU 1500
struct ethernetif struct xEthernetIf
{ {
struct eth_addr *ethaddr; struct eth_addr *ethaddr;
/* Add whatever per-interface state that is needed here. */ /* Add whatever per-interface state that is needed here. */
}; };
/* Forward declarations. */ /*
static void ethernetif_input( const unsigned char * const pucInputData, long lLength ); * Place received packet in a pbuf and send a message to the tcpip task to let
static struct pbuf *low_level_input( const unsigned char * const pucInputData, long lDataLength ); * it know new data has arrived.
*/
static void prvEthernetInput( const unsigned char * const pucInputData, long lInputLength );
/*
* Copy the received data into a pbuf.
*/
static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, long lDataLength );
/*
* Send data from a pbuf to the hardware.
*/
static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p );
/*
* Perform any hardware and/or driver initialisation necessary.
*/
static void prvLowLevelInit( struct netif *pxNetIf );
/* /*
* Query the computer the simulation is being executed on to find the network * Query the computer the simulation is being executed on to find the network
@ -104,12 +120,15 @@ static void prvOpenSelectedNetworkInterface( pcap_if_t *pxAllNetworkInterfaces )
* just polls the interface. * just polls the interface.
*/ */
static void prvInterruptSimulator( void *pvParameters ); static void prvInterruptSimulator( void *pvParameters );
/* /*
* Configure the capture filter to allow blocking reads, and to filter out * Configure the capture filter to allow blocking reads, and to filter out
* packets that are not of interest to this demo. * packets that are not of interest to this demo.
*/ */
static void prvConfigureCaptureBehaviour( void ); static void prvConfigureCaptureBehaviour( void );
/*-----------------------------------------------------------*/
/* The WinPCap interface being used. */ /* The WinPCap interface being used. */
static pcap_t *pxOpenedInterfaceHandle = NULL; static pcap_t *pxOpenedInterfaceHandle = NULL;
@ -117,33 +136,35 @@ static pcap_t *pxOpenedInterfaceHandle = NULL;
static char cErrorBuffer[ PCAP_ERRBUF_SIZE ]; static char cErrorBuffer[ PCAP_ERRBUF_SIZE ];
/* The network interface that was opened. */ /* The network interface that was opened. */
static struct netif *xlwIPNetif = NULL; static struct netif *pxlwIPNetIf = NULL;
/*-----------------------------------------------------------*/
/** /**
* In this function, the hardware should be initialized. * In this function, the hardware should be initialized.
* Called from ethernetif_init(). * Called from ethernetif_init().
* *
* @param netif the already initialized lwip network interface structure * @param pxNetIf the already initialized lwip network interface structure
* for this ethernetif * for this ethernetif.
*/ */
static void low_level_init(struct netif *netif) static void prvLowLevelInit( struct netif *pxNetIf )
{ {
pcap_if_t *pxAllNetworkInterfaces; pcap_if_t *pxAllNetworkInterfaces;
/* set MAC hardware address length */ /* set MAC hardware address length */
netif->hwaddr_len = ETHARP_HWADDR_LEN; pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;
/* set MAC hardware address */ /* set MAC hardware address */
netif->hwaddr[ 0 ] = configMAC_ADDR0; pxNetIf->hwaddr[ 0 ] = configMAC_ADDR0;
netif->hwaddr[ 1 ] = configMAC_ADDR1; pxNetIf->hwaddr[ 1 ] = configMAC_ADDR1;
netif->hwaddr[ 2 ] = configMAC_ADDR2; pxNetIf->hwaddr[ 2 ] = configMAC_ADDR2;
netif->hwaddr[ 3 ] = configMAC_ADDR3; pxNetIf->hwaddr[ 3 ] = configMAC_ADDR3;
netif->hwaddr[ 4 ] = configMAC_ADDR4; pxNetIf->hwaddr[ 4 ] = configMAC_ADDR4;
netif->hwaddr[ 5 ] = configMAC_ADDR5; pxNetIf->hwaddr[ 5 ] = configMAC_ADDR5;
/* device capabilities */ /* device capabilities */
/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ /* don't set pxNetIf_FLAG_ETHARP if this device is not an ethernet one */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP; pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
/* Query the computer the simulation is being executed on to find the /* Query the computer the simulation is being executed on to find the
network interfaces it has installed. */ network interfaces it has installed. */
@ -161,7 +182,7 @@ pcap_if_t *pxAllNetworkInterfaces;
/* Remember which interface was opened as it is used in the interrupt /* Remember which interface was opened as it is used in the interrupt
simulator task. */ simulator task. */
xlwIPNetif = netif; pxlwIPNetIf = pxNetIf;
} }
/** /**
@ -169,7 +190,7 @@ pcap_if_t *pxAllNetworkInterfaces;
* contained in the pbuf that is passed to the function. This pbuf * contained in the pbuf that is passed to the function. This pbuf
* might be chained. * might be chained.
* *
* @param netif the lwip network interface structure for this ethernetif * @param pxNetIf the lwip network interface structure for this ethernetif
* @param p the MAC packet to send (e.g. IP packet including MAC addresses and type) * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
* @return ERR_OK if the packet could be sent * @return ERR_OK if the packet could be sent
* an err_t value if the packet couldn't be sent * an err_t value if the packet couldn't be sent
@ -180,41 +201,43 @@ pcap_if_t *pxAllNetworkInterfaces;
* dropped because of memory failure (except for the TCP timers). * dropped because of memory failure (except for the TCP timers).
*/ */
static err_t low_level_output(struct netif *netif, struct pbuf *p) static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p )
{ {
/* This is taken from lwIP example code and therefore does not conform /* This is taken from lwIP example code and therefore does not conform
to the FreeRTOS coding standard. */ to the FreeRTOS coding standard. */
struct pbuf *q; struct pbuf *q;
static unsigned char buffer[ 1520 ]; static unsigned char ucBuffer[ 1520 ];
unsigned char *buf = buffer; unsigned char *pucBuffer = ucBuffer;
unsigned char *ptr; unsigned char *pucChar;
struct eth_hdr *ethhdr; struct eth_hdr *pxHeader;
u16_t tot_len = p->tot_len - ETH_PAD_SIZE; u16_t usTotalLength = p->tot_len - ETH_PAD_SIZE;
err_t xReturn = ERR_OK;
#if defined(LWIP_DEBUG) && LWIP_NETIF_TX_SINGLE_PBUF #if defined(LWIP_DEBUG) && LWIP_NETIF_TX_SINGLE_PBUF
LWIP_ASSERT("p->next == NULL && p->len == p->tot_len", p->next == NULL && p->len == p->tot_len); LWIP_ASSERT("p->next == NULL && p->len == p->tot_len", p->next == NULL && p->len == p->tot_len);
#endif #endif
/* initiate transfer */ /* Initiate transfer. */
if (p->len == p->tot_len) if( p->len == p->tot_len )
{ {
/* no pbuf chain, don't have to copy -> faster */ /* No pbuf chain, don't have to copy -> faster. */
buf = &((unsigned char*)p->payload)[ETH_PAD_SIZE]; pucBuffer = &( ( unsigned char * ) p->payload )[ ETH_PAD_SIZE ];
} }
else else
{ {
/* pbuf chain, copy into contiguous buffer */ /* pbuf chain, copy into contiguous ucBuffer. */
if (p->tot_len >= sizeof(buffer)) if( p->tot_len >= sizeof( ucBuffer ) )
{ {
LINK_STATS_INC(link.lenerr); LINK_STATS_INC( link.lenerr );
LINK_STATS_INC(link.drop); LINK_STATS_INC( link.drop );
snmp_inc_ifoutdiscards(netif); snmp_inc_ifoutdiscards( pxNetIf );
return ERR_BUF; xReturn = ERR_BUF;
} }
else
ptr = buffer; {
pucChar = ucBuffer;
for( q = p; q != NULL; q = q->next ) for( q = p; q != NULL; q = q->next )
{ {
@ -222,56 +245,62 @@ u16_t tot_len = p->tot_len - ETH_PAD_SIZE;
time. The size of the data in each pbuf is kept in the ->len time. The size of the data in each pbuf is kept in the ->len
variable. */ variable. */
/* send data from(q->payload, q->len); */ /* send data from(q->payload, q->len); */
LWIP_DEBUGF(NETIF_DEBUG, ("netif: send ptr %p q->payload %p q->len %i q->next %p\n", ptr, q->payload, (int)q->len, (void*)q->next)); LWIP_DEBUGF( NETIF_DEBUG, ("NETIF: send pucChar %p q->payload %p q->len %i q->next %p\n", pucChar, q->payload, ( int ) q->len, ( void* ) q->next ) );
if (q == p) if( q == p )
{ {
memcpy(ptr, &((char*)q->payload)[ETH_PAD_SIZE], q->len - ETH_PAD_SIZE); memcpy( pucChar, &( ( char * ) q->payload )[ ETH_PAD_SIZE ], q->len - ETH_PAD_SIZE );
ptr += q->len - ETH_PAD_SIZE; pucChar += q->len - ETH_PAD_SIZE;
} }
else else
{ {
memcpy(ptr, q->payload, q->len); memcpy( pucChar, q->payload, q->len );
ptr += q->len; pucChar += q->len;
}
} }
} }
} }
/* signal that packet should be sent */ if( xReturn == ERR_OK )
if( pcap_sendpacket( pxOpenedInterfaceHandle, buf, tot_len ) < 0 )
{ {
LINK_STATS_INC(link.memerr); /* signal that packet should be sent */
LINK_STATS_INC(link.drop); if( pcap_sendpacket( pxOpenedInterfaceHandle, pucBuffer, usTotalLength ) < 0 )
snmp_inc_ifoutdiscards(netif); {
return ERR_BUF; LINK_STATS_INC( link.memerr );
LINK_STATS_INC( link.drop );
snmp_inc_ifoutdiscards( pxNetIf );
xReturn = ERR_BUF;
} }
else
{
LINK_STATS_INC( link.xmit );
snmp_add_ifoutoctets( pxNetIf, usTotalLength );
pxHeader = ( struct eth_hdr * )p->payload;
LINK_STATS_INC(link.xmit); if( ( pxHeader->dest.addr[ 0 ] & 1 ) != 0 )
snmp_add_ifoutoctets(netif, tot_len);
ethhdr = (struct eth_hdr *)p->payload;
if( ( ethhdr->dest.addr[ 0 ] & 1 ) != 0 )
{ {
/* broadcast or multicast packet*/ /* broadcast or multicast packet*/
snmp_inc_ifoutnucastpkts(netif); snmp_inc_ifoutnucastpkts( pxNetIf );
} }
else else
{ {
/* unicast packet */ /* unicast packet */
snmp_inc_ifoutucastpkts( netif ); snmp_inc_ifoutucastpkts( pxNetIf );
}
}
} }
return ERR_OK; return xReturn;
} }
/** /**
* Should allocate a pbuf and transfer the bytes of the incoming * Should allocate a pbuf and transfer the bytes of the incoming
* packet from the interface into the pbuf. * packet from the interface into the pbuf.
* *
* @param netif the lwip network interface structure for this ethernetif * @param pxNetIf the lwip network interface structure for this ethernetif
* @return a pbuf filled with the received packet (including MAC header) * @return a pbuf filled with the received packet (including MAC header)
* NULL on memory error * NULL on memory error
*/ */
static struct pbuf *low_level_input( const unsigned char * const pucInputData, long lDataLength ) static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, long lDataLength )
{ {
struct pbuf *p = NULL, *q; struct pbuf *p = NULL, *q;
@ -287,7 +316,7 @@ struct pbuf *p = NULL, *q;
if( p != NULL ) if( p != NULL )
{ {
#if ETH_PAD_SIZE #if ETH_PAD_SIZE
pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */ pbuf_header( p, -ETH_PAD_SIZE ); /* drop the padding word */
#endif #endif
/* We iterate over the pbuf chain until we have read the entire /* We iterate over the pbuf chain until we have read the entire
@ -300,7 +329,7 @@ struct pbuf *p = NULL, *q;
* variable. * variable.
* This does not necessarily have to be a memcpy, you can also preallocate * This does not necessarily have to be a memcpy, you can also preallocate
* pbufs for a DMA-enabled MAC and after receiving truncate it to the * pbufs for a DMA-enabled MAC and after receiving truncate it to the
* actually received size. In this case, ensure the tot_len member of the * actually received size. In this case, ensure the usTotalLength member of the
* pbuf is the sum of the chained pbuf len members. * pbuf is the sum of the chained pbuf len members.
*/ */
memcpy( q->payload, &( pucInputData[ lDataLength ] ), q->len ); memcpy( q->payload, &( pucInputData[ lDataLength ] ), q->len );
@ -311,7 +340,7 @@ struct pbuf *p = NULL, *q;
pbuf_header( p, ETH_PAD_SIZE ); /* reclaim the padding word */ pbuf_header( p, ETH_PAD_SIZE ); /* reclaim the padding word */
#endif #endif
LINK_STATS_INC(link.recv); LINK_STATS_INC( link.recv );
} }
} }
@ -320,41 +349,39 @@ struct pbuf *p = NULL, *q;
/** /**
* This function should be called when a packet is ready to be read * This function should be called when a packet is ready to be read
* from the interface. It uses the function low_level_input() that * from the interface. It uses the function prvLowLevelInput() that
* should handle the actual reception of bytes from the network * should handle the actual reception of bytes from the network
* interface. Then the type of the received packet is determined and * interface. Then the type of the received packet is determined and
* the appropriate input function is called. * the appropriate input function is called.
* *
* @param netif the lwip network interface structure for this ethernetif * @param pxNetIf the lwip network interface structure for this ethernetif
*/ */
static void ethernetif_input( const unsigned char * const pucInputData, long lInputLength ) static void prvEthernetInput( const unsigned char * const pucInputData, long lInputLength )
{ {
/* This is taken from lwIP example code and therefore does not conform /* This is taken from lwIP example code and therefore does not conform
to the FreeRTOS coding standard. */ to the FreeRTOS coding standard. */
struct eth_hdr *ethhdr; struct eth_hdr *pxHeader;
struct pbuf *p; struct pbuf *p;
/* move received packet into a new pbuf */ /* move received packet into a new pbuf */
p = low_level_input( pucInputData, lInputLength ); p = prvLowLevelInput( pucInputData, lInputLength );
/* no packet could be read, silently ignore this */ /* no packet could be read, silently ignore this */
if( p == NULL ) if( p != NULL )
{ {
return;
}
/* points to packet payload, which starts with an Ethernet header */ /* points to packet payload, which starts with an Ethernet header */
ethhdr = p->payload; pxHeader = p->payload;
switch( htons( ethhdr->type ) ) switch( htons( pxHeader->type ) )
{ {
/* IP or ARP packet? */ /* IP or ARP packet? */
case ETHTYPE_IP: case ETHTYPE_IP:
case ETHTYPE_ARP: case ETHTYPE_ARP:
/* full packet send to tcpip_thread to process */ /* full packet send to tcpip_thread to process */
if(xlwIPNetif->input( p, xlwIPNetif )!=ERR_OK ) if( pxlwIPNetIf->input( p, pxlwIPNetIf ) != ERR_OK )
{ {
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n")); LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_input: IP input error\n" ) );
pbuf_free(p); pbuf_free(p);
p = NULL; p = NULL;
} }
@ -365,61 +392,68 @@ struct pbuf *p;
p = NULL; p = NULL;
break; break;
} }
}
} }
/** /**
* Should be called at the beginning of the program to set up the * Should be called at the beginning of the program to set up the
* network interface. It calls the function low_level_init() to do the * network interface. It calls the function prvLowLevelInit() to do the
* actual setup of the hardware. * actual setup of the hardware.
* *
* This function should be passed as a parameter to netif_add(). * This function should be passed as a parameter to netif_add().
* *
* @param netif the lwip network interface structure for this ethernetif * @param pxNetIf the lwip network interface structure for this ethernetif
* @return ERR_OK if the loopif is initialized * @return ERR_OK if the loopif is initialized
* ERR_MEM if private data couldn't be allocated * ERR_MEM if private data couldn't be allocated
* any other err_t on error * any other err_t on error
*/ */
err_t ethernetif_init( struct netif *netif ) err_t ethernetif_init( struct netif *pxNetIf )
{ {
err_t xReturn = ERR_OK;
/* This is taken from lwIP example code and therefore does not conform /* This is taken from lwIP example code and therefore does not conform
to the FreeRTOS coding standard. */ to the FreeRTOS coding standard. */
struct ethernetif *ethernetif; struct xEthernetIf *pxEthernetIf;
LWIP_ASSERT( "netif != NULL", ( netif != NULL ) ); LWIP_ASSERT( "pxNetIf != NULL", ( pxNetIf != NULL ) );
ethernetif = mem_malloc( sizeof( struct ethernetif ) ); pxEthernetIf = mem_malloc( sizeof( struct xEthernetIf ) );
if (ethernetif == NULL) if( pxEthernetIf == NULL )
{ {
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n")); LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_init: out of memory\n" ) );
return ERR_MEM; xReturn = ERR_MEM;
} }
else
{
#if LWIP_NETIF_HOSTNAME #if LWIP_NETIF_HOSTNAME
{
/* Initialize interface hostname */ /* Initialize interface hostname */
netif->hostname = "lwip"; pxNetIf->hostname = "lwip";
}
#endif /* LWIP_NETIF_HOSTNAME */ #endif /* LWIP_NETIF_HOSTNAME */
netif->state = ethernetif; pxNetIf->state = pxEthernetIf;
netif->name[0] = IFNAME0; pxNetIf->name[ 0 ] = IFNAME0;
netif->name[1] = IFNAME1; pxNetIf->name[ 1 ] = IFNAME1;
/* We directly use etharp_output() here to save a function call. /* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output() * You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link * from it if you have to do some checks before sending (e.g. if link
* is available...) */ * is available...) */
netif->output = etharp_output; pxNetIf->output = etharp_output;
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP; pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
netif->hwaddr_len = ETHARP_HWADDR_LEN; pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;
netif->mtu = netifMAX_MTU; pxNetIf->mtu = netifMAX_MTU;
netif->linkoutput = low_level_output; pxNetIf->linkoutput = prvLowLevelOutput;
ethernetif->ethaddr = ( struct eth_addr * ) &( netif->hwaddr[ 0 ] ); pxEthernetIf->ethaddr = ( struct eth_addr * ) &( pxNetIf->hwaddr[ 0 ] );
/* initialize the hardware */ /* initialize the hardware */
low_level_init( netif ); prvLowLevelInit( pxNetIf );
}
return ERR_OK; return xReturn;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -542,9 +576,9 @@ long lResult;
lResult = pcap_next_ex( pxOpenedInterfaceHandle, &pxHeader, &pucPacketData ); lResult = pcap_next_ex( pxOpenedInterfaceHandle, &pxHeader, &pucPacketData );
if( lResult == 1 ) if( lResult == 1 )
{ {
if( xlwIPNetif != NULL ) if( pxlwIPNetIf != NULL )
{ {
ethernetif_input( pucPacketData, pxHeader->len ); prvEthernetInput( pucPacketData, pxHeader->len );
} }
} }
else else
@ -578,7 +612,7 @@ unsigned long ulNetMask;
if( pcap_compile(pxOpenedInterfaceHandle, &xFilterCode, cErrorBuffer, 1, ulNetMask ) < 0 ) if( pcap_compile(pxOpenedInterfaceHandle, &xFilterCode, cErrorBuffer, 1, ulNetMask ) < 0 )
{ {
printf("\r\nThe packet filter string is invalid\r\n" ); printf( "\r\nThe packet filter string is invalid\r\n" );
} }
else else
{ {

20
Demo/Common/ethernet/lwip-1.4.0/ports/win32/include/arch/sys_arch.h
View file

@ -37,8 +37,8 @@
#include "queue.h" #include "queue.h"
#include "semphr.h" #include "semphr.h"
#define SYS_MBOX_NULL (xQueueHandle)0 #define SYS_MBOX_NULL ( ( xQueueHandle ) NULL )
#define SYS_SEM_NULL (xSemaphoreHandle)0 #define SYS_SEM_NULL ( ( xSemaphoreHandle ) NULL )
#define SYS_DEFAULT_THREAD_STACK_DEPTH configMINIMAL_STACK_SIZE #define SYS_DEFAULT_THREAD_STACK_DEPTH configMINIMAL_STACK_SIZE
typedef xSemaphoreHandle sys_sem_t; typedef xSemaphoreHandle sys_sem_t;
@ -46,18 +46,10 @@ typedef xSemaphoreHandle sys_mutex_t;
typedef xQueueHandle sys_mbox_t; typedef xQueueHandle sys_mbox_t;
typedef xTaskHandle sys_thread_t; typedef xTaskHandle sys_thread_t;
typedef struct _sys_arch_state_t #define sys_mbox_valid( x ) ( ( ( *x ) == NULL) ? pdFALSE : pdTRUE )
{ #define sys_mbox_set_invalid( x ) ( ( *x ) = NULL )
// Task creation data. #define sys_sem_valid( x ) ( ( ( *x ) == NULL) ? pdFALSE : pdTRUE )
char cTaskName[configMAX_TASK_NAME_LEN]; #define sys_sem_set_invalid( x ) ( ( *x ) = NULL )
unsigned short nStackDepth;
unsigned short nTaskCount;
} sys_arch_state_t;
#define sys_mbox_valid( x ) ( (*x == NULL) ? 0 : 1 )
#define sys_mbox_set_invalid( x ) ( *x = NULL )
#define sys_sem_valid( x ) ( (*x == NULL) ? 0 : 1 )
#define sys_sem_set_invalid( x ) ( *x = NULL )
#endif /* __ARCH_SYS_ARCH_H__ */ #endif /* __ARCH_SYS_ARCH_H__ */

352
Demo/Common/ethernet/lwip-1.4.0/ports/win32/sys_arch.c
View file

@ -48,28 +48,6 @@
#include "lwip/mem.h" #include "lwip/mem.h"
#include "lwip/stats.h" #include "lwip/stats.h"
/*---------------------------------------------------------------------------*
* Globals:
*---------------------------------------------------------------------------*/
#if 0
_RB_
struct timeoutlist
{
struct sys_timeouts timeouts;
xTaskHandle pid;
};
/* This is the number of threads that can be started with sys_thread_new() */
#define SYS_THREAD_MAX 4
static u16_t s_nextthread = 0;
static struct timeoutlist s_timeoutlist[SYS_THREAD_MAX];
#endif
/*-----------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
* Routine: sys_mbox_new * Routine: sys_mbox_new
*---------------------------------------------------------------------------* *---------------------------------------------------------------------------*
@ -80,22 +58,19 @@ static struct timeoutlist s_timeoutlist[SYS_THREAD_MAX];
* Outputs: * Outputs:
* sys_mbox_t -- Handle to new mailbox * sys_mbox_t -- Handle to new mailbox
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
err_t sys_mbox_new(sys_mbox_t *mbox, int size) err_t sys_mbox_new( sys_mbox_t *pxMailBox, int iSize )
{ {
err_t lwip_err= ERR_MEM; err_t xReturn = ERR_MEM;
*mbox = xQueueCreate( size, sizeof( void * ) ); *pxMailBox = xQueueCreate( iSize, sizeof( void * ) );
// Created succesfully? if( *pxMailBox != NULL )
if(*mbox != NULL)
{ {
lwip_err = ERR_OK; xReturn = ERR_OK;
#if SYS_STATS SYS_STATS_INC_USED( mbox );
SYS_STATS_INC(mbox.used);
#endif /* SYS_STATS */
} }
return lwip_err; return xReturn;
} }
@ -111,23 +86,25 @@ err_t lwip_err= ERR_MEM;
* Outputs: * Outputs:
* sys_mbox_t -- Handle to new mailbox * sys_mbox_t -- Handle to new mailbox
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_mbox_free(sys_mbox_t *mbox) void sys_mbox_free( sys_mbox_t *pxMailBox )
{ {
unsigned portBASE_TYPE uxMessagesWaiting; unsigned long ulMessagesWaiting;
uxMessagesWaiting = uxQueueMessagesWaiting( *mbox ); ulMessagesWaiting = uxQueueMessagesWaiting( *pxMailBox );
configASSERT( ( uxMessagesWaiting == 0 ) ); configASSERT( ( ulMessagesWaiting == 0 ) );
#if SYS_STATS #if SYS_STATS
if (uxMessagesWaiting != 0U)
{ {
SYS_STATS_INC(mbox.err); if( ulMessagesWaiting != 0UL )
{
SYS_STATS_INC( mbox.err );
} }
SYS_STATS_DEC(mbox.used); SYS_STATS_DEC( mbox.used );
#endif /* SYS_STATS */ }
#endif /* SYS_STATS */
vQueueDelete( *mbox ); vQueueDelete( *pxMailBox );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -139,9 +116,9 @@ unsigned portBASE_TYPE uxMessagesWaiting;
* sys_mbox_t mbox -- Handle of mailbox * sys_mbox_t mbox -- Handle of mailbox
* void *data -- Pointer to data to post * void *data -- Pointer to data to post
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_mbox_post(sys_mbox_t *mbox, void *msg) void sys_mbox_post( sys_mbox_t *pxMailBox, void *pxMessageToPost )
{ {
while( xQueueSendToBack( *mbox, &msg, portMAX_DELAY ) != pdTRUE ); while( xQueueSendToBack( *pxMailBox, &pxMessageToPost, portMAX_DELAY ) != pdTRUE );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -157,23 +134,22 @@ void sys_mbox_post(sys_mbox_t *mbox, void *msg)
* err_t -- ERR_OK if message posted, else ERR_MEM * err_t -- ERR_OK if message posted, else ERR_MEM
* if not. * if not.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg) err_t sys_mbox_trypost( sys_mbox_t *pxMailBox, void *pxMessageToPost )
{ {
err_t result; err_t xReturn;
if ( xQueueSend( *mbox, &msg, 0 ) == pdPASS ) if( xQueueSend( *pxMailBox, &pxMessageToPost, 0UL ) == pdPASS )
{ {
result = ERR_OK; xReturn = ERR_OK;
} }
else else
{ {
// could not post, queue must be full /* The queue was already full. */
result = ERR_MEM; xReturn = ERR_MEM;
#if SYS_STATS SYS_STATS_INC( mbox.err );
SYS_STATS_INC(mbox.err);
#endif /* SYS_STATS */
} }
return result;
return xReturn;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -201,48 +177,50 @@ err_t result;
* u32_t -- SYS_ARCH_TIMEOUT if timeout, else number * u32_t -- SYS_ARCH_TIMEOUT if timeout, else number
* of milliseconds until received. * of milliseconds until received.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) u32_t sys_arch_mbox_fetch( sys_mbox_t *pxMailBox, void **ppvBuffer, u32_t ulTimeOut )
{ {
void *dummyptr; void *pvDummy;
portTickType StartTime, EndTime, Elapsed; portTickType xStartTime, xEndTime, xElapsed;
unsigned long ulReturn;
StartTime = xTaskGetTickCount(); xStartTime = xTaskGetTickCount();
if (NULL == msg) if( NULL == ppvBuffer )
{ {
msg = &dummyptr; ppvBuffer = &pvDummy;
} }
if (timeout != 0) if( ulTimeOut != 0UL )
{ {
if ( pdTRUE == xQueueReceive( *mbox, &(*msg), timeout / portTICK_RATE_MS ) ) if( pdTRUE == xQueueReceive( *pxMailBox, &( *ppvBuffer ), ulTimeOut/ portTICK_RATE_MS ) )
{ {
EndTime = xTaskGetTickCount(); xEndTime = xTaskGetTickCount();
Elapsed = (EndTime - StartTime) * portTICK_RATE_MS; xElapsed = ( xEndTime - xStartTime ) * portTICK_RATE_MS;
return ( Elapsed ); ulReturn = xElapsed;
} }
else // timed out blocking for message else
{ {
*msg = NULL; /* Timed out. */
*ppvBuffer = NULL;
return SYS_ARCH_TIMEOUT; ulReturn = SYS_ARCH_TIMEOUT;
} }
} }
else else
{ {
while( pdTRUE != xQueueReceive( mbox, &(*msg), portMAX_DELAY ) ); // time is arbitrary while( pdTRUE != xQueueReceive( *pxMailBox, &( *ppvBuffer ), portMAX_DELAY ) );
EndTime = xTaskGetTickCount(); xEndTime = xTaskGetTickCount();
Elapsed = (EndTime - StartTime) * portTICK_RATE_MS; xElapsed = ( xEndTime - xStartTime ) * portTICK_RATE_MS;
if (Elapsed == 0) if( xElapsed == 0UL )
{ {
Elapsed = 1; xElapsed = 1UL;
} }
// return time blocked TBD test ulReturn = xElapsed;
return (Elapsed);
} }
return ulReturn;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -259,66 +237,63 @@ portTickType StartTime, EndTime, Elapsed;
* u32_t -- SYS_MBOX_EMPTY if no messages. Otherwise, * u32_t -- SYS_MBOX_EMPTY if no messages. Otherwise,
* return ERR_OK. * return ERR_OK.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg) u32_t sys_arch_mbox_tryfetch( sys_mbox_t *pxMailBox, void **ppvBuffer )
{ {
void *dummyptr; void *pvDummy;
unsigned long ulReturn;
if (msg == NULL) if( ppvBuffer== NULL )
{ {
msg = &dummyptr; ppvBuffer = &pvDummy;
} }
if ( pdTRUE == xQueueReceive( *mbox, &(*msg), 0 ) ) if( pdTRUE == xQueueReceive( *pxMailBox, &( *ppvBuffer ), 0UL ) )
{ {
return ERR_OK; ulReturn = ERR_OK;
} }
else else
{ {
return SYS_MBOX_EMPTY; ulReturn = SYS_MBOX_EMPTY;
} }
return ulReturn;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
* Routine: sys_sem_new * Routine: sys_sem_new
*---------------------------------------------------------------------------* *---------------------------------------------------------------------------*
* Description: * Description:
* Creates and returns a new semaphore. The "count" argument specifies * Creates and returns a new semaphore. The "ucCount" argument specifies
* the initial state of the semaphore. * the initial state of the semaphore.
* NOTE: Currently this routine only creates counts of 1 or 0 * NOTE: Currently this routine only creates counts of 1 or 0
* Inputs: * Inputs:
* sys_mbox_t mbox -- Handle of mailbox * sys_mbox_t mbox -- Handle of mailbox
* u8_t count -- Initial count of semaphore (1 or 0) * u8_t ucCount -- Initial ucCount of semaphore (1 or 0)
* Outputs: * Outputs:
* sys_sem_t -- Created semaphore or 0 if could not create. * sys_sem_t -- Created semaphore or 0 if could not create.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
err_t sys_sem_new(sys_sem_t *sem, u8_t count) err_t sys_sem_new( sys_sem_t *pxSemaphore, u8_t ucCount )
{ {
err_t lwip_err = ERR_MEM; err_t xReturn = ERR_MEM;
vSemaphoreCreateBinary( (*sem) ); vSemaphoreCreateBinary( ( *pxSemaphore ) );
if( *sem != NULL ) if( *pxSemaphore != NULL )
{ {
// Means it can't be taken if( ucCount == 0U )
if (count == 0)
{ {
xSemaphoreTake(*sem, 1); xSemaphoreTake( *pxSemaphore, 1UL );
} }
lwip_err = ERR_OK; xReturn = ERR_OK;
SYS_STATS_INC_USED( sem );
#if SYS_STATS
SYS_STATS_INC(sem.used);
#endif
} }
else else
{ {
#if SYS_STATS SYS_STATS_INC( sem.err );
SYS_STATS_INC(sem.err);
#endif
} }
return lwip_err; return xReturn;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -344,92 +319,86 @@ err_t sys_sem_new(sys_sem_t *sem, u8_t count)
* Outputs: * Outputs:
* u32_t -- Time elapsed or SYS_ARCH_TIMEOUT. * u32_t -- Time elapsed or SYS_ARCH_TIMEOUT.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) u32_t sys_arch_sem_wait( sys_sem_t *pxSemaphore, u32_t ulTimeout )
{ {
portTickType StartTime, EndTime, Elapsed; portTickType xStartTime, xEndTime, xElapsed;
unsigned long ulReturn;
StartTime = xTaskGetTickCount(); xStartTime = xTaskGetTickCount();
if (timeout != 0) if( ulTimeout != 0UL )
{ {
if( xSemaphoreTake( *sem, timeout / portTICK_RATE_MS ) == pdTRUE ) if( xSemaphoreTake( *pxSemaphore, ulTimeout / portTICK_RATE_MS ) == pdTRUE )
{ {
EndTime = xTaskGetTickCount(); xEndTime = xTaskGetTickCount();
Elapsed = (EndTime - StartTime) * portTICK_RATE_MS; xElapsed = (xEndTime - xStartTime) * portTICK_RATE_MS;
ulReturn = xElapsed;
return (Elapsed); // return time blocked TODO test
} }
else else
{ {
return SYS_ARCH_TIMEOUT; ulReturn = SYS_ARCH_TIMEOUT;
} }
} }
else else
{ {
while( xSemaphoreTake( sem, portMAX_DELAY ) != pdTRUE ); while( xSemaphoreTake( *pxSemaphore, portMAX_DELAY ) != pdTRUE );
EndTime = xTaskGetTickCount(); xEndTime = xTaskGetTickCount();
Elapsed = (EndTime - StartTime) * portTICK_RATE_MS; xElapsed = ( xEndTime - xStartTime ) * portTICK_RATE_MS;
if (Elapsed == 0) if( xElapsed == 0UL )
{ {
Elapsed = 1; xElapsed = 1UL;
} }
// return time blocked ulReturn = xElapsed;
return (Elapsed);
} }
return ulReturn;
} }
/** Create a new mutex /** Create a new mutex
* @param mutex pointer to the mutex to create * @param mutex pointer to the mutex to create
* @return a new mutex */ * @return a new mutex */
err_t sys_mutex_new(sys_mutex_t *mutex) err_t sys_mutex_new( sys_mutex_t *pxMutex )
{ {
err_t lwip_err = ERR_MEM; err_t xReturn = ERR_MEM;
*mutex = xQueueCreateMutex(); *pxMutex = xQueueCreateMutex();
if( *mutex != NULL ) if( *pxMutex != NULL )
{ {
lwip_err = ERR_OK; xReturn = ERR_OK;
#if SYS_STATS SYS_STATS_INC_USED( mutex );
SYS_STATS_INC(mutex.used);
#endif
} }
else else
{ {
#if SYS_STATS SYS_STATS_INC( mutex.err );
SYS_STATS_INC(mutex.err);
#endif
} }
return lwip_err; return xReturn;
} }
/** Lock a mutex /** Lock a mutex
* @param mutex the mutex to lock */ * @param mutex the mutex to lock */
void sys_mutex_lock(sys_mutex_t *mutex) void sys_mutex_lock( sys_mutex_t *pxMutex )
{ {
while( xSemaphoreTake( *mutex, portMAX_DELAY ) != pdPASS ); while( xSemaphoreTake( *pxMutex, portMAX_DELAY ) != pdPASS );
} }
/** Unlock a mutex /** Unlock a mutex
* @param mutex the mutex to unlock */ * @param mutex the mutex to unlock */
void sys_mutex_unlock(sys_mutex_t *mutex) void sys_mutex_unlock(sys_mutex_t *pxMutex )
{ {
xSemaphoreGive(*mutex); xSemaphoreGive( *pxMutex );
} }
/** Delete a semaphore /** Delete a semaphore
* @param mutex the mutex to delete */ * @param mutex the mutex to delete */
void sys_mutex_free(sys_mutex_t *mutex) void sys_mutex_free( sys_mutex_t *pxMutex )
{ {
#if SYS_STATS SYS_STATS_DEC( mutex.used );
SYS_STATS_DEC(mutex.used); vQueueDelete( *pxMutex );
#endif /* SYS_STATS */
vQueueDelete(*mutex);
} }
@ -441,10 +410,9 @@ void sys_mutex_free(sys_mutex_t *mutex)
* Inputs: * Inputs:
* sys_sem_t sem -- Semaphore to signal * sys_sem_t sem -- Semaphore to signal
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_sem_signal(sys_sem_t * sem) void sys_sem_signal( sys_sem_t *pxSemaphore )
{ {
//LWIP_ASSERT( "sys_sem_signal: sem != SYS_SEM_NULL", sem != SYS_SEM_NULL ); xSemaphoreGive( *pxSemaphore );
xSemaphoreGive(*sem);
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -455,15 +423,10 @@ void sys_sem_signal(sys_sem_t * sem)
* Inputs: * Inputs:
* sys_sem_t sem -- Semaphore to free * sys_sem_t sem -- Semaphore to free
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_sem_free(sys_sem_t * sem) void sys_sem_free( sys_sem_t *pxSemaphore )
{ {
//LWIP_ASSERT( "sys_sem_free: sem != SYS_SEM_NULL", sem != SYS_SEM_NULL );
#if SYS_STATS
SYS_STATS_DEC(sem.used); SYS_STATS_DEC(sem.used);
#endif /* SYS_STATS */ vQueueDelete( *pxSemaphore );
vQueueDelete(*sem);
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -474,20 +437,6 @@ void sys_sem_free(sys_sem_t * sem)
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_init(void) void sys_init(void)
{ {
#if 0
int i;
// Initialize the the per-thread sys_timeouts structures
// make sure there are no valid pids in the list
for (i = 0; i < SYS_THREAD_MAX; i++)
{
s_timeoutlist[i].pid = SYS_THREAD_NULL;
// s_timeoutlist[i].timeouts.next = NULL;
}
// keep track of how many threads have been created
s_nextthread = 0;
#endif
} }
u32_t sys_now(void) u32_t sys_now(void)
@ -495,52 +444,6 @@ u32_t sys_now(void)
return xTaskGetTickCount(); return xTaskGetTickCount();
} }
#if 0
_RB_
u32_t sys_jiffies(void)
{
return UEZTickCounterGet();
}
#endif
/*---------------------------------------------------------------------------*
* Routine: sys_arch_timeouts
*---------------------------------------------------------------------------*
* Description:
* Returns a pointer to the per-thread sys_timeouts structure. In lwIP,
* each thread has a list of timeouts which is represented as a linked
* list of sys_timeout structures. The sys_timeouts structure holds a
* pointer to a linked list of timeouts. This function is called by
* the lwIP timeout scheduler and must not return a NULL value.
*
* In a single threaded sys_arch implementation, this function will
* simply return a pointer to a global sys_timeouts variable stored in
* the sys_arch module.
* Outputs:
* sys_timeouts * -- Pointer to per-thread timeouts.
*---------------------------------------------------------------------------*/
#if 0
struct sys_timeouts *sys_arch_timeouts(void)
{
int i;
T_uezTask pid;
struct timeoutlist *tl;
pid = UEZTaskGetCurrent();
for (i = 0; i < s_nextthread; i++)
{
tl = &(s_timeoutlist[i]);
if (tl->pid == pid)
{
// return &(tl->timeouts);
}
}
// Error
return NULL;
}
#endif
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
* Routine: sys_thread_new * Routine: sys_thread_new
*---------------------------------------------------------------------------* *---------------------------------------------------------------------------*
@ -559,21 +462,24 @@ struct sys_timeouts *sys_arch_timeouts(void)
* Outputs: * Outputs:
* sys_thread_t -- Pointer to per-thread timeouts. * sys_thread_t -- Pointer to per-thread timeouts.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
sys_thread_t sys_thread_new(const char *name, void(* thread)(void *arg), void *arg, int stacksize, int prio) sys_thread_t sys_thread_new( const char *pcName, void( *pxThread )( void *pvParameters ), void *pvArg, int iStackSize, int iPriority )
{ {
xTaskHandle CreatedTask; xTaskHandle xCreatedTask;
int result; portBASE_TYPE xResult;
sys_thread_t xReturn;
result = xTaskCreate( thread, ( signed portCHAR * ) name, stacksize, arg, prio, &CreatedTask ); xResult = xTaskCreate( pxThread, ( signed char * ) pcName, iStackSize, pvArg, iPriority, &xCreatedTask );
if(result == pdPASS) if( xResult == pdPASS )
{ {
return CreatedTask; xReturn = xCreatedTask;
} }
else else
{ {
return NULL; xReturn = NULL;
} }
return xReturn;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -595,10 +501,10 @@ int result;
* Outputs: * Outputs:
* sys_prot_t -- Previous protection level (not used here) * sys_prot_t -- Previous protection level (not used here)
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
sys_prot_t sys_arch_protect(void) sys_prot_t sys_arch_protect( void )
{ {
vPortEnterCritical(); vPortEnterCritical();
return 1; return ( sys_prot_t ) 1;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -612,18 +518,18 @@ sys_prot_t sys_arch_protect(void)
* Inputs: * Inputs:
* sys_prot_t -- Previous protection level (not used here) * sys_prot_t -- Previous protection level (not used here)
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_arch_unprotect(sys_prot_t pval) void sys_arch_unprotect( sys_prot_t xValue )
{ {
(void) pval; (void) xValue;
taskEXIT_CRITICAL(); taskEXIT_CRITICAL();
} }
/* /*
* Prints an assertion messages and aborts execution. * Prints an assertion messages and aborts execution.
*/ */
void sys_assert(const char *msg) void sys_assert( const char *pcMessage )
{ {
(void) msg; (void) pcMessage;
for (;;) for (;;)
{ {