Jump to main content

##

# TCP/IP Stack Manager Configurations

TCP/IP Manager Specific User Configurations

- TCP/IP Stack State Machine Tick Rate, ms.:

  - The TCP/IP task will require a timer event with this rate for maintaining its own state machine, processing timeouts for all modules, or dispatching the RX traffic if the interrupt operation is not enabled, etc.
  - The lower this value (higher the frequency) the higher the priority of the TCP/IP stack and a higher performance can be obtained.
  - Note: this is the time base for all TCP/IP modules, i.e. no TCP/IP module can run at a rate higher than this one.
  - Note: the System Tick resolution has to be fine enough to allow for this TCP/IP rate granularity.
  - Value is in milliseconds
  - Default value: 5
  - Symbol TCPIP_STACK_TICK_RATE

- Stack Size (in bytes):

  - The size of the stack for the TCP/IP RTOS task
  - Default value: 4096
  - Symbol TCPIP_RTOS_TASK_STACK_SIZE

- Task Priority:

  - The priority of the TCP/IP RTOS task
  - Default value: 1
  - Symbol TCPIP_RTOS_TASK_PRIORITY

- Use Task Delay?:

  - Use delay to sleep the TCP/IP RTOS task
  - Default value: true
  - Symbol TCPIP_STACK_RTOS_USE_DELAY

- Task Delay:

  - The delay for the TCP/IP RTOS task
  - Default value: 1
  - Symbol TCPIP_STACK_RTOS_DELAY

- Use Heap Config:

  - Type of heap that the TCP/IP stack uses: internal heap, internal pool or external
  - This is a private TCP/IP heap and is used by internal stack modules that need dynamic memory (and most of them do): MAC buffers/packets, TCP and UDP buffers, etc.
  - Notes:
    - The internal heap provides reasonably fast allocation using a first fit algorithm So its allocation is memory efficient but can suffer of fragmentation issues.
    - The internal pool is very fast but works with fixed sizes. So the allocation may be not very memory efficient but there is no fragmentation. The pool creates blocks with different sizes that need to be defined separately. The initial pool configuration may be difficult. This pool works best when the pool entries can be increased at run time with new allocations.
    - The external heap relies on allocation functions provided to the stack (like the standard C malloc/calloc/free functions)
  - Default value: TCPIP_STACK_HEAP_TYPE_INTERNAL_HEAP
  - Symbol TCPIP_STACK_USE_HEAP_CONFIG (TCPIP_STACK_HEAP_TYPE_INTERNAL_HEAP, TCPIP_STACK_USE_EXTERNAL_HEAP, TCPIP_STACK_USE_INTERNAL_HEAP_POOL)

- TCP/IP Stack Dynamic RAM Size:

  - The total amount of internal dynamic memory heap that the TCPIP stack will create at start up.
  - This is the size of the internal heap, relevant only for the TCPIP_STACK_USE_INTERNAL_HEAP
  - Note: a small amount of memory is used for internal heap structure.
    - So the actual size of the created heap will be smaller than this.
  - Note: the settings in other modules configuration parameters (especially the MAC driver, TCP, UDP, HTTP, etc.) should be consistent with the total amount of heap that is allocated to the stack.
  - Note: this parameter should also be consistent with the project linker heap setting ( TCPIP_STACK_DRAM_SIZE < project heap)
  - Note: the above notes apply for the TCPIP_STACK_USE_INTERNAL_HEAP_POOL selection too.
    - However, for the pool heap this symbol is not used because the total memory that results from adding up all the pool entries plus the storage needed for internal heap structures.
  - Default value: 39250
  - Symbol TCPIP_STACK_DRAM_SIZE

- The Expansion Size for the Internal Heap Pool:

  - The size of the expansion heap for a TCPIP_STACK_USE_INTERNAL_HEAP_POOL
  - This is the amount of heap allocated besides the size resulting from the pool entries and allows expanding at run time.
  - How a specific entry expands is controlled per entry
  - If set to 0, then there is no expansion at run time.
  - Note: this parameter is specific for TCPIP_STACK_USE_INTERNAL_HEAP_POOL
  - Note: this parameter allows the auto configuration of the pool at run time
  - Default value: 4096
  - Symbol TCPIP_STACK_POOL_EXPANSION_SIZE

- Number of Heap Pool Entries:

  - Number of pool entries that the pool will contain (this cannot be changed after the creation)
  - Default value: 8
  - Symbol TCPIP_HEAP_POOL_ENTRIES_NUMBER

- Size of the Block, Bytes:

  - Size of the blocks in this pool entry
  - Default value: 64 - 2064
  - Symbol TCPIP_HEAP_POOL_ENTRY_SIZE_IDXn

- Number of Blocks to Dynamically Expand for this Pool Entry:

  - Number of blocks to expand/allocate when an allocation in this entry failed
  - Default value: 0 - 10
  - Symbol TCPIP_HEAP_POOL_ENTRY_EXP_BLOCKS_IDXn

- Stack allocation function, malloc style:

  - Stack allocation function, malloc style
  - This is the function the stack will call to allocate memory needed for its own heap: TCPIP_STACK_DRAM_SIZE.
  - Note: if running under an RTOS environment and the stack is initialized at run time, the allocation function should be thread safe
  - Default value: "malloc"
  - Symbol TCPIP_STACK_MALLOC_FUNC

- Stack allocation function, calloc style:

  - Stack allocation function, calloc style
  - This is the function the stack will call to allocate memory needed for its own heap: TCPIP_STACK_DRAM_SIZE.
  - Note: if running under an RTOS environment and the stack is initialized at run time, the allocation function should be thread safe
  - Default value: "calloc"
  - Symbol TCPIP_STACK_CALLOC_FUNC

- Stack deallocation function, free style:

  - Stack deallocation function, free style
  - This is the function the stack will call for freeing the allocated memory when the stack is deinitialized.
  - Default value: "free"
  - Symbol TCPIP_STACK_FREE_FUNC

- Flags supported for heap allocation: -TCP/IP heap allocation flags

  - Default value: "TCPIP_STACK_HEAP_FLAG_ALLOC_UNCACHED"
  - Symbol TCPIP_STACK_HEAP_USE_FLAGS

- Heap area usage:

  - Definition of the heap usage/purpose.
  - It defines what modules in the TCP/IP stack will use this heap.
  - Notes:
    - This is an advanced definition that is currently not used.
    - Multiple heaps usage will be added in the future.
    - For now only one heap type is supported and its used for all allocation operations.
  - Default value: TCPIP_STACK_HEAP_USE_DEFAULT
  - Symbol TCPIP_STACK_HEAP_USAGE_CONFIG

- Maximum heap types:

  - Number of heap types at run time to enable debugging, statistics, trace on, etc.
  - Currently only 1 heap type is supported at run time, one of: internal heap, internal pool and external
  - Default value: 1
  - Symbol TCPIP_STACK_SUPPORTED_HEAPS

- TCP/IP Stack Dynamic RAM Lower Limit:

  - The minimum amount of dynamic memory left for run time allocation by the stack (IP, UDP, etc)
  - This is just a warning threshold.
  - If after all the modules are initialized the amount of memory available in the TCPIP heap is less then TCPIP_STACK_DRAM_RUN_LIMIT then a warning will be displayed (if the debug channel is enabled)
  - For proper operation there should be always a heap reserve of at least few KB.
  - Note: this limit is used only for TCPIP_STACK_USE_INTERNAL_HEAP and TCPIP_STACK_USE_INTERNAL_HEAP_POOL
  - Default value: 2048
  - Symbol TCPIP_STACK_DRAM_RUN_LIMIT

- TCP/IP Stack Dynamic Allocation Debug:

  - Enable debugging of an allocation call that failed.
  - If the system debug is enabled (SYS_DEBUG_ENABLE) the stack will issue a warning message at the system debug channel.
  - Default value: false
  - Symbol TCPIP_STACK_DRAM_DEBUG_ENABLE

- TCP/IP Stack Dynamic Allocation Trace:

  - Enable tracing of the allocated memory by each module.
  - The stack will trace all the memory allocated by a module and various statistics.
  - Default value: false
  - Symbol TCPIP_STACK_DRAM_TRACE_ENABLE

- TCP/IP Stack Number of Trace Slots:

  - Number of trace slots to be used.
  - There is on slot needed per module that allocates memory from the heap.
  - Default value: 16
  - Symbol TCPIP_STACK_DRAM_TRACE_SLOTS

- TCP/IP Heap Size Estimate(in kilobytes):

  - An estimation of the TCP/IP stack heap requirements based on the project settings
  - Default value: 39250
  - Symbol TCPIP_STACK_HEAP_SIZE_RECOMMEND

- Module-wise Heap Estimate(show with each module):

  - Show heap estimation for each stack module
  - Default value: false
  - Symbol TCPIP_STACK_HEAP_CALC_MASK

- Enable User Notification:

  - This setting enables the reporting of the events by the stack to the user using the notification system
  - If enabled, then TCPIP_STACK_HandlerRegister and TCPIP_STACK_HandlerDeregister functions are compiled in and can be used
  - If disabled, these functions do not exist and cannot be used/called
  - Relevant only when TCPIP_STACK_USE_EVENT_NOTIFICATION is enabled
  - Default value: false
  - Symbol TCPIP_STACK_USER_NOTIFICATION

- Enable Stack Deinitialize Operations:

  - This setting enables the TCPIP_STACK_Deinitialize() operation
  - If this symbol is false, then the TCPIP_STACK_Deinitialize is not built in
  - Useful when stack stop and restart is not needed at run time - smaller code footprint for the TCP/IP stack.
  - Notes:
    - The TCP/IP stack can be initialized as usual (TCPIP_STACK_Initialize) but it cannot be stopped and restarted
    - None of the TCP/IP modules (except the MAC and PHY, see below) will have the corresponding Deinitialize function built in
    - If the stack initialization failed (i.e. the TCPIP_STACK_Initialize returned SYS_MODULE_OBJ_INVALID or TCPIP_STACK_Status returns SYS_STATUS_ERROR) the stack modules cannot be used and the application should not make any attempt to call their API!
  - Default value: true
  - Symbol TCPIP_STACK_DOWN_OPERATION

- Enable IF Up/Down Operations:

  - This setting enables the TCPIP_STACK_NetUp/TCPIP_STACK_NetDown operations
  - When enabled, these functions are built in and can be used by an app
  - Useful when interfaces do not need restarting at run time - results in smaller code footprint.
  - Note:
    - Combination TCPIP_STACK_DOWN_OPERATION == false and TCPIP_STACK_IF_UP_DOWN_OPERATION == true is invalid and must not be used otherwise the behavior is undefined!
  - Default value: true
  - Symbol TCPIP_STACK_IF_UP_DOWN_OPERATION

- Enable MAC Down on Failure:

  - This setting specifies the behavior of stack regarding the MAC and PHY drivers when the TCPIP_STACK_DOWN_OPERATION == false in the situation where the stack initialization failed and the stack cannot be started.
  - If true, the MAC (and the corresponding PHY) TCPIP_MAC_Deinitialize will be called.
    - This operation is supposed to exist and this setting will conserve power.
  - If false, the TCPIP_MAC_Deinitialize will not be called and the code footprint could be smaller.
    - The TCPIP_MAC_Deinitialize operation, which is expensive, could be unimplemented.
  - Note: the TCPIP_STACK_MAC_DOWN_OPERATION == false could be set only when TCPIP_STACK_DOWN_OPERATION == false! Otherwise the behavior is undefined!
  - Default value: true
  - Symbol TCPIP_STACK_MAC_DOWN_OPERATION

- Enable Interface Address Change Signaling:

  - This setting enables/disables the stack signaling when an interface address changes
  - This could be triggered by the DHCP kicking into action, by ZCLL or other address service, or simply by the user changing the IP address of an interface
  - If it is enabled, the socket modules (UDP, TCP) will be notified and they will disconnect their sockets that are currently connected on that interface that has changed.
  - User can be notified by registering an event handler either with socket events or with the general stack signaling mechanism
  - Default value: false
  - Symbol TCPIP_STACK_INTERFACE_CHANGE_SIGNALING

- Enable Configuration Save/Restore Functionality:

  - This setting enables the configuration get/set operations: TCPIP_STACK_ModuleConfigGet, TCPIP_STACK_NetConfigGet, TCPIP_STACK_NetConfigSet
  - If true, the functionality is built in and could be used by the application
  - If false, these functions do not exist and the generated code is smaller
  - Default value: true
  - Symbol TCPIP_STACK_CONFIGURATION_SAVE_RESTORE

- Number of entries in the secure port table:

  - The number of entries in the internally maintained secure port table
  - This table is populated at stack initialization with default well-known port values
  - Currently this number should be >= 10
  - Default value: 10
  - Symbol TCPIP_STACK_SECURE_PORT_ENTRIES

- Enable Alias Interfaces Support:

  - Enable support for alias interfaces
  - An alias interface uses the physical interface of another network interface.
  - It allows multiple IP addresses for a host on the same interface, for example.
  - Default value: false
  - Symbol TCPIP_STACK_ALIAS_INTERFACE_SUPPORT

- Enable Packet Logger:

  - Enable the packet logger
  - Simple module that logs the packets as they fly through the stack from creation until acknowledged
  - Note: the logger supports console commands for selecting logging modules/sockets
  - Default value: false
  - Symbol TCPIP_PACKET_LOG_ENABLE

- Number of Entries in the Packet Logger:

  - Number of log entries, if the packet logger is enabled
  - Each entry takes approx 24 bytes
  - Default value: 40
  - Symbol TCPIP_PKT_LOG_SIZE

- Enable External Packet Processing:

  - This setting enables/disables the processing of the RX packets by an external handler
  - The user of the stack can register an external function to process the incoming packets
  - If true, the functionality is built in and could be used by the application
  - If false, the functionality does not exist and the generated code is slightly smaller
  - Default value: false
  - Symbol TCPIP_STACK_EXTERN_PACKET_PROCESS

- Enable Stack Initialization Callback:

  - This callback is part of the initialization data that is passed to the stack at initialization
  - If the callback is NULL, then the stack initialization will proceed immediately with the data presented in the TCPIP_STACK_INIT. -If the callback is not NULL, then the initialization of the stack will be delayed and it will be performed in the TCPIP_STACK_Task() function.
  - The TCPIP_STACK_Task() will keep calling the callback function until this returns ready or an error condition.
  - Default value: false
  - Symbol TCPIP_STACK_ENABLE_INIT_CALLBACK

- Stack Initialization Callback Function:

  - Name of the initialization callback function
  - Default value: "TCPIP_STACK_InitCallback"
  - Symbol TCPIP_STACK_INIT_CALLBACK

- Number of Network interfaces:

  - Number of Network interfaces that are part of the project
  - Default value: 1
  - Symbol TCPIP_STACK_NET_INTERFACE_NUM

- Interface Name:

  - Name of the network interface
  - Default value: ""
  - Symbol TCPIP_STACK_NET_INTERFACE_NAME_IDXn

- Internal MAC?:

  - Use the internally built in MAC for this interface
  - Default value: false
  - Symbol TCPIP_STACK_INT_MAC_IDXn

- PHY Interface:

  - The MAC <-> PHY interface to use for this network interface
  - Default value: ""
  - Symbol TCPIP_STACK_MII_MODE_IDXn

- External Interface:

  - Setting the network with an external interface
  - Default value: ""
  - Symbol TCPIP_STACK_OTH_INT_IDXn