Skip navigation
Home > All Places > ModusToolbox > Blog > Authors mattl_01

ModusToolbox

5 Posts authored by: mattl_01

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

     https://github.com/cypresssemiconductorco/Code-Examples-for-ModusToolbox-Software

 

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 https://github.com/cypresssemiconductorco/mbed-os-example-capsense

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.

--Matt

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 (https://sourceforge.net/projects/srecord/) 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)

https://os.mbed.com/docs/mbed-os/v5.11/tools/installation-and-setup.html

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

https://os.mbed.com/teams/Cypress/

 

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:

 

CY8CKIT_062_BLE

CY8CKIT_062_WIFI_BT

CY8CKIT_062_4343W

CY8CPROTO_062_4343W

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.

DAPLink

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

mbedls

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

mbed-os/features/netsocket/WiFiInteface.h

 

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.

Windows:

⦁ Workspace PyOCD Path > Executable = pyocd-gdbserver

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

macOS:

⦁ Workspace PyOCD Path > Executable = pyocd-gdbserver

⦁ Workspace PyOCD Path > Folder = /Applications/MBEDCLI.app/Contents/Resources/miniconda/bin

Linux:

⦁ 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/MBEDCLI.app/Contents/Resources/miniconda/bin:/Applications/MBEDCLI.app/Contents/Resources/bin:/Applications/MBEDCLI.app/Contents/Resources/git/bin:/usr/local/bin

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:

https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads

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

 

Build

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

 

Program

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.

 

Debug

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.

 

--Matt

 

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?)

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.

    

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

     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

MTB_TOOLS=/cygdrive/c/Users/mdl/ModusToolbox_1.1/tools

 

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

PATH=$MTB_TOOLS/device-configurator-1.1:$PATH

# CapSense Configurator and CapSense Tuner

PATH=$MTB_TOOLS/capsense-configurator-1.1:$PATH

...

 

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.

 

--Matt

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 cypress.com 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 cypress.com). 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

 

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

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

MTB_TOOLS=/cygdrive/c/Users/mdl/ModusToolbox_1.1/tools

 

# Add the ModusToolbox Device Configurator

PATH=$MTB_TOOLS/device-configurator-1.1:$PATH

 

# To Add CapSense Configurator, uncomment the next line

#PATH=$MTB_TOOLS/capsense-configurator-1.1:$PATH

 

# To Add the Bluetooth Configurator, uncomment the next line

#PATH=$MTB_TOOLS/bt-configurator-1.1:$PATH

 

# To Add USB Configurator, uncomment the next line

#PATH=$MTB_TOOLS/usbdev-configurator-1.1:$PATH

 

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

 

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

PATH=$MTB_TOOLS/fw-loader-2.1/bin:$PATH

 

####### 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.

 

--Matt

Hello embedded designers. Thanks for your interest in ModusToolbox.  As this is a new release/platform, we would like to hear your feedback about your download/install experience.  While we have a number of machine/OS configurations that we test, there's nothing like hearing from users in the field.  Comments on the Installation Guide are also welcome.

 

--Matt