stna,
Here's my understanding of PSoC resource allocation and management. If my understanding is correct, the following might shed some light on your issue.
There are 3 methods to allocated and manage resources on the PSoC.
Device Configuration
This is the method closest to the TopDesign schematic entry process used in PSoC Creator.
It is a high-level tool provided by Infineon to make configuring all IO and internal peripherals theoretically easier.
It is intended as design-time tool. In other words, at the time of the design and development the HW and FW application designers define what resources are needed by the application including what pins are to be used to match the PCB layout requirements.
This method is generally considered "hard-coding" the assignments since dynamically reassigning fixed peripheral resources at run-time can be complicated (but not impossible). Because of the "hard-coding" at design-time, it makes this method the easiest and lowest maintenance in the cost as long as the peripherals and IO do not need to be dynamically reassigned.
To start this configuration in main() is usually just one function call. Simple.
HAL API calls
The HAL (Hardware Application Layer) calls are the lowest level access of all peripherals and IO pins. It has as a part of infrastructure knowledge of what PSoC resources are available. Any attempts to to allocate/deallocate resources not available will yield error codes. These error codes need to be monitored and handled properly to avoid failures of running the application.
With HAL calls, resources are allocated and can be deallocated as needed. This makes dynamic run-time reconfiguration of the PSoC possible and more reliable.
PDL API calls
The PDL (Peripheral Device Library) calls are one-level higher than the HAL calls. It is intended to provide the advantages of the HAL configuration flexibility while making the calls to the resources easier by commonly grouping peripheral and IO assignments in fewer API calls.
Generally, the user is encouraged to use PDL calls instead of HAL calls if possible. PDL calls internally call the needed HAL calls for the resources needed without the developer needing to know all the details needed at the HAL-level.
As with the HAL, the PDL has the flexibility of dynamically reallocation of resources at run-time.
Additionally, the error codes returned in the PDL functions should be acted on appropriately and should not be ignored.
What method is best to use?
In general, Device Configuration is the simplest and most straightforward. However the design intent of the resources are only available using the Device Configuration utility. Therefore this method works best if the resources are only defined at design-time.
Both the PDL and HAL methods allow you to define the design intentions as comments in the source code at the location of the allocation/and reallocation code sections. Because resource allocation is explicit in the application code, this allows for "better?" conditional compiling of resource allocation based on compile #defines.
Note: It is possible to use ALL the 3 methods in your code. To do so, you show be more aware of how each method manages the resources.
It might be said by others with more experience here that using RTOSs the PDL/HAL methods might be more preferred. This may be because the peripheral resources used by a task are allocated when the task is started. This may allow for lower current consumption because resources are started when needed and stopped when not needed.
Back to your issue with the stack
As you indicated your code worked prior to using Device "Configuration" method.
It is possible that the init_cycfg_all() call uses more stack because it is allocating the resource defined in the tool.
This might be the reason the use of the stack is larger.
Len
"Engineering is an Art. The Art of Compromise."
