File transfer problem with FTP server on zynq

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: ~~~



/* Define the byte order of the target MCU (the MCU FreeRTOS+TCP is executing on). Valid options are pdFREERTOSBIGENDIAN and pdFREERTOSLITTLEENDIAN. */


/* If the network card/driver includes checksum offloading (IP/TCP/UDP checksums) then set ipconfigDRIVERINCLUDEDRXIPCHECKSUM to 1 to prevent the software stack repeating the checksum calculations. */



/* Several API’s will block until the result is known, or the action has been performed, for example FreeRTOSsend() and FreeRTOSrecv(). The timeouts can be set per socket, using setsockopt(). If not set, the times below will be used as defaults. */


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, ipconfigDNSREQUESTATTEMPTS 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). ipconfigUDPTASKPRIORITY 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 (configMAXPRIORITIES – 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: */


/* 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 ipconfigUSENETWORKEVENTHOOK is set to 1 then FreeRTOS+TCP will call the network event hook at the appropriate times. If ipconfigUSENETWORKEVENTHOOK is not set to 1 then the network event hook will never be called. See */


/* Sockets have a send block time attribute. If FreeRTOSsendto() 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 ipconfigMAXSENDBLOCKTIMETICKS. 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. ipconfigMAXSENDBLOCKTIMETICKS 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. */


/* If ipconfigUSEDHCP 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 ipconfigUSEDHCP 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 ipconfigUSEDHCPHOOK 0

/* When ipconfigUSEDHCP 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 ipconfigMAXIMUMDISCOVERTXPERIOD. The IP stack will revert to using the static IP address passed as a parameter to FreeRTOSIPInit() if the re-transmission time interval reaches ipconfigMAXIMUMDISCOVERTXPERIOD 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. ipconfigARPCACHEENTRIES 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 ipconfigMAXARPRETRANSMISSIONS times before the ARP request is aborted. */

define ipconfigMAXARPRETRANSMISSIONS ( 5 )

/* ipconfigMAXARPAGE 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. ipconfigMAXARPAGE is specified in tens of seconds, so a value of 150 is equal to 1500 seconds (or 25 minutes). */

define ipconfigMAXARPAGE 150

/* Implementing FreeRTOSinetaddr() necessitates the use of string handling routines, which are relatively large. To save code space the full FreeRTOSinetaddr() implementation is made optional, and a smaller and faster alternative called FreeRTOSinetaddrquick() is provided. FreeRTOSinetaddr() takes an IP in decimal dot format (for example, “”) as its parameter. FreeRTOSinetaddrquick() takes an IP address as four separate numerical octets (for example, 192, 168, 0, 1) as its parameters. If ipconfigINCLUDEFULLINETADDR is set to 1 then both FreeRTOSinetaddr() and FreeRTOSindetaddrquick() are available. If ipconfigINCLUDEFULLINETADDR is not set to 1 then only FreeRTOSindetaddrquick() is available. */


/* ipconfigNUMNETWORKBUFFER_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. */


/* 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. ipconfigEVENTQUEUELENGTH 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. */


/* The address of a socket is the combination of its IP address and its port number. FreeRTOSbind() 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 ipconfigALLOWSOCKETSENDWITHOUTBIND 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 socketAUTOPORTALLOCATIONSTARTNUMBER to 0xffff. If ipconfigALLOWSOCKETSENDWITHOUTBIND 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. */


/* 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 ipconfigCANFRAGMENTOUTGOINGPACKETS is 1 then (ipconfigNETWORKMTU – 28) must be divisible by 8. */

define ipconfigNETWORK_MTU 1500

/* Set ipconfigUSEDNS to 1 to include a basic DNS client/resolver. DNS is used through the FreeRTOSgethostbyname() API function. */

define ipconfigUSE_DNS 0

/* If ipconfigREPLYTOINCOMING_PINGS is set to 1 then the IP stack will generate replies to incoming ICMP echo (ping) requests. */


/* If ipconfigSUPPORTOUTGOINGPINGS is set to 1 then the FreeRTOS_SendPingRequest() API function is available. */


/* If ipconfigSUPPORTSELECTFUNCTION is set to 1 then the FreeRTOS_select() (and associated) API function is available. */


/* If ipconfigFILTEROUTNONETHERNETII_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. */


/* If ipconfigETHERNETDRIVERFILTERSFRAMETYPES 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 ipconfigETHERNETDRIVERFILTERSFRAMETYPES 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. */


/* The windows simulator cannot really simulate MAC interrupts, and needs to block occasionally to allow other tasks to run. */


/* 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 TCPWINSEG_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 )


/* 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 ipconfigHASDEBUGPRINTF is set to 1 then FreeRTOSdebugprintf 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


/* Set to 1 to print out non debugging messages, for example the output of the FreeRTOSnetstat() 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


/* 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 )


~~~ Now I am blocked and I need some idea. Can someone help me? Thank you

File transfer problem with FTP server on zynq

Hi Claudio, the first thing I think of is Memory Caching. Could you write an email to me? My address is hein [at] htibosch[ dot] net I’m sure we’ll find the problem and report back to this forum once it is solved

File transfer problem with FTP server on zynq

Solved by using BufferAllocation1.c file instead of BufferAllocation2.c file. Thanks to Hein Tibosch for help. Best regards

File transfer problem with FTP server on zynq

Glad it works now. The difference between the two modules with respect to caching is: ● BufferAllocation_1.c pre allocates all buffers well-aligned, each with a length of 1536. The length 1536 is dividable by 32, which is the size of a DCache line. Xil_DCacheInvalidateRange() will work only on the buffer, not on neighbouring buffers. ● BufferAllocation_2.c has dynamic allocation: it will call vPortMalloc() each time when a network buffer is needed, and call vPortFree() when ready. Each time it will have a varying size and a 4-byte or 8-byte alignment. These buffers are not aligned with the data cache. Regards,