Skip navigation
Home > All Places > ModusToolbox > Blog
1 2 Previous Next


22 posts

Our friend, Matt Mielke at Dig-Key, just wrote a really good blog about using CMSIS-DSP on PSoC 6. It is one of those really good articles that just gets on with the job of describing the subject without a load of unnecessary, showy-offy acronyms and buzzwords. I really liked it and recommend you give it a read. Unless you really like slow math in your programs. Ok, then... good luck with that.

I liked that it methodically explains what the library does and how it helps, uses the CMSIS-PACK plug-in that ships with ModusToolbox to install the library, then adds it to the project and sets the include path up. In case you have never seen it, here is an image showing the Pack Manager after the library has been installed - it is a great way to install libraries and keep them up to date.

CMSIS Pack Manager installing CMSIS-DSP in ModusToolbox

I only thought of one thing I would add to the article. Matt explains the difference between hardfp and softfp libraries, and points out that you cannot mix-and-match them. But I'd also add that you need to remember that when choosing other middleware for your application. Here is a picture of the ModusToolbox Middleware Selector... notice the CapSense and Segger emWin entries that list a Hard FP and Soft FP implementation... you need to make sure all those match your DSP library selection.

Hard and Soft FP libraries in ModusToolbox Middleware Selector

Did you finish reading it yet? Good, wasn't it?


Mbed OS 5.13.1 released

Posted by MarkS_11 Jul 18, 2019

Arm announced a patch release of Mbed OS yesterday. It is version 5.13.1 and it adds a few interesting items for PSoC users. The big change is a new Wi-Fi Host Driver (WHD), which replaces the monolithic build of our WICED stack used in previous releases with a smaller footprint, more flexible driver that will save memory in your applications and make it easier to support your own target boards. There is also a USB peripheral driver, which extends the choices you have for wired connectivity, and a new Cypress HAL that complements the C++ Mbed peripheral driver interface with an efficient, Mbed-friendly set of drivers in the C language. Lovely!

One of the nice things about an online ecosystem like Mbed is that you do not need to go through a lengthy installation process to get the new software. Simply creating a new application in Mbed CLI ("mbed new my-super-new-application") will pull in the latest and greatest version of Mbed OS. You can then confirm the OS version by running "mbed ls". Here is the output from my Mbed CLI session where I create and build a new application.

yfs@YFS-T550 MINGW64 ~/mbed4

$ mbed new my-super-new-application

[mbed] Working path "C:\Users\yfs\mbed4" (directory)

[mbed] Program path "C:\Users\yfs\mbed4"

[mbed] Creating new program "my-super-new-application" (git)

[mbed] Adding library "mbed-os" from "" at branch/tag "latest"

[mbed] Updating reference "mbed-os" -> ""

yfs@YFS-T550 MINGW64 ~/mbed4

$ cd my-super-new-application

yfs@YFS-T550 MINGW64 ~/mbed4/my-super-new-application (master)

$ mbed ls

[mbed] Working path "C:\Users\yfs\mbed4\my-super-new-application" (program)

my-super-new-application ( revision in the current branch)

`- mbed-os (#5941d1718339, tags: latest, mbed-os-5.13.1)

yfs@YFS-T550 MINGW64 ~/mbed4/my-super-new-application (master)

$ cp ../main.cpp .

yfs@YFS-T550 MINGW64 ~/mbed4/my-super-new-application (master)

$ mbed compile --target CY8CKIT_062_WIFI_BT --toolchain GCC_ARM

Building project my-super-new-application (CY8CKIT_062_WIFI_BT, GCC_ARM)

Scan: my-super-new-application

Compile [  0.1%]: mbed_tz_context.c

Compile [  0.2%]: MCR20Drv.c

Compile [  0.3%]: at24mac.cpp

Compile [  0.4%]: NanostackRfPhyAtmel.cpp

Compile [  0.5%]: NanostackRfPhyMcr20a.cpp

Compile [  0.6%]: rf_configuration.c

Compile [  0.7%]: fslittle_test.c

Compile [  0.8%]: main.cpp

<Lots of compilation - deleted!>

Compile [ 99.7%]: USBSerial.cpp

Compile [ 99.8%]: OperationListBase.cpp

Compile [ 99.9%]: PolledQueue.cpp

Compile [100.0%]: TaskBase.cpp

Link: my-super-new-application

Elf2Bin: my-super-new-application

Post-Build: my-super-new-application

| Module           |         .text |       .data |        .bss |


| [fill]           |       80(+80) |       9(+9) |     35(+35) |

| [lib]\c.a        | 16696(+16696) | 2472(+2472) |     89(+89) |

| [lib]\gcc.a      |   3168(+3168) |       0(+0) |       0(+0) |

| [lib]\misc       |     224(+224) |       4(+4) |     28(+28) |

| [misc]           |         0(+0) |       0(+0) |       0(+0) |

| main.o           |     192(+192) |       0(+0) |       4(+4) |

| mbed-os\drivers  |       74(+74) |       0(+0) |       0(+0) |

| mbed-os\features |     204(+204) |       0(+0) |     48(+48) |

| mbed-os\hal      |   1248(+1248) |       4(+4) |     67(+67) |

| mbed-os\platform |   2892(+2892) |   260(+260) |   220(+220) |

| mbed-os\rtos     |   6468(+6468) |   168(+168) | 5973(+5973) |

| mbed-os\targets  | 17578(+17578) |   107(+107) | 1236(+1236) |

| Subtotals        | 48824(+48824) | 3024(+3024) | 7700(+7700) |

Total Static RAM memory (data + bss): 10724(+10724) bytes

Total Flash memory (text + data): 51848(+51848) bytes

Image: .\BUILD\CY8CKIT_062_WIFI_BT\GCC_ARM\my-super-new-application.hex

[mbed] Working path "C:\Users\yfs\mbed4\my-super-new-application" (program)


Note that, after creating the application, I I just copy in a simple blinky application (main.cpp) to the my-super-new-application folder. Here is the code for that... isn't it super!?!


/* mbed Microcontroller Library
* Copyright (c) 2018 ARM Limited
* SPDX-License-Identifier: Apache-2.0

#include "mbed.h"

DigitalOut led1(LED1);

#define SLEEP_TIME_MS 500

// main() runs in its own thread in the OS
int main()
    while( true )
        // Blink LED and wait 0.5 seconds
        led1 = !led1;
        wait_ms( SLEEP_TIME_MS );



Task-Aware Debugging

Posted by MarkS_11 Jun 30, 2019

I was asked a question last week about multi-threaded debugging in ModusToolbox IDE. I knew there was a plug-in for that but I had never used it. So I gave it a shot and here's how you can enable task-aware debugging with the FreeRTOS kernel.

It turns out that you do not need to install the plug-in - it is already there - but you do need to enable it for OpenOCD. I did that in the file ModusToolbox_1.1\tools\openocd-2.1\scripts\target\psoc6_common.cfg. On line 228, make this addition:

${TARGET}.cm4 configure -rtos auto -work-area-phys $_WORKAREAADDR_CM4 -work-area-size $_WORKAREASIZE_CM4 -work-area-backup 0

The "auto" is taken to mean FreeRTOS by the plug-in, but you can use "-rtos FreeRTOS" if you prefer to be explicit. Next you need to define a variable that the plug-in expects (but is no longer defined in FreeRTOS). I just created a global variable like this:

static volatile int uxTopUsedPriority;

Then, in main(), I use the variable to make sure it is not optimized out by the compiler.

uxTopUsedPriority = configMAX_PRIORITIES - 1;

All I needed now was a project to debug. I created one from the PioneerKitAppFreeRTOS template and made a copy of the "blinky" task (so my application would be slightly more interesting). When I run the debugger and hit a breakpoint in one of the blinky functions, the Quick Panel Debug tab looks like this, which make it really easy to figure out what tasks are in the application and which one I am debugging.

Task-Aware Debugging in ModusToolbox IDE

Now, there is one slight problem with this... it breaks debugging of non-FreeRTOS applications! Oopsy! The reason for this is that the "-rtos auto" causes the debugger to look for missing symbols when you are not using the RTOS. I fixed this by making copies of psoc6.cfg and psoc6_common.cfg (called psoc6_rtos.cfg and psoc6_common_rtos.cfg) in the target folder above. In the psoc6_rtos.cfg file I edited the last line as follows:

source [find target/psoc6_common_rtos.cfg]

In the original psoc6_common.cfg file I backed out the edit so that this file is returned to its original state. Now I have RTOS and non-RTOS config files and, by default, the launch configuration for your projects will use the non-RTOS setup. However, when I do want to enable multi-thread debugging, I just edit the Debug Configuration (Run menu) to use the new files instead. In the Debugger tab there is a filed for Config Options and I change the config file as follows:

-c "source [find target/psoc6.cfg]"

Here is an image of that change.

Enabling Task-aware Debugging in ModusToolbox IDE


I am really happy with this discovery. I can now enable task-aware debugging for a project in just a couple of minutes. I think it will become a standard practice for me. I hope you like it too! I attached my config files so you can just copy them into the target folder, rather than edit the installed IDE files (remember to log into to access them).


PWM Clock Sharing

Posted by MarkS_11 Jun 27, 2019

Did you finish your homework? Well, here's an answer anyway. A couple of days ago I used a pair of TCPWM blocks to toggle the brightness of an LED at 1Hz. In that project I used an 8-bit clock divider as the source for the LED-driving PWM and a 16-bit divider for the slower toggling Timer-Counter. It worked just fine but it felt a little decadent to use two clock dividers when I am using a PSoC, which has the on-chip flexibility to use one divider for both TCPWM blocks. How to do that?

Well, the easy part is changing the clock source selection in the Timer-Counter using the Device Configurator. Open the project in ModusToolbox IDE and open the Configurator. In the SWAP_CTR block change the Clock Signal to "8 bit Divider 2 clk", which is marked in the drop-down as "USED" as a reminder that another resource is using that source (obviously... this is why we are choosing it!).

Choosing a USED PSoC clock divider

Next, there is a little mathematics, which is the English word for math. The frequency of the TCPWM output is a function of the peripheral clock (CLK_PERI) frequency, the 8 but divider value, the TCPWM prescaler (which I hinted at last time) and the period of the TCPWM counter. In pseudo-math (note that it is OK to call it math when it's "pseudo" - just because I am a snob does not mean I am not really lazy as well) it looks like this.


LED frequency =  ----------------------------

divider * prescaler * period

Some of these are known (or the pseudo-math becomes "guessing"). The LED toggling frequency needs to be 1Hz. The CLK_PERI is set to 72MHz in the Platform tab of the Device Configurator and let's leave that alone. For the others, the divider is a 8-bit value, the period is 16-bit, and the prescaler is 1, 2, 4, 8, 16, 32, 164 or 128. The trick we have to perform is to divide and prescale CLK_PERI such that the TCPWM period gives us 1Hz, preferably with a nice round number. Here is the rearranged formula.

divider * prescaler * period = 72000000

The 16-bit TCPWM has a maximum period of 65535, which means the clock must be divided by at least 1098.6, which cannot be done in a 8-bit divider. So we need to use a prescaler value of at least 8. Beyond that there are gabillions of combinations that satisfy the equation. After a little trial and error, well mostly error, I figured out that a divider of 225 works really nicely because it creates a frequency of 320kHz. Precaling that by 32 gives me a TCPWM frequency of 10kHz and a period of 10000 gives me a 1Hz output. Et voila!

Dividing and prescaling the PSoC clock frequency

Here is the set up for the Timer-Counter, with the prescaler and period set as above.

Setting the PSoC Timer-Counter period and prescaler

Note that the LED_PWM just has to toggle fast enough not to flicker so I set the period to 1000 and the compare values to 500 and 50 for the 50% and 5% intensity values.

I had quite a lot of fun doing this project. I think it nicely illustrates how flexible PSoC is and how wretched my mathematics skills are. I've attached a template that you can use to replicate the design - to use it, open the New Application dialog and "Import..." the file to create a copy of the project.

Importing the project template into ModusToolbox IDE

Note: you must be logged into to see the attachment (


Internally-Triggered PSoC PWM

Posted by MarkS_11 Jun 26, 2019

I got "back on the blog" about a week ago and wrote about configuring PWMs and hooking them up to LEDs. It was simple stuff but hopefully got us all up to speed on configuring peripherals and connecting them to pins. Today I want to extend that learning a little bit and use one TCPWM block to control another. Wooooooo! Scary stuff! Not really.

I also mentioned last time that the TCPWM supports two compare values, which is why I suggested you play with the duty cycle using the SetCompare0() function. Yes, there is also a SetCompare1(). Genius! So I propose to set up the PWM with two compare values, giving us a bright and a dim LED. Then I will periodically switch between the two values to prove that it all works. As with cat-skinning, there are many ways to do this. Here are three that come to mind (all of them assume you have set up a 16-bit PWM, called LED1_PWM, to drive an LED as in my previous blog).

  1. Modify the compare value from firmware
  2. Set up two compare values and switch between them from firmware
  3. Set up two compare values and use another TCPWM to switch between them

Let's walk through all three methods, starting with the firmware. Remember that LED1_PWM has a period of 32767 and a compare value of 16384, and that it is turned on with the following code in main().


Cy_TCPWM_PWM_Init(     LED1_PWM_HW, LED1_PWM_NUM, &LED1_PWM_config );


Cy_TCPWM_TriggerStart( LED1_PWM_HW, LED1_PWM_MASK );


That gives us a fairly bright LED (actually 50% of maximum) and so, in the main loop, add these two lines of code.




Cy_TCPWM_PWM_SetCompare0( LED1_PWM_HW, LED1_PWM_NUM, 1638 ); // 5%

Cy_SysLib_Delay( 500 );

Cy_TCPWM_PWM_SetCompare0( LED1_PWM_HW, LED1_PWM_NUM, 16384 ); // 50%

Cy_SysLib_Delay( 500 );



Program that code and you will see the LED switch between 50% and 5% brightness. But, let's face it, that is a fairly ugly solution because we are just jamming values into the PWM and spinning the CPU.Let's move onto the second method. Open up the Device Configurator and navigate to the setup for LED1_PWM. Check the Enable Compare Swap box, which causes the Compare 1 parameter to become editable, and set it to 1638.

Setting two compare values in the PSoC TCPWM

Save that change and go back to ModusToolbox IDE. Change the C code in the loop as follows.




Cy_TCPWM_TriggerCaptureOrSwap( LED1_PWM_HW, LED1_PWM_MASK );

Cy_SysLib_Delay( 500 );



This code causes the PWM to swap the compare value between the choices you made in the Configurator. It's a little neater than the first choice but I am still troubled by the spin loop.Let's just do it all in hardware. Go back to the Device Configurator and find the Swap Input parameter in the Inputs section. Choose Rising Edge from the drop-down menu. This selection enables the Swap Signal parameter. Use that drop-down to choose another TCPWM block - Counter 15 is a good choice because it is adjacent to the one we are already using (and so is easy to find - there is no technical advantage to a particular 16-bit TCPWM choice). Note that there are three connectivity options on the block - overflow, underflow and cc_match/capture/compare. I chose underflow so I can trigger the swap with a down-counter. All this sets up LED1_PWM to switch between Compare 0 and Compare 1 whenever there is a rising edge on the TCPWM #15 underflow signal.

Setting up the PSoC TCPWM compare value swap signal

The next step is to set up the new TCPWM block. I chose the Timer-Counter personality - I do not need it to be a PWM because I just want the terminal condition to cause the trigger - and called it SWAP_CTR.

Choosing the Timer-Counter personality for the PSoC TCPWM

In the parameters, set the Count Direction to Down so it will underflow at the end of each cycle.

Setting the direction and period of the PSoC Timer-Counter

I want a 500ms period and so this means I need a pretty slow clock and I cannot do that with an 8-bit source divider. For the Clock Signal choose 16-bit Divider 1, jump the Peripheral-Clocks tab, and set the divider on that clock to 36000 (which give a 2kHz signal from the 72MHz source).

Setting the 16-bit divider on the PSoC Timer-Counter peripheral clock

Back in the TCPWM set the period to 1000 (shown above) and we have the desired triggering rate. Save the edits and return to the ModusToolbox IDE.First of all, remove ALL the code from the for(;;) loop - this is hardware only! Then enable the new counter as follows.


Cy_TCPWM_PWM_Init(       LED1_PWM_HW, LED1_PWM_NUM, &LED1_PWM_config );


Cy_TCPWM_Counter_Init(   SWAP_CTR_HW, SWAP_CTR_NUM, &SWAP_CTR_config );




There are three things to note about this code.

  1. The APIs are slightly different - i.e. Cy_TCPWM_Counter_Init intead of Cy_TCPWM_PWM_Init - but the arguments are the same.
  2. There is only one call to the TriggerStart() function because both counters are in the same block (i.e. LED1_PWM_HW == SWAP_CTR_HW).
  3. TriggerStart() acts upon the ORed masks of the two TCPWM blocks.

Programming this should cause the LED to swap states automatically without any SW intervention. I think you'd agree that it is a cleaner, more efficient solution. The only remaining problem I have with this is that I am being a little greedy with the clocks. I'd really like to use just one 8-bit clock source, as opposed to one 8- and one 16-bit divider. So I will leave you a little homework... try to change the settings in the Device Configurator to use just one clock for the TCPWMs. I'll post a solution in a day or two (assuming I can actually get it to work!).

Hint - there is a Clock Prescaler in the TCPWM blocks which can be used to slow down the input clock speed.

Back in February I committed to write about peripheral setup using the ModusToolbox device configurator tool. I have not done very well! We have had another release since then - ModusToolbox 1.1 - and I have been buried in planning for the 2.0 release and training our internal teams. But that is real work and I've had enough of it. It's time to get back to writing about PSoC and developing cool applications.

But first a word or two about a change in the project structure for PSoC applications between the 1.0 and 1.1 releases. In 1.0 we created five projects for a single application; one each for the CM4 and CM0+ cores, one each for the PDL libraries for each core, and one for the configuration. Early feedback was that this was confusing and difficult to manage and so we re-jigged things in the 1.1 software. We also found that most engineers do not use the CM0+ core in real applications because they prefer the faster (more power efficient) CM4 and the simplicity of single-core development. As a result, by default, we now only create the CM4 project and leave the CM0+ to the experts. That removed two of the required projects, which was a good start. Next, we realized that there is no longer any point having a separate configuration project, so we moved the design.modus file into the CM4 project and put all the generated source into a local folder, instead of a link to another project. The result is a major usability improvement. You get the application project, where you do all the work, and a library project, which you typically never edit - just build once and link. Another benefit of this is that the library project can be linked to any number of a applications. The first application you create in a new workspace will have a library project but, if you then create more applications they default to sharing the original library. I find this really helps me manage projects and I only rarely have to change, or create new, workspaces.

In previous posts I have written about creating applications, starter templates for single-threaded and FreeRTOS applications, and doing some basic things like twiddling LEDs and reacting to button presses. Note that in the post about <here all the generated code goes I wrote about the GeneratedSource folder being in the configuration project. Obviously, if you are using ModusToolbox 1.1 that folder is now in the main application project.

OK, that's enough housekeeping about releases. We've all got v1.1 right! Good, let's modify a start project to set up a peripheral. You all know how to do this by now (check out the links above if you need a reminder) so create a new application using the PioneerKitApp starter template. This template has the buttons and LEDs configured for us so we do not need to repeat all that work.

Open the device configurator (click on "Configure Device" in the Quick Panel or double-click on design.modus) and look for KIT_LED1 in the Pins tab. Click on the Digital Output internal connection and choose the 16-bit TCPWM.

Choosing a PWM to drive the LED



Now click on the chain button to jump to the TCPWM.

LED driven from PWM 14 in block 1

Note that it is in block 1, which contains 24 16-bit TCPWMs (block 0 are the 32-bit TCPWMs - that's overkill for this application). Click on the checkbox to enable the peripheral and give it a name - "LED1_PWM".

Enable the TCPWM and give it an alias to make C code easier to write

Notice the configuration panel that appeared when you enabled the peripheral. It has set the Period to the maximum value (32768) and the Compare to 50% of that (16384). Those are good starting conditions - the LED will "glow" at 50% of maximum intensity. You can also see that the PWM_n signal is connected to KIT_LED1, which is a useful confirmation.

Configuration panel showing the period and compare values

The last edit is to set up a source clock, which follows a very similar path to what we just did. Click on the Clock Signal, under Inputs, and choose "8 bit Divider 2 clk". In the pull-down you will see all the other clocks that are set up by the template. You could reuse one of those if you wish to share the resources, but this is a simple application that will only use a fraction of available resources so I am keeping things simple. Click on the chain to jump to the clocks tab. Notice that the clock is enabled for you, with a divider of 1, giving a 72MHz frequency for the counter. That's plenty o' Hertz! Save the changes and exit the configurator.

In the GeneratedSource/cycfg_peripherals.h file you will find these new defines that we will use to start the PWM.


#define LED1_PWM_NUM 14UL

#define LED1_PWM_MASK (1UL << 14)

In cycfg_peripherals.c there is a configuration struct. All those PWM options are really impressive but I am glad I do not have to set them up by hand!

const cy_stc_tcpwm_pwm_config_t LED1_PWM_config =




.pwmAlignment = CY_TCPWM_PWM_LEFT_ALIGN,

.deadTimeClocks = 0,


.period0 = 32768,

.period1 = 32768,

.enablePeriodSwap = false,

.compare0 = 16384,

.compare1 = 16384,

.enableCompareSwap = false,

.interruptSources = CY_TCPWM_INT_NONE,




.swapInputMode = LED1_PWM_INPUT_DISABLED & 0x3U,

.swapInput = CY_TCPWM_INPUT_0,

.reloadInputMode = LED1_PWM_INPUT_DISABLED & 0x3U,

.reloadInput = CY_TCPWM_INPUT_0,

.startInputMode = LED1_PWM_INPUT_DISABLED & 0x3U,

.startInput = CY_TCPWM_INPUT_0,

.killInputMode = LED1_PWM_INPUT_DISABLED & 0x3U,

.killInput = CY_TCPWM_INPUT_0,

.countInputMode = LED1_PWM_INPUT_DISABLED & 0x3U,

.countInput = CY_TCPWM_INPUT_1,


Add these lines to your main() function (in Source/main.c) before the for loop.

    Cy_TCPWM_PWM_Init(     LED1_PWM_HW, LED1_PWM_NUM, &LED1_PWM_config );

    Cy_TCPWM_TriggerStart( LED1_PWM_HW, LED1_PWM_MASK );

    Cy_TCPWM_PWM_Enable(   LED1_PWM_HW, LED1_PWM_NUM );

Notice that the trigger function works on all 24 TCPWMs in the block, and so we pass a MASK argument, not the individual TCPWM number. LED1_PWM_MASK is just a 1 shifted left by LED1_PWM_NUM and so you can see how to control and synchronize the triggering of individual TCPWMs by ORing the masks.

When you build and program the application into your Pioneer kit the LED should glow quite brightly. This is because a 50% duty cycle is almost as bright as 100% to our eyes. Even your young ones! A household mirror reflects about 50% of the light that hits it and your reflection does not appear especially dim! So play with the duty cycle to reduce the brightness. You can do this by editing the compare value in the configurator or by calling the Cy_TCPWM_PWM_SetCompare0() function to change it your C code (use the Compare0 function because the PWM supports two period and compare values, which we will play with next time). If you have never done this before I think you will be surprised at how low the duty cycle has to be in order to really dim the LED.

I wrote about Zerynth just after the Embedded World show, where they gave a great demo of their Python virtual machine running an IoT demonstration on a PSoC Pioneer kit.

Like all good demos it was, in essence, really simple. They dropped a MikroE Weather Click board (with a Bosch BME280 humidity/pressure/temperature sensor) onto the Pioneer kit, read values over I2C into the PSoC application, which published the weather data to the cloud wirelessly whenever the CapSense button was pressed. Simple right? Yeah, of course it is simple - but only because Cypress has invested decades of R&D effort and millions of dollars into making the most robust and best performing CapSense and wireless solutions on the planet! But the demo is simple and the Zerynth stuff is cool.

Better still, late last week they formally announced the availability of the software in their excellent Zerynth Studio product. So go download it now!!!!

PSoC Pioneer kit running the Zerynth Python VM with a MikroE Arduino Uno shield and Weather Click sensor board

I am very excited about this collaboration. The Zerynth folk are really easy to work with and their excitement about the product is infectious. I think it has something to do with being young and Italian, and having perfect hair! When they are not making innovative products I imagine they just scoot around Pisa, on Vespas, calling out "ciao" to all the pretty people. Well, maybe that's just what I would do?

In case you hadn't figured it our yet, I've run out of things to write... I want to go learn Python and try it out on my Pioneer kit... and so should you... so get downloading and join the millennials by coding in Python. It'll make you feel years younger. And your hair will look good too.


Sharing My Eclipse Project

Posted by JimT_21 Apr 4, 2019

When in the course of a developer’s life it becomes necessary to share a project, an Eclipse IDE (and ModusToolbox IDE is no exception) is both helpful and confusing. The use case we’re talking about here is: “I want to pack up my project and send it to someone for them to see, use, or comment on.” A perfect example is when you have a support question and the support engineer asks you to send them the project.

Here’s how.


Before we get started....

  • Pro Tip #1: Before archiving, select the projects in the project explorer. Then they are automatically selected for the archive.
  • Pro Tip #2: When you archive a project, do not include the Debug folder. The IDE regenerates this information, you don’t need to include it. You will save many, many megabytes of space excluding the Debug folder.


To send someone your project, you create a project archive. Use File > Export and then choose General > Archive file. In the resulting dialog, you’ll see your projects and all their elements. Select the project you want to include. Expand it to see all the “stuff” in the project, and deselect the Debug folder. Browse to where you want it to be, give it a name, and click Finish.

Now, how about the other side of this equation. Someone sent you an archive. How do I get it into the IDE? This is where Eclipse is confusing.


To import projects from the file system, use File > Import and then General. See the screenshot below. There are several wizards to choose from, one of which is called Archive File. Hey, I just created an archive file, so that’s what I should import it, right? WRONG! Silly you for being that logical.  

Instead, use Existing Projects into Workspace. Your archive includes an existing project. So you are importing the existing project.


For Existing Projects into Workspace, you specify that this is an archive file. Browse to it and click Finish.


Finally, as an aside, this and many other Eclipse oddities are discussed in my Eclipse Survival Guide. If you're new to Eclipse, you may want to check it out.  Happy Eclipsing!

Hey ModusToolbox users.  This blog post is a follow-up to the post I recently made showing a WiFi Scanner using the Mbed->ModusToolbox flow. While that was meant as an introduction, this post will actually be a lot shorter. Basically, all I’ll cover here is how to use an example from the Cypress GitHub code example repository instead of Mbed’s.


I will be using the PSoC 6 Wi-Fi BT prototyping kit (CY8CPROTO-062-4343W).  But, you can also use the CY8CKIT-062-BLE or the CY8CKIT-062-WiFi-BT. You can use any Cypress kit supported in Mbed that has a CapSense slider on the board.


OK, I am going to assume you have already gone through that first blog post and have your ModusToolbox and Mbed environment all set up.  The first thing we need to do is go get the code example.  You can do that in a couple of ways.


1. Go directly to the GitHub location for ModusToolbox examples, which is here


2. From the ModusToolbox IDE Quick Panel, select “Search Online for Code Examples” like this

Either way, you’ll end up at this location.  Focus on the area labeled “Mbed OS Examples”.

I want the Mbed OS and CapSense example so I’ll click on that.  There are actually instructions on running this example right on that GitHub page, but I’ll repeat most of them here so you are not jumping back and forth.


3. Open up a Git Bash shell first (you can use a Cygwin terminal or a Windows cmd window, the instructions for setting up your environment will vary slightly).


4. Import the code example like this

mbed import

Depending network traffic, it may take a minute or two to copy the example over (it’s almost a Gb on disk).


5. Go to the example folder

cd mbed-os-example-capsense


6. Plug in your kit and ensure the kit is in DAPLink mode. See my earlier blog post or the Switch Kit to DAPLink Mode section in chapter 3 of the ModusToolbox IDE User Guide if you need more information on this.  For my kit, I press and hold SW3 for > 2 seconds.


7. Compile the example and program the board with the following command

mbed compile --target CY8CPROTO_062_4343W --toolchain GCC_ARM --flash --sterm

For other targets:

mbed compile -m CY8CKIT_062_WIFI_BT -t GCC_ARM -f –sterm

mbed compile -m CY8CKIT_062_BLE -t GCC_ARM -f --sterm

Note: -f is equivalent to –flash, -t is equivalent to --toolchain


OK, what is that –sterm option?  In my other examples I have used PuTTY or TeraTerm (you can still use those if you want).

The --sterm option opens a serial terminal set to 9600-8N1 on your the command window after programming completes. Obviously, leave this option out if you wish to connect using another serial terminal application.


8. After the kit is programmed and the program starts, you will see this message in your terminal window that looks something like this.

+++++++++++++++++++ Application has started. Touch any CapSense button or slider.


9. Touch the buttons and the slider to observe the red LED changing its state and to see the status of the various CapSense sensors printed in the terminal.  The messages in the terminal will look something like this.

10. You can also monitor the CapSense data using the CapSense Tuner application as described on the GitHub site or in this blog post.


That’s it for this post. Hit me up in the comments if you have questions.


Hello again Embedded Developers,


In this blog post I’ll introduce you to using the Mbed flow with ModusToolbox. The example design will scan for WiFi networks in range, print them to a tutorial, then connect to a WiFi network.  This article will cover


I. Setting up your environment

a. Install ModusToolbox 1.1

b. Install Cygwin (for Windows)

c. Install SRecord

d. Install/Configure the Mbed Command Line Interface (CLI)

e. Update PyOCD

f. Setup your Windows environment

g. Setup your compiler


II. Importing an example WiFi Scanner application from Mbed


III. Compiling with the Mbed CLI, targetting a Cypress board


IV. Flashing the design using the Mbed CLI or from the ModusToobox IDE


V. Importing the design into the ModusToolbox IDE for further editing, programming, and debugging.


One key document to have handy is Chapter 3 of the ModusToolbox IDE User Guide (Mbed OS to ModusToolbox Flow)  You can find this document in the installation ($install/docs/mt_ide_user_guide.pdf) or on the website (the 1.1 version is here).  Now is a good time to mention that this example is for ModusToolbox 1.1.


I. Environment setup


Install ModusToolbox

If you don’t already have ModusToolbox 1.1 installed, install it now.


Install Cygwin Make (Windows)

You need Cygwin Make for the Cypress Mbed flow to work properly in a Windows version of Eclipse. Refer to the Cygwin website for instructions to download and install Cygwin. Do not add Cygwin to your Windows PATH system environment variable. Cygwin is only required for Eclipse.


Install SRecord

You must install the SRecord utility ( which is used by the ModusToolbox IDE build process to produce a combined HEX file for program/debug.


Install/Configure the Mbed CLI (you won't be able to do anything past here without completing this step)

Go here and follow the instructions for your platform (I’ll be using Windows for this post)

If you want to see the including supported boards and code examples, visit the Cypress page on the Mbed website.  It’s here.


If necessary, Update PyOCD

In order for Mbed applications to work with ModusToolbox and Cypress kits, PyOCD 0.16.1 or greater is required.  Run the following from a cmd window.

pyocd --version

Again, the reply should be 0.16.1 or greater.


If you don’t have the correct version, run:

pip install -U pyocd

I used 0.18.0 for this blog post.


Set up your Windows environment

You need an environment variable called CYSDK that points to the ModusToolbox installation. In my case, I have the following two lines in my  .bash_profile (I’m using a Git Bash shell for this example.

export CYSDK="C:/Users/mdl/ModusToolbox_1.1" (or in a plain Windows cmd window, set CYSDK=C:/Users/mdl/ModusToolbox_1.1)


Set up your compiler

While there are many compilers you can use with Mbed (e.g. ARM and IAR), I will just cover the one I am using; the GCC distribution shipped with ModusToolbox.  This is done with an Mbed command.  You must do this with an Mbed command.  It doesn’t look at an environment variables you have set up in Windows.  Here is the command I used.

mbed config -G GCC_ARM_PATH /c/users/mdl/ModusToolbox_1.1/tools/gcc-7.2.1-1.0/bin

You should see a confirmation message that looks similar to

[mbed] C:/users/mdl/ModusToolbox_1.1/tools/gcc-7.2.1-1.0/bin now set as global GCC_ARM_PATH


(if you are using a plain Windows cmd window, the mbed config command would be something like

mbed config -G GCC_ARM_PATH C:\users\mdl\ModusToolbox_1.1\tools\gcc-7.2.1-1.0\bin )


II. Go get an example from the Mbed repository

1. Create a directory for you example and navigate to it.

2. Get an example using the mbed command “mbed import [example name]”.  Here is the command I ran from the command line

mbed import mbed-os-example-wifi

This many take a bit of time to complete based on net work traffic because there is a lot of stuff in this example.  You can add the “-v” option to the end of the command to get a little more status.

Pro Tip:This is actually a pretty hairy example for your very first Mbed design. You may want to start with the simple Mbed blinking LED example. That command would look like

mbed import mbed-os-example-blinky


III. Compile the example

You could wait to do this step after importing into the ModusToolbox IDE, but I like to make sure I have the basic example compiling before importing.


1. Change directory to the example you just imported. In my case:

cd mbed-os-example-wifi

2. Explore and review the contents of the directory

Some of the key files are a README file, an mbed-os directory (that is responsible for most of the disk space consumption) and a C++ source file, main.cpp.

3. Compile the design with a Cypress board as the target

The format of the mbed compile command we will use is

mbed compile --target [Cypress Board] --toolchain [TOOLCHAIN]

where TOOLCHAIN = GCC_ARM and Cypress Board = CYW943012P6EVB_01

If you want to see all the compile options, you can type

mbed compile --help

If you want to see table of all available toolchains and targets, type

mbed toolchain --supported

Cypress targets at the time I created this blog post include:






CYW943012P6EVB_01  (the board I am using)


4. Configure the example for your specific WiFi network

Now, we will set up the WiFi network we will connect to in this example.  Do this before running a build/compile.  In the project directory, you will see a file named mbed_app.json.  Replace SSID and PASSWORD as shown below with the SSID and password for your network.


Leave the quotation marks and backslashes exactly as shown.  Now, the actual compile command for my board will look like this.

mbed compile --target CYW943012P6EVB_01 --toolchain GCC_ARM

If I had a Cypress 062 WiFi-BT board, the command would look like.

mbed compile --target CY8CKIT_062_WIFI_BT--toolchain GCC_ARM


If I were using the IAR compiler, I’d replace GCC_ARM with IAR.

One quick note: At the time of this blog post, IAR 8 was not compatible with Mbed OS.

The first time you build this example, it will take a while.  The end of the compile will look something like the following.


Before you can program the board, you must put it in Arm Mbed DAPLink mode. Arm Mbed DAPLink is open-source software project that enables programming and debugging application software running on Arm Cortex CPUs. DAPLink runs on a secondary MCU (often a PSoC 5LP on Cypress boards) that is attached to the SWD or JTAG port of the application MCU.  It enumerates as a USB composite device and creates a bridge between your development computer and the CPU debug access port. More info can be found here.


You need to do a one-time load of the DAPLink firmware onto your board. The full instructions for installing DAPLink onto supported Cypress development boards can be found in Chapter 3 of the ModusToolbox IDE User Guide, but I will go ahead and list them for my CYW943012P6EVB board here.

1. Plug a USB cable into your computer.

2. Press and hold SW3 while plugging in the other end of the cable to your board. This puts the kit in firmware bootload mode.  Obviously use the USB port near the PSoC 5LP, not the USB for the device USB.  Just look on the screen printing for a string starting WITH CY8C5868.

3. From a command window, run the command

fw-loader --update-kp3

The fw-loader can be found in the ModusToolbox installation directory under tools/fw-loader-2.1/bin .  I put it in my path, but you can just go over to the directory and run it.

4. After the fw update is complete, you can put your kit into DAPLink mode by pressing and holding SW4 (Custom App) for 2 seconds are so.  You can tell you are successful by running the following in a command window


The results of this command will look something like this

If you need to return the standard CMSIS-DAP HID/BULK mode, just press and hold the Custom App switch (SW4) for about 2 seconds again.


IV. Program the board


There are a couple of ways to program the board.

1. From the Mbed command line, with the --flash option.  Here’s the command for this blog post.

mbed compile --target CYW943012P6EVB_01 --toolchain GCC_ARM --flash

2. From the ModusToolbox IDE, which is a longer discussion. I will talk about this later.


About the WiFi Scanner Application

Now, I’ll take some time to talk about the application you have programmed onto the board.  This example

1. brings up the WiFi and underlying network interface

2. scans the available networks, and

3. prints network interface and connection details.


Connect to the mbed serial port using a terminal emulation program such as PuTTY (my buddy Keith says that for serial stuff in embedded design, RealTerm is better than PuTTY or TeraTerm).  The mbed serial port should look something like this in the Windows Device Manager.

If you don’t see something like that, it’s possible you are not in DAPLink mode. Windows 7 users may also need to do an additional step (which is described in Chapter 3 of the ModusToolbox IDE User Guide).

I set PuTTY up with a baud rate of 9600, 8 data bits, 1 stop bit, no parity, no flow control.  Once connected with PuTTY, I press the RST switch (SW5) on my board.  The results will look something like the following (note DAWG5 is the SSID in this case).

If you would like to play around with the source a bit (maybe you want to play with the output or take some commands from stdin), just open up the source in main.cpp using the ModusToolbox IDE or your favorite code editor. Also, explore source code in various directories under mbed-os. For this example, you may want to look at the code in mbed-os/features/netsocket/.  For example, the WiFiInterface class is defined in



V. Importing into the ModusToolbox IDE

At any point after importing the example from Mbed, you can export to a number of different IDEs. For example, to export to an Eclipsed-based IDE, such as the ModusToolbox IDE, run a command of the following format.

1. mbed export --ide [IDE] --target [target]

For this example, use the following command

mbed export --ide eclipse_gcc_arm --target CYW943012P6EVB_01

mbed export --supported  will print a matrix of supported IDEs and targets.

2. Now open the ModusToolbox IDE and use the standard Eclipse Import function (File > Import) to import this Mbed application.  Here again, you may want to refer to Chapter 3 of the ModusToolbox IDE User Guide. After selecting File > Import, expand the C/C++ folder and select the Existing Code as Makefile Project option. Click Next >.

3. Click Browse… and navigate to the directory where you exported the application from Mbed. Ensure the Toolchain for Indexer Settings is set to <none>. Do not change any other settings, including the project name.

4. Click OK then Finish.

When the import finishes, the Mbed OS application will be shown in the Eclipse Project Explorer


Define the Workspace PyOCD Path

Your Eclipse IDE (in this example it’s the ModusToolbox IDE) will need to know how to get to PyOCD for programming and debugging.

Open the Window > Preferences dialog, select MCU > Workspace PyOCD Path, and set the following workspace paths (adjust the path to the Scripts directory for your python/pyocd installation):



Here are the settings for the various platforms.


⦁ Workspace PyOCD Path > Executable = pyocd-gdbserver

⦁ Workspace PyOCD Path > Folder = C:\Python27\Scripts


⦁ Workspace PyOCD Path > Executable = pyocd-gdbserver

⦁ Workspace PyOCD Path > Folder = /Applications/


⦁ Workspace PyOCD Path > Executable = pyocd-gdbserver

⦁ Workspace PyOCD Path > Folder = ~/.local/bin


Create the PATH variable

Right-click on the project and select Properties. Navigate to C/C++ Build > Environment.


Click Add to add a new variable with name PATH, leave the value blank, and select "Add to all configurations."

Click OK to close the New Variable dialog. This step is recommended for Windows to clean up any existing value of the system PATH variable in the current project (this ensures that the project configuration is isolated from the host environment).

Then, click Edit to open the dialog again. Remove anything there, and enter the appropriate value:


⦁ Windows: C:/cygwin64/bin;${cy_tools_path:gcc-7.2.1}/bin


⦁ macOS: ${cy_sdk_install_dir}/tools/gcc-7.2.1-1.0/bin:/usr/bin:/bin:/Applications/

Also add /usr/local/Cellar/srecord/1.64/bin to /etc/paths


⦁ Linux: Check the gcc directory path: /usr/bin:/bin:${cy_sdk_install_dir}/tools/gcc-7.2.1-1.0/bin


Note: It is possible to target another toolchain instead of GCC 7.2.1 provided by ModusToolbox. To use the GNU Arm Embedded Toolchain, install the following to the default location:

Then prepend the following to the Eclipse PATH instead of ${cy_tools_path:gcc-7.2.1}/bin:

<install_dir>/GNU Tools ARM Embedded/7 2018-q2-update/bin


Build, Program, and Debug the Application from the ModusToolbox IDE



If you haven’t recently built the application, select Project > Build to build the project and generate the combined HEX file for programming. When complete, the Console displays a message similar to the following:

hex file ready to flash: BUILD/mbed-os-example-wifi-combined.hex



Open the Run > Run Configurations dialog. Select the “program” configuration for your application under GDB PyOCD Debugging.

On the Main tab, under C/C++ Application, click Browse… to change the specified target from the ELF file to the combined HEX file. Click Apply


On the Startup tab, make sure the Load symbols option is using the ELF file. If not, select the [application].elf file.

Click Run (the red text in the console is normal for PyOCD). It will look something like this.


After programming, you can reconnect with PuTTY as described earlier.  Press the kit reset button to start the program from the beginning.



Open the Run > Debug Configurations dialog and select the “debug” configuration for your application under GDB PyOCD Debugging. Repeat the same process described earlier for changing the configuration under programming. Click Debug.

The IDE will switch to debugging mode and will halt at the break, ready for debugging.  The screen will look something like this.

Note: While debugging, you may see various errors in your code (main.cpp file), such as “function ‘printf’ could not be resolved.” These are likely not real errors. They are caused by the import of the make file into Eclipse. To turn these errors off, go to Project > Properties > C/C++ > Code Analysis, and disable “Potential Programming Problems” and “Syntax and Semantic Errors.”

That’s it for this example.  There’s a ton of stuff it can do, so play around with it a bit. As an advanced exercise modify it to prompt for an SSID and Password.

One reminder, if you are having trouble with this example, get the mbed-os-example-blinky example working first.  Hit me up in the comments if you have questions.




P.S. I soooo wanted to title this post, A Scanner Darkly MichaelF_56 dared me, but MarkS_11 wouldn't let me (Any Philip K. Dick / Rickard Linklater fans out there?)


This blog post discusses implementation of BLE Proximity Profile in  CYW20819 using the device configurator tool in ModusToolBox IDE.


Tool: ModusToolBox 1.1 or above, Serial Terminal (Example: TeraTerm, CoolTerm)

Programming Language: C

Associated Parts: CYW20819

Related Hardware: CYW920819EVB-02 Board (2 boards required)

Proximity Profile:

The purpose of proximity profile is to keep an eye on the BLE Connection link between two devices and trigger an alert when the link is weakened as path loss increases. This profile supports two roles:

  1. Proximity Server (Reporter)
  2. Proximity Client (Monitor)

The proximity profile must include the Link Loss Service. It may optionally include Tx Power Service and Immediate alert service also. Link Loss Service:  The GATT DB of the link loss service has the “Alert Level” characteristic which may be written by the proximity client. This indicates the level of alert to be triggered in the server when the disconnection happens.Tx power Service:  The proximity client may anytime know the Transmitter Power level of the server. This is enabled by reading the Tx Power level characteristic included in the Tx power service.Immediate Alert Service:  The proximity monitor may keep calculating the path loss as follows:

Path Loss = Tx Power Level – RSSI

If the path loss exceeds a certain threshold, the monitor may write the Alert Level characteristic of the IAS, thereby prompting the user to perform appropriate action to avoid disconnection.

Block Diagram:

Using the Device Configurator to generate Proximity Server project:

We can use the Device Configurator Tool in ModusToolBox IDE to generate the GATT DB and an outline code for the firmware. For more details on using the Device Configurator, refer to the Bluetooth Designer Guide in WICED Studio SDK. The GATT DB of the Proximity Server has 3 different services. It is easy to generate the GATT DB and a skeleton code using the Bluetooth Device Configurator Tool.

  1. In the ModusToolBox IDE, go to project folder -> design.modus-> Device Configurator.
  2. Select ‘Bluetooth’ and Click on ‘Launch Bluetooth Configurator’.


       3. Using the “Add Service” Option, different services are selected.


       4. Add the characteristics as shown above and save the configuration to obtain the skeleton project. The files will be

Firmware: This example contains two projects – The proximity server and the proximity client. Proximity Server:  A skeleton code of the proximity server can be generated using the above steps. Certain key features need to be added to the skeleton code to make the server project complete. According to the specification, a proximity reporter has to advertise with the UUID of Link Loss Service. So, the advertisement data should be modified as follows


:/* Set Advertisement Data */

void proximityserver_set_advertisement_data( void )

{    wiced_bt_ble_advert_elem_t adv_elem[3] = { 0 };


    uint8_t num_elem = 0;
    /* Advertisement Element for Flags */

adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_FLAG;

adv_elem[num_elem].len = sizeof(uint8_t);

adv_elem[num_elem].p_data = &adv_flag;


adv_elem[num_elem].advert_type  = BTM_BLE_ADVERT_TYPE_16SRV_COMPLETE;

adv_elem[num_elem].len = sizeof(lls_uuid);

adv_elem[num_elem].p_data       = ( uint8_t* )lls_uuid;


    /* Advertisement Element for Name */

adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_NAME_COMPLETE;

adv_elem[num_elem].len = strlen((const char*)BT_LOCAL_NAME);

adv_elem[num_elem].p_data = BT_LOCAL_NAME;


    /* Set Raw Advertisement Data */

wiced_bt_ble_set_raw_advertisement_data(num_elem, adv_elem);


Where lls_uuid is declared and initialized as:

/* Link Loss service UUID  */

const uint8_t lls_uuid[2] = {(uint8_t)UUID_SERVICE_LINK_LOSS & 0xFF, (uint8_t)(UUID_SERVICE_LINK_LOSS >> 8)  };

The proximity server receives Link Loss and IAS Alerts in the form of writes. The IAS Alert is triggered instantaneously whereas the link loss alert happens when there is a disconnection. The Alerts are indicated by the LEDs. Proximity Client:  This is a central / client device that performs read / write operations with the GATT DB of the server. The central starts scanning for peripherals that advertise with a Link Loss Service UUID, upon a GPIO button press and initiates the connection. Then it begins to discover all the three services of the proximity profile in the server, one by one and saves the handles of the attributes. Following this, the TX power characteristic of the server is read. Now the client periodically calculates the RSSI every 100 mS and thus the average path loss. If the path loss reaches beyond certain thresholds, the client writes to the Immediate alert characteristics of the server, resulting in an immediate trigger. The thresholds are as follows: MILD ALERT: Path loss above 90 dB HIGH ALERT: Path loss above 100 dBThe Link loss alert can be written to the server by pressing the GPIO Interrupts on the client Eval Board. Every time the GPIO is pressed, a different LL alert value is written to the server.

Programming and Testing:

  1. Install the ModusToolBox 1.1 (or above) in your PC. Plug in two CYW920819EVB-02 Boards and let the drivers bind to the devices. Make sure the jumpers are in place. For more details, please refer Getting Started with CYW20819.
  2. Refer this Knowledge Base Article for importing a new ModustoolBox Project.
  3. Open two windows of Serial Terminal (Example: Teraterm or Coolterm), and bind each of those windows to the PUART COM Ports of each devices. Each device has two COM Ports with consecutive numbers. The COM Port with the bigger number corresponds to the PUART that displays Debug Messages. The one with the smaller number corresponds to the HCI UART. The BaudRate is set to 115200 in the firmware. Make sure the BaudRate in serial terminals is also set to 115200.
  4. Select the proximity_server project you created, and click on ‘Build and Program’ as shown in below figure. You can see the Secure_hub program being built and downloaded into one of the boards. (For more details or troubleshooting, please refer the Getting Started with CYW20819)



  1. Similarly program the ProximityClient program to the device.
  2. The ProximityServer device will start to advertise. In the ProximityClient device, press the BTN (D2) button for more than 5 seconds for the scan to start. Once the ProximityClient finds the ProximityServer device advertising, it will automatically initiate connection and pairing process.
  3. The client performs discovery in the server and saves the attribute handles of the Link loss alert, immediate alert and transmit power characteristics. The initial Tx power is also read from the server.
  4. Click the BTN (D2) button to write LL Alert value to the server. Every time the button is pressed, a different value of alert level (among the 3: NO_ALERT, MILD_ALERT, HIGH_ALERT) is written to the server. When a link loss happens, the server will be triggered based on the alert level that was written, as indicated by the LED 2.
  5. The client will also keep calculating the Path loss and writes immediate alerts to the server if the path loss value exceeds a certain threshold. Such alerts immediately trigger the server, as indicated by the LED 1.

Path Loss Vs Distance:


For a Tx Power of 4 dBm in CYW20819, the path loss Vs Distance values are observed as below in an office environment




Related Documents:

The below table lists all relevant application notes, code examples, knowledge base articles, device datasheets, and Component / user module datasheets.






AN225684 - Getting Started with CYW20819

The Getting Started Guide can be downloaded from here.


CYW920819EVB-02 Evaluation Kit User Guide

This Evaluation Kit User Guide can be downloaded from here.


This example demonstrates the implementation of different security levels of pairing and the data transfer in a multi-connection environment.



This project instantiates a data hub that plays the roles of GAP Central, GAP Peripheral, GATT Client and GATT Server at the same time, and that is able to pair with up to 3 slaves at different security levels. In addition, the device will also be able to pair with a Master, to which it can send the data collected from the slaves or distribute the data from the master to the slaves.


Tool: ModusToolBox IDE 1.1 and above, Any BLE Central (Example: CySmart Mobile Application), Serial Terminal (Example: TeraTerm, CoolTerm)

Programming Language: C

Associated Parts: CYW20819

Related Hardware: CYW920819EVB-02 Board (2 to 4 required)


Block Diagram:

                                                  Figure 1: Block Diagram



As shown in the above block diagram, the Secure Hub can connect with up to 3 slave devices (programmed with hello_sensor project). It in turn serves as a slave for a master device. All the CYW20819 devices will be able to communicate with the PC via PUART interfaces that appear as serial terminal COM Ports in the PC.


Firmware Flow of secure_hub Device:


                                                                              Figure 2: Firmware Flow




  • application_start is the program entry point. Here the peripheral UART is set for displaying Debug Messages. The BT Stack and the corresponding management callback are started using the wiced_bt_stack_init () API.
  • db_management_cback()  function in secure_hub.c handles the events generated for the BLE Stack. The BTM_ENABLED_EVT indicates that the Bluetooth stack is ready. Upon the reception of this event, we start the Non-Connectable High Duty Cycle advertisement. The Timer and GPIO Interrupts are registered. The Timer and GPIO Button Press Interrupt callbacks increment the suffix in the Device Name by 1 and then continues the advertisement with the incremented name.
  • In the secure_hub and the hello_sensor projects, the user needs to enter the desired security level and IO Capabilities via console. The console accepts inputs via PUART. The 4 security levels supported in this project are
  1. Just Works
  2. MITM
  3. LE Secure Connection
  4. LE Secure Connection with MITM
  • The hello_sensor project starts advertising, once these details are entered. A Scan is initiated via GPIO Interrupt button press on the secure_hub device. The UUID of the service available in the hello_sensor node is verified in the callback, after which the connection is initiated by the secure_hub.
  • Once a connection is established with the slave, the secure_hub performs a GATT Discovery of the slave using the custom UUIDs of hello_service. The discovery happens in 3 stages:


                (ii) Characteristic

                (iii) Descriptor



The GATT DB of the hello_sensor device contains the hello service. The hello_service contains two characteristics (Refer hello_sensor/gatt_db.c and hello_sensor/gatt_db.h files)

  • HANDLE_HSENS_SERVICE_CHAR_NOTIFY:This characteristic has the properties of Notification and Indication. The Bytes to be notified    / indicated are typed in the serial terminal of the hello_sensor device and are transmitted as Notification or Indication to the secure_hub.
  • HANDLE_HSENS_SERVICE_CHAR_BLINK:This characteristic has the properties of Read and Write. The secure nature of the application is demonstrated using this characteristic. In the gatt_db.c file of the hello_sensor, it can be noticed that the permissions of this characteristic include these bitmasks: LEGATTDB_PERM_WRITE_REQ| LEGATTDB_PERM_AUTH_WRITABLE. This means that this characteristic can be written only when the link has been paired with MITM (Man in the middle protection).  Security Levels (either BTM_LE_AUTH_REQ_MITM or BTM_LE_AUTH_REQ_SC_MITM. The user has to manually take care of this in the application level. When other security levels are used, a write to this characteristic will result in an “Insufficient Authentication” error. Once this characteristic is successfully written by a one byte value, the Red LED on the board blinks as many times as the written value. By the end of the discovery, the secure_hub device stores the Attribute handles of the HANDLE_HSENS_SERVICE_CHAR_BLINK characteristic and the CCCD (Client Characteristic Configuration Descriptor) of the HANDLE_HSENS_SERVICE_CHAR_NOTIFY characteristic. With the attribute handles, the secure_hub device can write to these characteristics descriptors. The CCCD Handle is required, so that the notifications / indications can be enabled / disabled on the hello_sensor slaves. The handles are stored in a global structure g_secure_hub.
  • The GATT DB of the secure_hub device correspondingly has two characteristics HANDLE_SECURE_HUB_SERVICE_CHAR_NOTIFY and HANDLE_SECURE_HUB_SERVICE_CHAR_LED_WRITE. The former is used to transmit the Notifications / Indications received from the hello_sensor devices to the master (if present any). Such notifications are appended along with the Connection ID of the slave, so that the master can identify the slave that has sent the notification. The latter is used to receive writes from the master, which is in-turn written to the HANDLE_HSENS_SERVICE_CHAR_BLINK characteristic on the hello_sensor slaves.
  • At any instant, a new slave may be connected to the secure_hub or a old one may detach itself by pressing the SW1 button the board. A maximum of 3 hello_sensor slaves can be connected to the secure_hub device at a time, in addition to a master. The secure_hub keeps advertising, until a master has connected to it. It will again start advertising when the master has disconnected from it.


Programming and Testing:

  • Install the ModusToolBox 1.1 (or above) in your PC. Plug in two CYW920819EVB-02 Boards and let the drivers bind to the devices. Make sure the jumpers are in place. For more details, please refer Getting Started with CYW20819.
  • Refer this Knowledge Base Article   for importing a new ModustoolBox Project.
  • Open two windows of Serial Terminal (Example: Teraterm Coolterm), and bind each of those windows to the PUART COM Ports of each devices. Each device has two COM Ports with consecutive numbers. The COM Port with the bigger number corresponds to the PUART that displays Debug Messages. The one with the smaller number corresponds to the HCI UART. The BaudRate is set to 115200 in the firmware. Make sure the BaudRate in serial terminals is also set to 115200.
  • Select the secure_hub project you created, and click on ‘Build and Program’ as shown in below figure. You can see the Secure_hub program being built and downloaded into one of the boards. (For more details or troubleshooting, please refer the Getting Started with CYW20819)



  • Similarly program the hello_sensor firmware to another device.
  • In the Teraterm, the debug logs can be seen asking to select the security level among these 4 – No Security, MITM (Man in the middle), LE Secure Connection, LE Secure Connection with MITM. Select the appropriate security level on either device, by entering the corresponding number. Following this, for the security levels that involve MITM, you will have to select the IO Capabilities. The user has to select the MITM.




  • The hello_sensor device will start to advertise. In the secure_hub device, press the SW3 button for more than 5 seconds for the scan to start. Once the secure_hub finds the hello_sensor device advertising, it will automatically initiate connection and pairing process. In case of the security levels with MITM, passkey entry might be required, where the user has to enter the passkey displayed by one device as input to another device.
  • The secure_hub device keeps advertising and it can be connected to another central (any BLE App on Smart Phone, say CySmart.)
  • Once the pairing is complete, the secure_hub automatically enables notifications on the hello_sensor device. The user will be able to send notifications by directly typing on the terminal of the hello_sensor byte by byte. The secure_hub displays the notifications received from the hello_sensor and in turn sends them to the Central if present, and if notifications / indications have been enabled by the Central.
  • At any time, another hello_sensor device can be connected the secure_hub by following steps 7,8,9 while preserving the existing connection. A maximum of 3 hello_sensor devices can be connected to the secure hub.
  • The Central can send write requests to the secure_hub which in turn performs write requests to the slave hello_sensor devices connected to it.

Note: When the secure_hub tries to write to a slave with which it has paired with security levels without MITM, it will receive “Insufficient Authentication Error”. Also, when the master tries to write to the secure_hub, when no slaves are connected to the secure_hub, it will result in an “insufficient authorization” error.


Related Documents:

Table -1 lists all relevant application notes, code examples, knowledge base articles, device datasheets, and Component / user module datasheets.


Table 1: Related Documents






AN225684 - Getting Started with CYW20819

This Getting Started Guide can be downloaded from here.


CYW920819EVB-02 Evaluation Kit User Guide

This Evaluation Kit User Guide can be downloaded from here.

Hello Embedded Developers,


This is a follow-on to my blog post on using ModusToolbox from the Windows command line. In this example, I add configurators to the mix. In this post I will

  1. Adjust my pinout with the ModusToolbox Device Configurator, launched from the command line
  2. Observe CapSense signals with the CapSense Tuner (launched from the Device Configurator or from the command line).

I’ll also going to show the how to set a make variable on the command line and get help with the various make variables and targets Cypress provides in ModusToolbox.


Remember to have your environment set up similar to what is described in the previous blog post. This means:

  • We need GNU make, such as might be found in Cygwin and
  • An environment variable called CYSDK that points to the ModusToolbox installation. In my case have the following two lines in my Cygwin .bash_profile.



     export CYSDK


I have also set up my path to make it easier to launch the tools I am interested in running.  Here are the lines I have in my .bash_profile.


# I want to run several ModusToolbox tools from the command line

# The following is how I manage that. You don’t have to use this variable



# Add the ModusToolbox Device Configurator (allows me to do things like change the pinout)


# CapSense Configurator and CapSense Tuner




Again, start with an example template

In my case, I’m going to start with CapSenseSlider, which is found here $INSTALL\libraries\psoc6sw-1.1\examples\CapSenseSlider

  1. Copy that whole directory over into a clean workspace, for example, C:\Users\<User>\Desktop\CapSense.
  2. Open a Cygwin terminal and go to that directory.
  3. Once you are in that project directory, go to the Source subdirectory and open (or just view) main.c.  Instructions for this example are shown in the comments at the top of the file.  For this walk through, I am using a CY8CPROTO-062-4343W kit.  So, from the instructions I can already see I’ll need to change the pins as the pin assignments for this example are, by default, set up for the CY8CKIT-062-BLE kit or the CY8CKIT-062-WIFI-BT Kit.


Here is an excerpt from main.c of the CapSenseSlider example template.



* Migration to CY8CPROTO-062-4343W kit (ModusToolbox IDE):

*   1. Create this project targeting the CY8CPROTO-062-4343W kit.

*   2. Open design.modus file and replicate P0[3] configuration on P13[7]. Give

*      this pin the alias "LED_RED". Disable P0[3].

*   3. Build and Program


* Migration to CY8CPROTO-062-4343W kit (command line make):

*   1. Launch the Device Configurator tool from

*      ModusToolbox_x.x\tools\device-configurator-x.x\



Set up the pin that drives the LED


4. Go up one level in the hierarchy from main.c and from the Cygwin command line type


device-configurator design.modus


You should see a window similar to the following



5. Click on the Pins tab to modify the assignments.  According to the instructions in main.c, we will need to replicate all the settings from P0[3] (Pin 3 on Port 0) to P13[7] and disable P0[3]. P13[7] corresponds to LED4 on the board I am using.  Here is a screen shot showing LED4, near the center of the CY8CPROTO-062-4343W board (see red rectangle).



6. Here is what the settings for P13[7] look like after the edit.


Note the alias, LED_RED. That is important. That is how we will be referencing that signal in our code.  If you like, search for the string LED_RED in main.c.  You will see code such as


Cy_GPIO_Write(LED_RED_PORT, LED_RED_PIN, redLedState);


Cy_GPIO_Write is the API Cypress has provide to write a value to a GPIO.


7. Save your new pin configuration (File->Save)

8. Fortunately, pin assignments for the CapSense buttons and slider segments don’t need to be changed since they are the same across several Cypress boards (e.g. CY8CPROTO-062-4343W, CY8CKIT-062-BLE, and CY8CKIT-062-WIFI-BT).

9. I’ll show you how to launch the CapSense Tuner later in this post, but first let’s just see if we can make LED4 turn on and off with the button, BTN0. Make sure you are in the project directory (that is, the one with the design.modus file).

10. Since we’ve modified pin assignments, let’s be safe do a make clean from the command line.

11. Plug in your board to a USB port on your computer using a USB cable. Make sure you that on the board you plug into the USB port that is the Program/Debug USB port on the top-left (when the board is oriented so the CapSense slider is on the bottom). The other USB port is for the PSoC 6’s USB.


Build your application and program the board


12. Now type make DEVICE=CY8C624ABZI-D44 program


Specifying the Make variable DEVICE=CY8C624ABZI-D44 overrides the default targeted device and targets instead the particular PSoC 6 on the board I am using. The make target named program will launch the appropriate tools to download the program from you computer to the board (flash the part).


Recall from the previous blog post that the first build of a given project will be substantially longer than future builds.


If you want to know more about the make variables available with ModusToolbox, refer to the document Running ModusToolbox from the Command Line. You can also just type make help in a ModusToolbox project directory to get a plethora of information (see the following screen shot for a partial list)



13. After a successful build, you should be able to repeatedly touch BTN0 on the board to toggle LED4.  You may need to press SW1 (RESET) first.


Observe what’s happening with the CapSense sensors using the CapSense Tuner


We can watch what happens when each of the sensors are pressed in the CapSenseTuner, which can be launched from the command line in two ways. The first method is to launch it from the Device Configurator. The second is to launch the CapSense Tuner directly from the command line. I'll show both ways.


First from the ModusToolbox Device Configurator.

  1. Launch the Device Configurator, as described earlier in this post, that is device-configurator design.modus
  2. Switch to the Peripherals tab
  3. Expand the System group if it’s not already expanded.  You will see that CapSense is enabled (see check mark).  Your window will look something like this

4. Select the CapSense row

5. Launch the CapSense Tuner from the right side under External Tools (see the following screen shot)


6. Once the CapSense Tuner window opens

    • Select Communication->Connect KitProg3 UART-[some string]->I2C
    • Select the Widget View if not already selected
    • Select everything in the Widget Explorer
    • Connect (click the round, green button, press F4, or select Connect from the Communication menu)
    • Start (click the triangle pointing to the right, press F5, or select Start from the Communication menu)

     If you forget those last two steps (Connect and Start), the output will be quite boring.

7. Now, touch BTN0 on the board and observe that Button0 in the middle window of the appliation will turn blue. Also notice the blue graph bar in the Touch Signal Graph Window on the right side of the application. It will look something like following screen shot.



You can also launch the CapSense Tuner directly from the command line (Instead of launching from the ModusToolbox Device Configurator),

That’s done as follows:


  1. From the command line, type capsense-tuner
  2. Choose File->Open from the tool menu
  3. Navigate to [Project Directory]/GeneratedSource folder and select cycfg_capsense.h


Remember that I have the CapSense tuner set up in my path via my .bash_profile.  You can also launch it directly from $Install\tools\capsense-configurator-1.1 (depending on your version of ModusToolbox, you may need to replace 1.1 with the proper substring).


Now, run your finger across the CapSense slider and watch the results in the CapSense Tuner Application (make sure all the sensors are selected on the left). Again, don't forget to connect and start in the CapSense Tuner application. The application will show something like this


That it for this post.  You can follow similar steps for other ModusToolbox configurators. In future posts, we’ll show other things, such as the Mbed command line flow.  Let us know in the comments if there is something specific you would like to see.



Hello Embedded Developers,


In this post, I’ll run through a quick example of using ModusToolbox from the Windows command line.  First, let me point you to a couple of reference documents.

  1. Running ModusToolbox from the Command Line – This is shipped with ModusToolbox in the $Install/docs folder and can be found on as well (just follow the link).  You will want to refer to this document for additional information, especially if you want to run under Linux or MacOS instead of Windows.  There is also documentation of several make variables available with ModusToolbox.
  2. Cypress Programmer 2.1 OpenOCD CLI User Guide – This is also shipped with ModusToolbox but is located in the $Install/tools/openocd-2.1/docs directory (it’s also on Specifically, you may want to review the Usage Examples chapter.   The path name may vary slightly base on which version of ModusToolbox you have installed.


One clarification before I get started: I am not going to cover running configurators or the Mbed command line flow in this post. We will do that separately.


OK, first let’s get our Windows environment setup


1. We need GNU make.  For Windows, Cypress recommends using a standard make distribution, such as found in Cygwin (uname -r returns “2.11.1(0.329/5/3)” for me).  I use Cygwin64 Terminal to do all my Windows command line stuff.


2.  ModusToolbox looks for an environment variable called CYSDK that points to the ModusToolbox installation. I have the following two lines in my Cygwin .bash_profile



export CYSDK


Now, let’s build an application

I’ll start with the simple Blinky Application found in $INSTALL\libraries\psoc6sw-1.1\examples\Blinky (see screenshot that follows).


  1. Copy that whole directory over into a clean workspace.  Let’s say the new location is C:\Users\<User>\Desktop\BlinkyLED. You can run right from the install location, but I prefer to leave that alone.
  2. Open a Cygwin terminal and go to that directory.
  3. Once I am in the directory, I just type make. The output will look something like this.


Be aware that the first build will take a lot longer than subsequent builds for this same project as the shared library, PSoC6_PDL.a, gets compiled the first time.


Note: Now is a good time to point out one of my favorite ModusToolbox make variables, DEBUG.  If I experience weird or unexpected behavior, make DEBUG=true is my best friend (observe that DEBUG in all caps and true is all lowercase).


4. After a successful build, you’ll see a directory named “build” has been created.  If you’re curious, take a look at the contents of that directory. For example, an ELF file has been created in build/PSoC6_cm4_dual/Debug/mainapp

The file [project name]_mainapp_final.elf in that directory is what we will use to program our device.

5. Optionally edit main.c in the Source directory. For example, I might want to change the blink rate of the LED.  If you edit this file, you obviously need to go up one level in the hierarchy and type make again.

6. As discussed in the Running ModusToolbox from the Command Line document, we have built several handy make targets into ModusToolbox. Let’s use one now!

  1. Plug in your target board (I’m using a CY8CKIT-062-BLE for this example)
  2. type make program (this will program your board with the elf file you just created).


Successful programming will end with output that look something like the following.


That’s it. You are ready to try some examples on your own.


For reference, here is a portion of my .bash_profile. A few notes about it:

  • My user name for this example is “mdl”
  • My ModusToolbox is installed in C:\Users\mdl\ModusToolbox_1.1
  • It’s easy to get tripped up setting CYSDK if you are not careful.  Pay close attention to this.


####### excerpt from the .bash_profile file for my Cygwin terminal


# Set up environment variable used by ModusToolbox tools

export CYSDK=C:/Users/mdl/ModusToolbox_1.1


# I want to run several ModusToolbox tools from the command line

# The following is how I manage that. You don’t have to use this variable



# Add the ModusToolbox Device Configurator



# To Add CapSense Configurator, uncomment the next line



# To Add the Bluetooth Configurator, uncomment the next line



# To Add USB Configurator, uncomment the next line



# You can add similar lines for QSPI, SmartIO, etc.


# Add the FW Loader utility (used for various things such as updating kits to Kitprog3)



####### End excerpt from the .bash_profile


In future posts, we’ll show things like running the configurators from the command line and using the Mbed flow.  Let me know in the comments if there is something specific you would like to see.



Our friends over at Percepio just won a Best in Show award at Embedded World in Germany. Device Firmware Monitor (DFM) was the winner in the Development Tools category.

Percepio Device Firmware Monitor, the new cloud service for software quality assurance in IoT product organizations, has been awarded Best in Show at Embedded World 2019, in the Development Tools category.DFM is an exciting new cloud service for IoT firmware developers, providing awareness of firmware issues in deployed devices and speeding up resolution. DFM notifies firmware developers within seconds after an error has been detected and provides diagnostic information about the issue via the cloud, including a software trace that visualizes what was going on in the firmware when the error occurred. This makes it far easier to understand the problem, find a solution, and quickly dispatch an over-the-air (OTA) update to correct the problem. DFM integrates Percepio's leading analysis tool Tracealyzer, with AWS IoT connectivity.Percepio Best in Show Diploma


Most embedded software is shipped with defects remaining in the code. On average, 5 percent of all bugs introduced during development elude verification efforts and make their way to customers. The IoT trend brings OTA updates as a potential remedy, but developers can't fix bugs they are not aware of. Automatic feedback is needed. Percepio DFM is a ground-breaking new approach, providing awareness and diagnostics that allow IoT developers to leverage the full potential of OTA updates to continuously improve their firmware and customer experience.

Congratulations to Johan, Mike and the rest of the Percepio team! We think DFM is an exciting new product and, pretty soon, we hope to test it out with PSoC 6 and our connectivity devices.