Hi all
I’m using FreeRTOS+TCP, FreeRTOS+FAT and FreeRTOS FTP server to connect Filezilla to my board
in order to manage the SD card.
The software run correctly and I can see the SD card content, create folder, upload and download file from/to PC and the memory card.
However files transferred from PC to the SD card appear with some random data corrupted.
Instead files transferred from SD card to PC are ok.
I have tried the following:
1) Used FreeRTOS+TCP 2.01 and 2.07
2) Modified circular buffer size
but the probelm persist.
If I print out the data received from TCP in function prvStoreFileWork I see that data received from socket
are corrupted (the problem is not in +FAT).
This is my FreeRTOSIPconfig file:
~~~
ifndef FREERTOSIPCONFIG_H
define FREERTOSIPCONFIG_H
/* Define the byte order of the target MCU (the MCU FreeRTOS+TCP is executing
on). Valid options are pdFREERTOS
BIGENDIAN and pdFREERTOS
LITTLEENDIAN. */
define ipconfigBYTEORDER pdFREERTOSLITTLE_ENDIAN
/* If the network card/driver includes checksum offloading (IP/TCP/UDP checksums)
then set ipconfigDRIVER
INCLUDEDRX
IPCHECKSUM to 1 to prevent the software
stack repeating the checksum calculations. */
define ipconfigDRIVERINCLUDEDTXIPCHECKSUM ( 1 )
define ipconfigDRIVERINCLUDEDRXIPCHECKSUM ( 1 )
/* Several API’s will block until the result is known, or the action has been
performed, for example FreeRTOS
send() and FreeRTOSrecv(). The timeouts can be
set per socket, using setsockopt(). If not set, the times below will be
used as defaults. */
define ipconfigSOCKDEFAULTRECEIVEBLOCKTIME ( 5000 )
define ipconfigSOCKDEFAULTSENDBLOCKTIME ( 5000 )
/* Include support for LLMNR: Link-local Multicast Name Resolution
(non-Microsoft) */
define ipconfigUSE_LLMNR ( 0 )
/* Include support for NBNS: NetBIOS Name Service (Microsoft) */
define ipconfigUSE_NBNS ( 0 )
/* Include support for DNS caching. For TCP, having a small DNS cache is very
useful. When a cache is present, ipconfigDNS
REQUESTATTEMPTS can be kept low
and also DNS may use small timeouts. If a DNS reply comes in after the DNS
socket has been destroyed, the result will be stored into the cache. The next
call to FreeRTOS_gethostbyname() will return immediately, without even creating
a socket. */
define ipconfigUSEDNSCACHE ( 1 )
define ipconfigDNSCACHENAME_LENGTH ( 16 )
define ipconfigDNSCACHEENTRIES ( 4 )
define ipconfigDNSREQUESTATTEMPTS ( 2 )
/* The IP stack executes it its own task (although any application task can make
use of its services through the published sockets API). ipconfigUDP
TASKPRIORITY
sets the priority of the task that executes the IP stack. The priority is a
standard FreeRTOS task priority so can take any value from 0 (the lowest
priority) to (configMAX
PRIORITIES – 1) (the highest priority).
configMAXPRIORITIES is a standard FreeRTOS configuration parameter defined in
FreeRTOSConfig.h, not FreeRTOSIPConfig.h. Consideration needs to be given as to
the priority assigned to the task executing the IP stack relative to the
priority assigned to tasks that use the IP stack. */
define ipconfigIPTASKPRIORITY ( configMAX_PRIORITIES – 2 )
/* The size, in words (not bytes), of the stack allocated to the FreeRTOS+TCP
task. This setting is less important when the FreeRTOS Win32 simulator is used
as the Win32 simulator only stores a fixed amount of information on the task
stack. FreeRTOS includes optional stack overflow detection, see:
http://www.freertos.org/Stacks-and-stack-overflow-checking.html */
define ipconfigIPTASKSTACKSIZEWORDS ( configMINIMALSTACKSIZE * 5 )
/* ipconfigRAND32() is called by the IP stack to generate random numbers for
things such as a DHCP transaction number or initial sequence number. Random
number generation is performed via this macro to allow applications to use their
own random number generation method. For example, it might be possible to
generate a random number by sampling noise on an analogue input. */
extern UBaseType_t uxRand();
define ipconfigRAND32() uxRand()
/* If ipconfigUSE
NETWORKEVENT
HOOK is set to 1 then FreeRTOS+TCP will call the
network event hook at the appropriate times. If ipconfigUSENETWORK
EVENTHOOK
is not set to 1 then the network event hook will never be called. See
http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS
PlusUDP/API/vApplicationIPNetworkEventHook.shtml
*/
define ipconfigUSENETWORKEVENT_HOOK 1
/* Sockets have a send block time attribute. If FreeRTOS
sendto() is called but
a network buffer cannot be obtained then the calling task is held in the Blocked
state (so other tasks can continue to executed) until either a network buffer
becomes available or the send block time expires. If the send block time expires
then the send operation is aborted. The maximum allowable send block time is
capped to the value set by ipconfigMAXSEND
BLOCKTIME
TICKS. Capping the
maximum allowable send block time prevents prevents a deadlock occurring when
all the network buffers are in use and the tasks that process (and subsequently
free) the network buffers are themselves blocked waiting for a network buffer.
ipconfigMAXSEND
BLOCKTIME
TICKS is specified in RTOS ticks. A time in
milliseconds can be converted to a time in ticks by dividing the time in
milliseconds by portTICKPERIOD_MS. */
define ipconfigUDPMAXSENDBLOCKTIMETICKS ( 5000 / portTICKPERIOD_MS )
/* If ipconfigUSE
DHCP is 1 then FreeRTOS+TCP will attempt to retrieve an IP
address, netmask, DNS server address and gateway address from a DHCP server. If
ipconfigUSEDHCP is 0 then FreeRTOS+TCP will use a static IP address. The
stack will revert to using the static IP address even when ipconfigUSE
DHCP is
set to 1 if a valid configuration cannot be obtained from a DHCP server for any
reason. The static configuration used is that passed into the stack by the
FreeRTOSIPInit() function call. */
define ipconfigUSE_DHCP 0
define ipconfigDHCPREGISTERHOSTNAME 0
define ipconfigUSEDHCPHOOK 0
/* When ipconfigUSE
DHCP is set to 1, DHCP requests will be sent out at
increasing time intervals until either a reply is received from a DHCP server
and accepted, or the interval between transmissions reaches
ipconfigMAXIMUMDISCOVER
TXPERIOD. The IP stack will revert to using the
static IP address passed as a parameter to FreeRTOS
IPInit() if the
re-transmission time interval reaches ipconfigMAXIMUMDISCOVER
TXPERIOD without
a DHCP reply being received. */
define ipconfigMAXIMUMDISCOVERTXPERIOD ( pdMSTO_TICKS( 30000 ) )
/* The ARP cache is a table that maps IP addresses to MAC addresses. The IP
stack can only send a UDP message to a remove IP address if it knowns the MAC
address associated with the IP address, or the MAC address of the router used to
contact the remote IP address. When a UDP message is received from a remote IP
address the MAC address and IP address are added to the ARP cache. When a UDP
message is sent to a remote IP address that does not already appear in the ARP
cache then the UDP message is replaced by a ARP message that solicits the
required MAC address information. ipconfigARP
CACHEENTRIES defines the maximum
number of entries that can exist in the ARP table at any one time. */
define ipconfigARPCACHEENTRIES 6
/* ARP requests that do not result in an ARP response will be re-transmitted a
maximum of ipconfigMAX
ARPRETRANSMISSIONS times before the ARP request is
aborted. */
define ipconfigMAXARPRETRANSMISSIONS ( 5 )
/* ipconfigMAX
ARPAGE defines the maximum time between an entry in the ARP
table being created or refreshed and the entry being removed because it is stale.
New ARP requests are sent for ARP cache entries that are nearing their maximum
age. ipconfigMAX
ARPAGE is specified in tens of seconds, so a value of 150 is
equal to 1500 seconds (or 25 minutes). */
define ipconfigMAXARPAGE 150
/* Implementing FreeRTOS
inetaddr() necessitates the use of string handling
routines, which are relatively large. To save code space the full
FreeRTOS
inetaddr() implementation is made optional, and a smaller and faster
alternative called FreeRTOS
inetaddr
quick() is provided. FreeRTOSinet
addr()
takes an IP in decimal dot format (for example, “192.168.0.1”) as its parameter.
FreeRTOSinet
addrquick() takes an IP address as four separate numerical octets
(for example, 192, 168, 0, 1) as its parameters. If
ipconfigINCLUDE
FULLINET
ADDR is set to 1 then both FreeRTOSinet
addr() and
FreeRTOSindet
addrquick() are available. If ipconfigINCLUDE
FULLINET
ADDR is
not set to 1 then only FreeRTOSindet
addrquick() is available. */
define ipconfigINCLUDEFULLINET_ADDR 1
/* ipconfigNUM
NETWORKBUFFER_DESCRIPTORS defines the total number of network buffer that
are available to the IP stack. The total number of network buffers is limited
to ensure the total amount of RAM that can be consumed by the IP stack is capped
to a pre-determinable value. */
define ipconfigNUMNETWORKBUFFER_DESCRIPTORS 96
/* Optimisation that allows more than one Rx buffer to be passed to the TCP task
at a time – requires driver support. */
define ipconfigUSELINKEDRX_MESSAGES ( 1 )
/* A FreeRTOS queue is used to send events from application tasks to the IP
stack. ipconfigEVENT
QUEUELENGTH sets the maximum number of events that can
be queued for processing at any one time. The event queue must be a minimum of
5 greater than the total number of network buffers. */
define ipconfigEVENTQUEUELENGTH ( ipconfigNUMNETWORKBUFFER_DESCRIPTORS + 5 )
/* The address of a socket is the combination of its IP address and its port
number. FreeRTOS
bind() is used to manually allocate a port number to a socket
(to ‘bind’ the socket to a port), but manual binding is not normally necessary
for client sockets (those sockets that initiate outgoing connections rather than
wait for incoming connections on a known port number). If
ipconfigALLOWSOCKET
SENDWITHOUT
BIND is set to 1 then calling
FreeRTOSsendto() on a socket that has not yet been bound will result in the IP
stack automatically binding the socket to a port number from the range
socketAUTO
PORTALLOCATION
STARTNUMBER to 0xffff. If
ipconfigALLOW
SOCKETSEND
WITHOUTBIND is set to 0 then calling FreeRTOS_sendto()
on a socket that has not yet been bound will result in the send operation being
aborted. */
define ipconfigALLOWSOCKETSENDWITHOUTBIND 1
/* Defines the Time To Live (TTL) values used in outgoing UDP packets. */
define ipconfigUDPTIMETO_LIVE 128
define ipconfigTCPTIMETO_LIVE 128 /* also defined in FreeRTOSIPConfigDefaults.h */
/* USE_TCP: Use TCP and all its features */
define ipconfigUSE_TCP ( 1 )
/* USE_WIN: Let TCP use windowing mechanism. */
define ipconfigUSETCPWIN ( 1 )
/* The MTU is the maximum number of bytes the payload of a network frame can
contain. For normal Ethernet V2 frames the maximum MTU is 1500. Setting a
lower value can save RAM, depending on the buffer management scheme used. If
ipconfigCAN
FRAGMENTOUTGOING
PACKETS is 1 then (ipconfigNETWORKMTU – 28) must
be divisible by 8. */
define ipconfigNETWORK_MTU 1500
/* Set ipconfigUSE
DNS to 1 to include a basic DNS client/resolver. DNS is used
through the FreeRTOSgethostbyname() API function. */
define ipconfigUSE_DNS 0
/* If ipconfigREPLY
TOINCOMING_PINGS is set to 1 then the IP stack will
generate replies to incoming ICMP echo (ping) requests. */
define ipconfigREPLYTOINCOMING_PINGS 1
/* If ipconfigSUPPORT
OUTGOINGPINGS is set to 1 then the
FreeRTOS_SendPingRequest() API function is available. */
define ipconfigSUPPORTOUTGOINGPINGS 0
/* If ipconfigSUPPORT
SELECTFUNCTION is set to 1 then the FreeRTOS_select()
(and associated) API function is available. */
define ipconfigSUPPORTSELECTFUNCTION 1
/* If ipconfigFILTER
OUTNON
ETHERNETII_FRAMES is set to 1 then Ethernet frames
that are not in Ethernet II format will be dropped. This option is included for
potential future IP stack developments. */
define ipconfigFILTEROUTNONETHERNETII_FRAMES 1
/* If ipconfigETHERNET
DRIVERFILTERS
FRAMETYPES is set to 1 then it is the
responsibility of the Ethernet interface to filter out packets that are of no
interest. If the Ethernet interface does not implement this functionality, then
set ipconfigETHERNET
DRIVERFILTERS
FRAMETYPES to 0 to have the IP stack
perform the filtering instead (it is much less efficient for the stack to do it
because the packet will already have been passed into the stack). If the
Ethernet driver does all the necessary filtering in hardware then software
filtering can be removed by using a value other than 1 or 0. */
define ipconfigETHERNETDRIVERFILTERSFRAMETYPES 1
/* The windows simulator cannot really simulate MAC interrupts, and needs to
block occasionally to allow other tasks to run. */
define configWINDOWSMACINTERRUPTSIMULATORDELAY ( 2 / portTICKPERIODMS )
/* Advanced only: in order to access 32-bit fields in the IP packets with
32-bit memory instructions, all packets will be stored 32-bit-aligned, plus 16-bits.
This has to do with the contents of the IP-packets: all 32-bit fields are
32-bit-aligned, plus 16-bit(!) */
define ipconfigPACKETFILLERSIZE 2
/* Define the size of the pool of TCP window descriptors. On the average, each
TCP socket will use up to 2 x 6 descriptors, meaning that it can have 2 x 6
outstanding packets (for Rx and Tx). When using up to 10 TP sockets
simultaneously, one could define TCP
WINSEG_COUNT as 120. */
define ipconfigTCPWINSEG_COUNT 240
/* Each TCP socket has a circular buffers for Rx and Tx, which have a fixed
maximum size. Define the size of Rx buffer for TCP sockets. */
define ipconfigTCPRXBUFFER_LENGTH ( 0x4000 )
/* Define the size of Tx buffer for TCP sockets. */
define ipconfigTCPTXBUFFER_LENGTH ( 0x4000 )
/* When using call-back handlers, the driver may check if the handler points to
real program memory (RAM or flash) or just has a random non-zero value. */
define ipconfigISVALIDPROG_ADDRESS(x) ( (x) != NULL )
/* Include support for TCP hang protection. All sockets in a connecting or
disconnecting stage will timeout after a period of non-activity. */
define ipconfigTCPHANGPROTECTION ( 1 )
define ipconfigTCPHANGPROTECTION_TIME ( 30 )
/* Include support for TCP keep-alive messages. */
define ipconfigTCPKEEPALIVE ( 1 )
define ipconfigTCPKEEPALIVE_INTERVAL ( 20 ) /* in seconds */
/* Zynq driver specific parameters */
define ipconfigNICINCLUDEGEM ( 1 )
define ipconfigNICNTX_DESC ( 32 )
define ipconfigNICNRX_DESC ( 32 )
//#define ipconfigNIC_LINKSPEED100 ( 1 )
define ipconfigNICLINKSPEEDAUTODETECT ( 1 )
/* Set to 1 or 0 to include/exclude FTP and HTTP functionality from the standard
server task. */
define ipconfigUSE_HTTP ( 0 )
define ipconfigUSE_FTP ( 1 )
/* Buffer and window sizes used by the FTP and HTTP servers respectively. The
FTP and HTTP servers both execute in the standard server task. */
define ipconfigFTPTXBUFSIZE ( 256 * 1024 )
define ipconfigFTPTXWINSIZE ( 8 )
define ipconfigFTPRXBUFSIZE ( ( 256 * 1024 ) – 1 )
define ipconfigFTPRXWINSIZE ( 12 )
define ipconfigHTTPTXBUFSIZE ( 256 * 1024 )
define ipconfigHTTPTXWINSIZE ( 8 )
define ipconfigHTTPRXBUFSIZE ( ( 256 * 1024 ) – 1 )
define ipconfigHTTPRXWINSIZE ( 12 )
/* When set to 1, the application writer must provide the implementation of a
function with the following name and prototype:
BaseType_t xApplicationDNSQueryHook( const char *pcName );
The function must return pdTRUE if pcName matches a test name assigned to the
device, and pdFALSE in all other cases. */
define ipconfigDNSUSECALLBACKS 0
/* Set to 1 if the driver’s transmit function is using zero copy. Otherwise set
to 0. */
define ipconfigZEROCOPYTX_DRIVER 1
/* UDP Logging related constants follow. The standard UDP logging facility
writes formatted strings to a buffer, and creates a task that removes messages
from the buffer and sends them to the UDP address and port defined by the
constants that follow. */
/* Prototype for the function used to print out. In this case the standard
UDP logging facility is used. */
extern int lUDPLoggingPrintf( const char *pcFormatString, … );
/* Set to 1 to print out debug messages. If ipconfigHAS
DEBUGPRINTF is set to
1 then FreeRTOS
debugprintf should be defined to the function used to print
out the debugging messages. */
void xil_printf( const char8 *ctrl1, …);
define ipconfigHASDEBUGPRINTF 1
if( ipconfigHASDEBUGPRINTF == 1 )
#define FreeRTOS_debug_printf(X) xil_printf X
endif
/* Set to 1 to print out non debugging messages, for example the output of the
FreeRTOS
netstat() command, and ping replies. If ipconfigHASPRINTF is set to 1
then FreeRTOS_printf should be set to the function used to print out the
messages. */
define ipconfigHAS_PRINTF 1
if( ipconfigHAS_PRINTF == 1 )
#define FreeRTOS_printf(X) xil_printf X
endif
/* The example IP trace macros are included here so the definitions are
available in all the FreeRTOS+TCP source files. */
//#include “DemoIPTrace.h”
define ipconfigMULTI_INTERFACE ( 0 )
endif /* FREERTOSIPCONFIG_H */
~~~
Now I am blocked and I need some idea.
Can someone help me?
Thank you
