BLOG# 2 - BPM Display - Research & Experimentation

A Heart Rate Monitor Display project utilizing the PSoC™ 62S2 + AIROC™ Wi-Fi/Bluetooth Pioneer Kit

manufactured by CYPRESS - INFINEON TECHNOLOGIES (Part# CY8CKIT-062S2-43012)


This is my 2nd blog post for this Design Challenge: Low Power IoT Design Challenge

version 1.0



Blog#1 - BPM Display - Introduction

Blog#3 - BPM Display - System Design


  • This blog post, will describe my research conducted on the PSoC Kit as it relates to my idea stated in my Introduction Blog.
  • I will be describing what comes in the box and describing the contents of the box in pictures.
  • Then I'll describe how I started to use the PSoC6 Dev Kit.
    • I'll describe how I used the ModusToolBox IDE, by giving my step by step instructions on Building and Debugging the "Hello World"  example that comes pre-installed on the kit.
  • I then pose some experiments to conduct with the kit, to evaluate some technical Software concepts that I feel could be used in my Idea.
  • Next I will explain in detail, a series of blogs on using FreeRTOS on a similar  PSoC 6 board by Jan Crumps.
    • The reason I chose to utilize Jan's PSoC 6 series in my experiments, is that the series addresses many software components that I posed in experiments that I could use to design and Implement my Idea.
  • I then,  give a little tutorial on Importing and Converting a project to the PSoC kit, so the user can import Jan's project and use it with the this kit.
  • I finish out the blog post, by giving some useful reference links that I used in my research.



The Challenge Kit Described

What's in a name

The kit name "PSoC™ 6S2 + AIROC™ Wi-Fi/Bluetooth Pioneer Kit' is a mouthful, so I decided to break the words out to try and make sense of the kit name.

Please Note: the Kit Guide adds a "2" to the "PSoC 6S2" name,  making the title really "PSoC 62S2 Wi-Fi BT Pioneer Board"

PSoC - stands for (programmable system on a chip) is a family of MCU IC's by Cypress Semiconductor

PSoC™ 62S2 - PSoC 6 is a line of Cypress IC's. PSoC 6 MCU (part# CY8CKIT-062S2-43012). not sure what the "S2" in the title is?

AIROC™ - is a Wi-Fi & Bluetooth® combo chip  manufactured by Infineon 

+ AIROC™ Wi-Fi/Bluetooth - meaning the kit includes the Infineon AIROC IC, which is a Wi-Fi/Bluetooth combo chip

Pioneer Kit - Well, I take this to mean that it is a discovery kit to experiment with the PSoC 6S2 IC and the AIROC IC. Why not just call it a "Dev Kit"?


Like the box says I'm going to call it " PSoC 6 Dev Kit"


Unboxing of the Challenge Kit

What's in the Box

The blue box contains the following---------------------------------------------------------------------------------------
  • PSoC 62S2 Wi-Fi BT Pioneer Board
  • USB Type-A to Micro-B cable
  • Four jumper wires (4 inches each)
  • Two jumper wires (5 inches each)
  • Quick Start Guide
Front of the BoxBack of the Box
Back of the box Text----------------------------------------------------------------------------------------

For the latest software and information on this kit, visit:



Cypress Developer Community™


Training - Workshops/Webinars/On-Demand


Cypress Online Store


Online Technical Support



Cypress Semiconductor Corporation 198 Champion Court San Jose, CA 95134 USA


Copyright 02019 Cypress Semiconductor Corporation. All rights reserved. All trademarks or registered trademarks referenced herein are the property of their respective owners. 002-28136 Rev**

PSoC MCU product page


Wi-Fi + Bluetooth Combos bluetooth-combos


Cypress Education - University Alliance


CY8CKIT-062S2-43012 Rev "C



Cypress Customer Support If you have questions, visit


Contains Model: Type1LV FCC ID: VPYLBEE59B1LV IC: 772C-LBEE59B1LV




Front Of the boardBack of the board . I like the rubber feet. It's a nice touch.
Quick start guidesame as this link at




Kit Contents:

1 PSOC® 62S2 Wi-Fi BT Pioneer Board

2 USB Type-A to Micro-B cable

3 Four jumper wires (four inches each)

4 Two jumper wires (five inches each)

5 Quick Start Guide (this document)


• Before starting, ensure you have the following.

• PC with USB port

• UART terminal software such as Tera Term or Minicom

• Visit the kit website to download and install the

required software.

What is the link?

What required software?

Do I need to install the ModusToolbox before connecting the cable? the answer is yes....


eventually I went to the following page:

and downloaded the Windows10 version.

You should  have already registered an account on

Ensure the jumper J14 is at position 2-3 to select 3.3V

• Connect the KitProg3 USB connector (J6) to your PC

. Wait for the drivers installation to complete


• Open the UART terminal software and connect to the kit's USB-UART COM port with the settings

- Baud rate: 115200, Data: 8 bit, Parity: None, Stop bit: 1 bit, Flow control: None

• Press the XRES switch (SW1) to reset the device. SW1 is numbered 13 below.

• Follow the instructions displayed on the UART terminal to use the pre-programmed code example

Nothing happens here if you have not installed the Modus Toolbox .the USB drivers needed to connect to the UART are install with ModusToolkit


Refer to the Kit Guide available at the kit website for details.

Again a URL address would be helpful here.


My version of Getting Started

Register an account on

  • The first thing you will need to do is register on the website.
  • Go through this so you are able to download the ModusToolbox ,and other documentation


Download the software

Install ModusToolbox

  • In windows, click on the exe file you had downloaded
  • The toolbox will install
  • in windows open the device manager and observe a new USB device


Run the Preinstalled demo

  • In the quick start guide it stats:
    • "Visit the kit website to download and install the required software."
  • So, I tried to follow the rest of the directions and I was not able to get the terminal to work as specified.
  • So, I then downloaded and installed the ModusToolbox.
  • After the install, I noticed a new driver in the device manager and I had a new com port: COM10 in the TeraTerm dropdown that was not there before
  • My guess is, that the ModusToolbox installs the KitProg3 Driver and assigns it to COM10.
  • Now the demo displays information as described on the TeraTerm screen when I plug in the USB cable
  • Plug the USB cable between the KitProg3 USB connector on the board and your PC used for development.
  • Now observe LED8 blinking on and off every second.
  • Information displayed on the Terminal screen.

    As directed "Press 'Enter' key" will  pause or resume the blinking the LED8



Getting to know ModusToolBox IDE

  • After you have installed the ModusToolbox, this section will give you a Quick Start guide to running the "pre-programmed code example" that comes with the kit out of the box.
  • I'm assuming this is the code used in the Pre-programmed example, since the output on the terminal is identical.
  • I will experiment with the "Hello World" example to learn more about the workings of the IDE.
  • Follow these steps for Windows,  if your interested, otherwise you could follow along with your Linux or Mac install.


Open ModusToolbox from the windows start menu.

  • Form the "ModusToolbox 2.3" Folder, Select the "Eclipse IDE for ModusToolbox 2.3"

Select a Directory as Workspace

  • Use the "Browse" button on the following dialog box to select a workspace
  • A workspace is the root directory for your project.


Create a "New Application"

  • There are several ways to start a new project, but go to the panel described below and select " New Application"



  • After you have clicked on the  "Run Application" button, the Project Creator GUI pops up.
  • The Project Creator GUI tool provides a series of screens to:
    • Select a Board Support Package (BSP) for the kit (CY8CKIT-062S2-43012) that you will be using.
    • Select code examples
    • specify the application name and location
  • The following message dialog appears (on Windows it shows up under the ProjectCreator window)
  • You cannot go back to the main IDE Window and this will go away after you have created the example project.

Board Support Package (BSP) Dialog Box

  • The first box to appear is  the "Project Creator 1.30 - Choose Board Support Package (BSP)" dialog box pictured below.
  • There seems to be a lot of information here, but what you will be doing is selecting the CY8CKIT-062S2-43012 part number as the BSP.
  • You can find the part by placing "CY8CKIT-062S2-43012" in the search box as described below.
  • Observe the search bar and when the part is entered takes you to the "PSoC 6 BSPs"  CY8CKIT-062S2-43012 part with a link to cypress kit webpage and a description of the product in the right panel.
  • Click ""Next" located in the bottom right of the dialog.


Select Application Dialog box

  • After you select the "NEXT" button", the following "Project Creator 1.30 - select Application" dialog box  appears.
  • On this dialog box, you get a list of examples you can select from. The examples are retrieved for you from the GitHub repository.
  • You can Rename your location of the project,
  • You can search for an example name or word and the example will show up in the list. For example if I enter "FreeRTOS" all the examples containing it in the description or in the title will be displayed.
  • You can select multiple example Projects and they will be loaded into the IDE.
  • For this exercise, scroll down to "Hello World" and check it
    • It's not apparent, but you can change the name of the project by clicking over the textbox indicated in green in the above picture. Then type in a new name and press Enter.
    • There is also a description of the example in the right window panel.
    • A Summary of the settings is displayed in the bottom panel.
    • Press the "Create Button" to create the project.
    • You will see activity displayed in the bottom panel of the process.
  • The process takes a while but the build is being done and eventually the ProjectCreator dialog closes and you are returned to the ModusToolbox screen described below


Back on the Main Screen

    • On this screen there are now several windows that contain information
    • The Project Explorer Window displays the source code.
    • As you double-click on a file, The contents is displayed in the Editor Window to the right
    • To the right of the editor is an Outline Window that displays of the source objects for quick navigation.
    • To the bottom of these 2 windows is the Console Window, that displays where the log files are located if you need to find them.
    • Next well run the program


Launch the Program.

  • GO to the Launches section located in the "Quick Panel" as described below.
  • Get the TeraTerm Terminal up and running
  • If not already done, plug in the USB cable between the kit and the PC your running ModusToolbox on.
  • Select the  Hello_World Program  (KitProg3_MiniProg4) button. I'll be getting into the debugger later.
  • The compiled code is programmed to the kit.
  • You will see information in the Console window.
  • When finished the program will begin to execute.
  • Congratulations, you have successfully implemented your first example application in ModusToolbox to the PSoC 6 Kit


Next Steps with the IDE

  • To get to know the ModusTollbox in more detail you can refer to the following  documentation and Videos.


Experimenting with the Kit

As I'm researching the capabilities of the kit  and the possibilities of Low Power and AnycCloud connectivity options, I started forming a slightly different design for my idea mentioned in my introduction blog, My design idea started to incorporate the Heart Rate Sensor Design implementation and use the Arduino to send the Heart Rate values to the PSoC 6 board. I figured that my Heart Rate Data was working using the HR Sensor and the OLED, why not just pass the BPM values to the UART on the PSoC 6. Now the PSoC 6 can wake up when it gets a BPM value and send it on thru to the cloud for storage and analysis.


One of the prime reasons behind this design shift is, that the BPM calculations are complex and already implemented and tested using  Python. The PSoC 6 utilizes C, so code would have to be rewritten and tested for a accuracy. Much easier to keep the working code for now and keep the Heart Rate Sensor attached to the Arduino design.

I would also like to shift the OLED display to the PSoC 6 to utilize the low power sleep capabilities of the MCU.


Proposed Experiments

In this section I will experimenting with the Following:

  • Sending the Heart Rate Value from the Arduino to the PSoC 6
    • Send BPM value from the Arduino code
    • Receive the BPM value on the PSoC 6 UART
    • Using the UART on the PSoC 6
  • AnyCloud MQTT examples
    • MQTT experimentation with AWS
    • Is there a way to send it to Azure?
  • Using FreeRTOS OS capabilities to implement my idea in software
    • Message queue experiments
    • Scheduler
    • Triggers and semaphore.
  • Low power options of the PSoC 6
    • Putting the PSoC 6 in a Sleep state
    • Waking up the PSoC 6 from a sleep state
  • Connect the OLED display to the PCoC 6 to display the BPM values
    • Experiment with Sleep state for the OLED so that it only is awaken when there is a value sent to it.


PSoC 6 Blog Series by Jan Crumps

  • Jan Crumps series on the PSoC6 in the Embedded group, turned out to be addressing the many areas for experiments, that I defined in the previous section.
  • I learn by doing. These blogs were a tremendous resource for me to experiment with the kit, the IDE and learn more about RTOS.

    • Jan examples are for a different kit, but I'm interested in learning some of the concepts that might be the same for CY8CKIT
    • I used CYBCKIT-062S2-43012 as the BSP for all his projects as described  in the photo to the right. All the blogs worked for me
    • Two Useful Blog Posts on BSP and the FreeRTOS Schedular

      • the next 2 blog post are good examples on how to use BSP and creating a FreetRTOS project specific to a target version.
      • PSoC 6 and ModusToolbox: Create a Project with its own Board- and Module configurations

        • I tried this out and was confused at first because the Shared directory for the BSP device was not listed as described in Step 2.
        • What I had to do was make the device  shared in the Library manager. It was unchecked by default. When I checked it and selected "Update", the directory was created. Now you can follow along to the rest of the steps.
        • This a neat feature, but since I'm only using the CY8CKIT, I'm not sure if I'll be using this configuration. I don't plan on changing the BSP at this stage of my development.
      • PSoC 6 and ModusToolbox: Create a FreeRTOS 10.3 Project

        • I tried this example out to learn more about freeRTOS and Scheduling Task.
        • freeRTOS is run on the CM4 core.
        • This example creates a Blinky app that runs on freeRTOS version 10.3. It utilizes the freeRTOS Scheduler to run a Task.
        • One freeRTOS Task, will toggle the LED every time it's activated by the freeRTOS Scheduler.
        • The Task is very simple. A LED is toggled, and the task yields to the RTOS scheduler for one second. In an ever lasting loop.

        • The effect is that the led will blink every 2 seconds:

          • LED toggle (CYBSP_USER_LED is available on all evaluation kits)

          • Yield for a second

        • During the Yield Delay, the task is inactive and the scheduler can execute other tasks. This is different to delay mechanisms that use MCU ticks to burn time. Those occupy the MCU for a second. The FreeRTOS vTaskDelay() task frees the MCU for a second.


      • Four Blog Posts on UART, RTOS Scheduling and Message Queues, AnyCloud MQTT Client  and Low Power

        • In the next 4 blogs, Jan implements a software design that answered all my questions on:
        • How I was going to implement my idea.
          • It describes how to:
            • Implement a UART Receiver for incoming serial data from the Arduino design.
            • Use FreeRTOS Scheduling, Messaging, Semaphores and Triggers.
        • This design is what I was envisioning for my Software design to implement my ides.
        • The blogs contain project code that I will be experimenting with as described in the next 4 sections.
        • I spent a tremendous amount of time going through the code and analyzing the logic and determined that I would use Jan's design for the core software implementation for my design.
        • Go through these blogs sequentially in the following order
          • I ran through this example to learn more about implementing a UART Receiver for incoming serial data from the Arduino design.
          • As stated by Jan, "The focus is on saving processor power. The design does not poll for incoming data. It yields all powers to the RTOS scheduler (possibly going to low power mode) until a trigger fires after a defined number of bites arrived at the UART input."
          • NOTE to self: I think , I should be able to put a write to and LED here and the LED will go into sleep mode () turn of and come on again when a vulue is written to it?
          • This blog shows how to:
            • Define a UART with RTOS Trigger Support.
              • Uses most of the code snippets describe in the document at PSoC 6 documentation
              • Explains what was changed and why.
            • Describes a FreeRTOS interrupt handler.
              • Written to release a task as soon as an agreed on number of characters arrive.
            • Describes the PSoC 6 Function to enable UART read with interrupt handling.

              • Describes the read function "UART_receive()"that is called everytime the buffer is filled.
            • Describes the FreeRTOS Task (uart_task.c) that wakes up when a buffer of UART data is received.
            • A helpful callout on PSoC 6 troubleshooting using the debugger on the code described.
          • There is no ModusToolbox example to play with, in this blog, but I did find one in the next blog.

          • On to the next blog that will describe the RTOS message queue implementation.
            • Describes: How to use an RTOS Message Queue to send data to a task.
            • Describes: How a task can retrieve a message from a queue
            • Describes: the advantages of using RTOS in this or any implementation.
            • Answers:  the question "What is gained by using an RTOS?"
          • The ModusToolbox example project is located at the end of the blog.
            • Download the ZIP archive 
            • Unzip the archive to a temporary directory.
            • All of the the project archive examples in Jan's blogs use the CY8CPROTO board, because he is implementing the software design on this kit.
            • This should not be a problem, since the kits look similar and ModusToolbox has the capabilities to update a project o a different BSP and Library support using the Modustoolboox Library Manager,
            • Refer to Appendix A-Importing and Converting a project to using the CY8CKIT
          • Jan states the following about the project:
            • The project is configured for:
              • UART 5.0 and 5.1 (the Debug USB COM port), 9600 / 8 / 1 / N
              • If you want to use other pins, check uart_task.h.

              • There's an example for pins 10.0 and 10.1 that you can use as inspiration...

              • I'll be checking it out.
          • Use the blog to analyze and run the code

            • This example contains two scheduler task:
              • UART (uart_task.c) - This code is explained in the previous blog post.
                • This blog describes two lines of code related to the Message queue, that are added to this code
                  • one line of code to create the message queue.
                  • one line of code to push a message onto the created queue.
              • telemetry (telemetry_receive_task.c) - task for handling the telemetry queue, that is created and populated by the UART task.
                • this task is quite simple and contains just a few lines of code.
                • in an infinite loop
                  • The queue is checked for a message.
                  • If found, it will toggle the user LED.
                  • An example of how to process the message is included, and commented out
            • The Tasks are created on the scheduler in main.c
            • To run this code I'll need to design some testing code to be implemented.
            • The design and testing will be done in future blog post.
          • Now onto the next blog that describes how to "react on a message on the RTOS queue and publish its payload on Amazon's AWS IoT MQTT service""
            • Refer to Appendix A-Importing and Converting a project to using the CY8CKIT
          • After getting the project into ModusToolbox follow the instructions at the end of the blog post to:
            • refresh Quick Panel
            • Update mqtt_client.h with Amazon certificates. I need to learn more about
              • getting an AWS account .. Free?
              • Creating an AWS IoT MQTT service. FREE?
            • Build the Application
              • ERRORS!!!


          • Then Connect the Arduino Design breadboard to the PSoC 6
            • Program the Python example on the Arduino, that sends 16 bytes once every time the Arduino resets
            • Run the Python script
          • if everything is working you should get the results described in the blog post
          • Jan plan was to support deep sleep in the UART task, but could not get it to work properly.
            • FreeRTOS allowed the controller to go in deep sleep
            • But lost received bytes when the UART trigger woke it up.
            • To continue on, Jam reconfigured FreeRTOS to not go into deep sleep.
          • Retuning back after studying up on "how to manage the PSoC peripherals when switching power modes", he was able to get the design working with deep sleep support.
          • At the beginning of the blog, there is an interesting flow diagram for describing Bloacking vs. Non-Blocking functions.
          • This blog post contains two sections
            • PSoC6 power mode management and UART
            • Configure UART to support wake-up from deep sleep after receiving 16 bytes on the RX pin

          • The ModusToolbox example project is located at the end of the blog.
              • Download the ZIP archive
              • Unzip the archive to a temporary directory.
              • All of the the project archive examples in Jan's blogs use the CY8CPROTO board, because he is implementing the software design on this kit.
              • Refer to Appendix A-Importing and Converting a project to using the CY8CKIT
          • Analyze the code using the blog post as a guide.
          • Run it and to observe the deep sleep if possible
  • This concludes my experiments with Jan Crumps PSoC 6 Blog Series


Connecting the OLED to the PSoC6

  • I've decided at this point to use the OLED on the Arduino project for now.
  • If time permits at the end of the Challenge, I can add it to the PSoC design and implement a Sleep mode OLED Display.
  • For now I'll see how the power modes work with The UART Task.


Conclusions and Summary



Before I received the actual kit for this challenge :

  • i started preparing an outline for an introduction blog and putting together my idea for the design challenge.
  • I started going thru the documents listed on the Challenge description Low Power IoT - Design Challenge  Document page
  • I ran the Preinstalled demo as I described
  • Then I ran and documented the "Run the "Hello World" example in  ModusToolbox" section
  • I then read through the User guide and Watch some training video's on the ModusToolbox.
  • I had worked with Eclipse on a prior roadtest for the NXP MCU, so I was familiar with the navigation and layouts.


Experimenting with the kit

  • II wrote this section of the blog, to document my experiments with the kit in order for me understand how I could implement the software for My Idea
  • I posed some areas that I thought I would need to research to implement My Idea.
  • I was introduced to a PSoC6 blog series by a fellow Element14 member Jan Crumps.

    • I heard about it in a comment he had posted on the Design Challenge page. I started to read his blog on using FreeRTOS to AWS MQTT (PSoC 6 and ModusToolbox: FreeRTOS to AWS MQTT). I was interested an interest to learn and Experiment with an Anycloud example.
    • It turned out to be addressing the many areas I had defined that I would need to implement the software for my idea.
    • This started me to thinking If I could use his design for my Idea.
    • I spent a tremendous amount of time going through the code and analyzing the logic and determined that I would use Jan's design for the core software implementation for my design.
    • Thank You... Jan Crumps.
    • He used the PSoC 6 Kit: CY8CPROTO-062-4343W  but according to his GitHub repo this kit is supported.
    • I spent a substantial amount of my time dissecting and learning from his blog post.



  • When running the quick start guide, I ran into a snag on step 2
      • Visit the kit website to download and install the required software.
    • The card should be, IMHO more descriptive on this step!
    • I didn't know what the required software to download and install
    • There was no link to the required software.
    • did I need to install ModusToolbox before connecting the cable?
    • Figured it out eventually by registering an account with the cypress website and  downloading and install ModusToolbox
    • This was a little frustrating to get started for a novice PSoC6 novice like me.
  • The ModusToolbox is easy to use and the documentation is easy to find what you need quickly
  • The blogs by Jan Crumps were an inspiration for me to use his UART FreeRTOS  Design into my design.





Appendix A - Importing and Converting a project to using the CY8CKIT

  • This appendix will describe how to load an existing Project from the filesystem.
  • It will also describe how to convert the project from the kit CY8CPROTO-062-4343W  that is used by Jan the CY8CKIT-062S2-43012
  • use the File/Open projects from file system. The following dialog will appear
  • The project is imported viewable in the project tab as shown above .
  • Open the Makefile
  • change TARGET=
    • to TARGET= CY8CKIT-062S2-43012
    • Here is the Active setting in the Makefile
  • Select the project on the "Project Explorer" and click the Library Manager in the "quick launch" window under tools.
  • Now the Library manager pops up as describe below
  • Note the BSP tab is displaying CY8CKIT-062S2-43012 in the list.
  • Select CY8CKIT-062S2-43012 and note that it turns bold with an (Active) indication.
  • you can Unselect Y8CPROTO-062-4343W, since you won't be using it.
  • The dialog should look like the picture below.
  • Select Update
  • The library manager will do it's thing and when it's done, the dropdown for active BSP contains CY8CKIT-062S2-43012.
  • Try to build. the project by selecting the Build <project name>
  • If successful plug in the USB to Prog3 USB connector
  • From the Launches section in "quick panel" select either <program name> Debug/Program  (KitProg3_MiniProg4))
  • Congratulations you have imported and converted to the kit to use the CY8CKIT-062S2-43012 Evaluation kit.




Technical Resources:


Getting Started Resources


RoadTest Reviews:

  • created by  shivam tiwari on Dec 14, 2020 8:15 PM, modified on Dec 31, 2020 4:16 AM
    • Total Score 51/60
    • Nice examples and pictures of Modus Toolbox
  • created by  Michal Zurek on Dec 21, 2020 7:43 PM, modified on Dec 30, 2020 11:29 AM
    • Total Score 53/60
    • Detailed scouring section, which was helpful.
    • Broken down into separate blogs (18 total) for each component  and 6 detailed projects
    • This is a well done Roadtest. I recommend it to beginners.
  • created by  Gordon Margulieux on Dec 20, 2020 4:36 AM, modified on Dec 20, 2020 5:06 AM
    • total score 43/60
    • Nice Unboxing section.
    • Nice pros/cons section
    • Do not use PCreator/WICED is the message here! He had issues. For this challenge it it highly recommended to use ModusToolbox, and I guess I see why!
    • Nice section on ModusToolkit setup and testing the example in the user manual Hello World.
    • He Didn't get a chance to run any of the other examples as the previous review did.

Other resources include:





Blog#1 - BPM Display - Introduction

Blog#3 - BPM Display - System Design