The CC2640R2F Platform¶

Hardware and Software Architecture¶

This section aims to introduce the different cores within the CC2640R2F, how they interact, and the firmware that runs on them. The information presented here should be considered as an overview. For detailed descriptions of the hardware described here, refer to the chapter 23 of the CC26xx Technical Reference Manual.

BLE-Stack Protocol Stack and Application Configurations¶

Figure 3. shows the platform that supports two different protocol stack and application configurations.

• Single device: The controller, host, profiles, and application are all implemented on the CC2640R2F as a true single-chip solution. This configuration is the simplest and most common when using the CC2640R2F. This configuration is used by most of TI’s sample projects. This configuration is the most cost-effective technique and provides the lowest-power performance.
• Simple network processor: The Simple Network Processor (SNP) implements the controller and host layers of the BLE-Stack. Additionally, the SNP exposes an interface for scheduling communication between the stack and an external MCU. This accelerates dual MCU designs because the application processor (AP) is only responsible for managing custom profiles and application code. Stack-related functionality, such as security, is implemented on the SNP. The SNP currently supports the peripheral and broadcaster GAP roles. Communication with the SNP is carried out through the SNP API. The SNP API is built on the Unified Network Processor Interface (UNPI), which supports UART and SPI transport layers. For more information, reference the Unified Network Processor Interface wiki page. TI also provides the SAP library, which implements a UNPI master and the SNP API. The SAP library can be ported to any TI-RTOS-capable processor, or used as a reference for developing a custom dual MCU solution. For a description of the SNP, see the CC2640R2F Simple Network Processor API Guide CC2640R2F Simple Network Processor API Guide.

Figure 3. Single-Device Processor and Simple Network Processor Configurations

Solution Platform¶

This section describes the various components that are installed with the BLE-Stack 3.00.00 and the directory structure of the protocol stack and any tools required for development. Figure 4. shows the BLE-Stack 3.00.00 development system.

Figure 4. Bluetooth low energy Stack Development System

The solution platform includes the following components:

• TI’s Real-Time Operating System (TI-RTOS) with the TI-RTOS kernel, optimized power management support, and peripheral drivers (SPI, UART, and so forth)
• CC26xxware DriverLib provides a register abstraction layer and is used by software and drivers to control the CC2640R2F SoC.
• The Bluetooth low energy protocol stack is provided in library form with parts of the protocol stack in the CC2640R2F ROM.
• Sample applications and profiles make starting development using both proprietary and generic solutions easier.

The following integrated development environments (IDEs) are supported:

• IAR Embedded Workbench for ARM
• Code Composer Studio™ (CCS)

Refer to the SDK release notes for the specific IDE versions supported by this release.

Example Software Architecture¶

The CC2640R2F Bluetooth low energy software environment consists of the following parts:

• TI-RTOS
• An application image
• A stack image

TI-RTOS is a real-time, pre-emptive, multithreaded operating system that runs the software solution with task synchronization. Both the application and Bluetooth low energy protocol stack exist as separate tasks within the RTOS. The Bluetooth low energy protocol stack has the highest priority. A messaging framework called indirect call (ICall) is used for thread-safe synchronization between the application and stack. Figure 5. shows the architecture.

Figure 5. Example Software Architecture

• The stack image includes the lower layers of the Bluetooth low energy protocol stack from the LL up to and including the GAP and GATT layers. Most of the Bluetooth low energy protocol stack code is provided as a library.
• The application image includes the profiles, application code, drivers, and the ICall module.

Directory Structure¶

The default install location is: C:\ti\simplelink_cc2640r2_sdk_x_xx_xx_xx.

The SDK installs to this location by default. For the purposes of this document, consider the above path to the BLE-Stack root directory; it will be omitted. All paths will be relative to the BLE-Stack root directory. Opening up the root install directory shows the new parent folders within the SDK, as shown in Table 1.

Working With Hex Files¶

BLE-Stack projects have build configurations in which the application and stack projects to produce an Intel^®-extended hex file in their respective output folders. These hex files lack overlapping memory regions and can be programmed individually with a flash programming tool, such as SmartRF Flash Programmer 2. You can combine the application and stack hex files into a super hex file manually or using free tools. Information on the Intel Hex standard.

One example for creating the super hex file is with the IntelHex python script hex_merge.py, available at here. To merge the hex files, install Python^® 2.7.x and add it to your system path environment variables.

The following is an example usage to create a merged simple_peripheral_cc2640r2lp.hex file consisting of the individual application and stack hex files:

1
2
3
4
5
6

C:\Python27\Scripts>python hexmerge.py \
    -o .\simple_peripheral_cc2640r2lp_merged.hex \
    -r 0000:1FFFF
    simple_peripheral_cc2640r2lp_app.hex:0000:1FFFF
    simple_peripheral_cc2640r2lp_stack.hex
    --overlap=error

Programming Internal Flash With the ROM Bootloader¶

The CC2640R2F internal flash memory can be programmed using the bootloader in the ROM of the device. Both UART and SPI protocols are supported. For more details on the programming protocol and requirements, see the Bootloader chapter of the CC26xx Technical Reference Manual.

Installing Code Composer Studio (CCS)¶

The CCS toolchain contains many features beyond the scope of this document. More information and documentation can be found here.

Check the BLE-Stack 3.00.00 release notes to see which CCS version to use and any required workarounds. Object code produced by CCS may differ in size and performance as compared to IAR produced object code.

The following procedure describes installing and configuring the correct version of CCS and the necessary tools.

1. Install Code Composer Studio for ARM

   • Download Code Composer Studio
   • Start the instllation process and accept the license agreement. It is recommended to install CCS in its default location.
   • In the Processor Support section, select Simplelink CC13xx and CC26xx Wireless MCUs.
   • Under the Debug Probes section, CCS will install support for TI XDS Debug Probe Support. This option supports the XDS110 debugger.
   • Start the installation by selecting Finish.

   Attention

   The version required is stated in the release notes.

2. Verify ARM Compiler Tools version

   • If needed, the CCS and ARM compiler versions can be verified by going to into Help -> About Code Composer Studio. Under the Installation Details button, you can determine the ARM Compiler Tools version. Please ensure this version satisfies the version requirements as stated in the release notes.
   • If an update is required, refer to Installing a Specific TI ARM Compiler for the procedure to install the required TI ARM Compiler version.

Installing a Specific TI ARM Compiler¶

To install a specific TI ARM Compiler, refer to the following steps and Figure 6.

1. Help -> Install New Software
2. Under the Work with: drop-down list, select Code Generation Tools Update
3. Uncheck Show only the latest versions of available software
4. Expand TI Compiler Update.
5. Select the desired ARM Compiler Tools version as stated in the release notes.
6. Press Next to complete the installation. You may have to restart CCS afterwards.

Figure 6. TI ARM Compiler Version in Code Composer Studio

Importing CCS projects¶

This section describes how to import and build an existing project and references the simple_peripheral project. All of the BLE-Stack 3.00.00 projects included in the development kit have a similar structure.

1. Open the CCS IDE from the Start Menu.

2. Create a workspace.

   Attention

   Ensure that the CCS workspace path does not contain a whitespace.

3. Import a CCS Project

   • Select Project -> Import CCS Projects...

   • Select search directory: <SDK_INSTALL_DIR>\examples\rtos\CC2640R2_LAUNCHXL\blestack\simple_peripheral\tirtos\ccs

   • CCS discovers several projects, each having a unique build configuration.

     • For this example, select simple_peripheral_cc2640r2lp_app and simple_peripheral_cc2640r2lp_stack_library

   • Select Finish

   Caution

   Similar as with all other TI projects, CCS needs to discover the Simplelink CC2640R2 SDK before BLE-Stack 3.00.00 projects can be imported.

4. Click Finish to import (see Figure 7.).

   

   Figure 7. Import CCS Projects

Discovering CCS products¶

Code Composer Studio automatically discovers the Simplelink CC2640R2 SDK if it installed in its default installation directory (c:/ti). Once discovered by CCS, it defines a build enviornment variable named COM_TI_SIMPLELINK_CC2640R2_SDK_INSTALL_DIR which is used by BLE-Stack 3.00.00 projects.

If a BLE-Stack 3.00.00 project is imported from a path other than what was specificed during the Simplelink CC2640R2 SDK installation, the COM_TI_SIMPLELINK_CC2640R2_SDK_INSTALL_DIR variable must be redefined after the import proceeduring at a project-by-project basis.

To redefine this variable:

1. Open the CCS project’s properties (Project -> Properties)

2. Navigate to Resource -> Linked Resources and edit COM_TI_SIMPLELINK_CC2640R2_SDK_INSTALL_DIR and have it point to your imported root directory location.

   

   Figure 8. Redefining COM_TI_SIMPLELINK_CC2640R2_SDK_INSTALL_DIR

BLE-Stack 3.00.00 CCS project build configurations¶

CCS Project Explorer

Figure 9. CCS Project Explorer

This and all BLE-Stack 3.00.00 project workspaces contain various projects and build configurations as shown in Table 6. *_StackLibrary build configurations build the stack as a library as described in Stack Library Configuration.

Click the project name in the file explorer to select the project as the active project. In Figure 9., the application is selected as the active project. Each of these projects produces a separate, downloadable image.

The simple_peripheral sample project is the primary sample application for the description of a generic application in this guide. The simple_peripheral project implements a basic Bluetooth low energy peripheral device including a GATT server with GATT services. This project can be used as a framework for developing peripheral-role applications.

Compiling and Download¶

For all build configurations, the stack project should always be built before the application project.

For projects where the stack is built as a library:

1. Build the stack library project.

   • Set the stack project as the active project.
   • Select Project -> Build All to build the stack project.

2. Build the application project.

   • Set the application project as the active project.
   • Select Project -> Build All to build the application project.

3. Load the whole application

   • Select Run -> Debug to download the application

Note

Application project that consume the stack in a library form will not have hard defined image boundaries.

After the initial build, if the stack project is not modified, only the applicaiton project needs to be rebuilt.

For projects where the stack and application are split images (not a library):

1. Build the stack project.

   • Set the stack project as the active project.
   • Select Project -> Build All to build the stack project.

2. Build the application project.

   • Set the application project as the active project.
   • Select Project -> Build All to build the application project.

3. Load the stack project

   • Set the stack project as the active project.
   • Select Run -> Debug to download the stack

4. Load the application project

   • Set the application project as the active project.
   • Select Run -> Debug to download the application

Note

The stack project defines the flash and RAM boundary parameters used by the application project. Any modifications to the stack project require a rebuild of the stack project, followed by a rebuild of the application project to use the new boundary settings. See Frontier Tool Operation.

After the initial build, if the stack project is not modified, only the applicaiton project needs to be rebuilt.

Sample applications that implement the Over the Air Download (OAD) firmware update capability require the Boot Image Manager (BIM) project to be built. Refer to the Over the Air Download (OAD) section for more details.

Accessing Preprocessor Symbols¶

Various C preprocessor symbols may need to be set or adjusted at the project level. The following procedure describes how to access and modify preprocessor symbols.

1. Open Project Properties
2. Navigate to Build -> ARM Compiler -> Predefined Symbols
3. Use the buttons highlighted in Figure 10. to add, delete, or edit a preprocessor.

Figure 10. CCS Predefined Symbols

Resetting the CC2640R2F in CCS¶

Select Board Reset from the reset menu.

Figure 11. CCS Board Reset

Additional training and support for CCS¶

For additional training and support with Code Composer Studio, refer to: Code Composer Studio Wiki Code Composer Studio Training

Installing IAR¶

The IAR toolchain contains many features beyond the scope of this document. More information and documentation can be found at IAR.com.

Check the BLE-Stack 3.00.00 release notes to see which IAR version to use and any required workarounds. Object code produced by IAR may differ in size and performance as compared to CCS produced object code.

The following procedure describes installing and configuring the correct version of IAR and the necessary tools.

1. Install IAR Embedded Workbench for ARM

   Download and install IAR EW ARM

   To get IAR, choose one of the following methods:

   • Download the IAR Embedded Workbench 30-Day Evaluation Edition – This version of IAR is free, has full functionality, and includes all of the standard features. The size-limited Kickstart evaluation option is not compatible with this SDK.
   • Purchase the full-featured version of IAR Embedded Workbench – For complete BLE application development using the CC2640R2F, TI recommends purchasing the complete version of IAR without any restrictions. You can find the information on purchasing the complete version of IAR.

   Attention

   The version required is stated in the release notes. Opening IAR project files with a previous version of IAR may cause project file corruption.

2. Show Build Messages

   TI recommends showing all the build output messages for full verbosity during building. To do this, go to Tools -> Options and set Show Build Messages to All (see Figure 12.)

   

   Figure 12. Show All Build Messages in IAR

Opening IAR Projects¶

This section describes how to open and build an existing project and references the simple_peripheral project. All of the BLE-Stack 3.00.00 projects included in the development kit have a similar structure.

1. Open the IAR Embedded Workbench IDE from the Start Menu.

2. Open an IAR workspace project: File -> Open -> Workspace...

   • For this example, select <SDK_INSTALL_DIR>\examples\rtos\CC2640R2_LAUNCHXL\blestack\simple_peripheral\tirtos\iar\simple_peripheral.eww

IAR Workspace Pane

Figure 13. IAR Workspace Pane

This workspace file is for the simple_peripheral project. When selected, the files associated with the workspace become visible in the Workspace pane on the left side of the screen. See Figure 13.

Select either project as the active project by clicking the respective tab at the bottom of the workspace pane. In Figure 13., the Overview tab is selected. This tab displays the file structure for both projects simultaneously. In this case, use the drop-down menu at the top of the workspace pane to select the active project. Each of these projects produces a separate downloadable object. The simple_peripheral sample project is the primary reference target for the description of a generic application in this guide. The simple_peripheral project implements a basic BLE-Stack peripheral device including a GATT server with GATT services. This project can be a framework for developing peripheral-role applications.

BLE-Stack 3.00.00 IAR project build configurations¶

This and all BLE-Stack 3.00.00 project workspaces contain various projects and build configurations as shown in Table 7. *_StackLibrary build configurations build the stack as a library as described in Stack Library Configuration.

Compile and Download¶

For all build configurations, the stack project should always be built before the application project.

For projects where the stack is built as a library:

1. Build the stack library project.

   • Select the stack project.
   • Select Project -> Make to build the stack.

2. Build the application project.

   • Select the application project.
   • Select Project -> Make to build the application.

3. Load the whole application

   • To download and debug: Select Project -> Download and Debug
   • To download without debugging: Select Project -> Download -> Download Active Application

Note

Application project that consume the stack in a library form will not have hard defined image boundaries.

After the initial build, if the stack project is not modified, only the applicaiton project needs to be rebuilt.

For projects where the stack and application are split images (not a library):

1. Build the stack project.

   • Select the stack project.
   • Select Project -> Make to build the stack.

2. Build the application project.

   • Select the application project.
   • Select Project -> Make to build the application.

3. Load the stack project.

   • Select Project -> Download -> Download Active Application to download the stack project.

4. Load the application project.

   • To download and debug: Select Project -> Download and Debug
   • To download without debugging: Select Project -> Download -> Download Active Application

Note

The stack project defines the flash and RAM boundary parameters used by the application project. Any modifications to the stack project require a rebuild of the stack project, followed by a rebuild of the application project to use the new boundary settings. See Frontier Tool Operation.

After the initial build, if the stack project is not modified, only the applicaiton project needs to be rebuilt.

When the application is downloaded (that is, flash memory programmed), you can debug with reflashing the device. Go to Project -> Debug without Downloading.

Sample applications that implement the Over the Air Download (OAD) firmware update capability require the Boot Image Manager (BIM) project to be built. Refer to the Over the Air Download (OAD) section for more details.

Accessing Preprocessor Symbols¶

Various C preprocessor symbols may need to be set or adjusted at the project level. The following procedure describes how to access and modify preprocessor symbols.

1. Open the Project’s Options and select the C/C++ Compiler Category.
2. Open the Preprocessor tab.
3. View the Defined symbols box (see Figure 14.).
4. Add or edit the preprocessor symbols.

Figure 14. IAR Defined Symbols Box

Resetting the CC2640R2F in IAR¶

Select the Board Reset option from the following Reset (back arrow) Debug Menu drop-down box.

Figure 15. IAR Board Reset

Flash¶

The flash is split into erasable pages of 4kB. The various sections of flash and their associate linker files are as follows.

• Simple NV (SNV) Area: used for nonvolatile memory storage by the GAP Bond Manager and also available for use by the application. See Using Simple NV for Flash Storage for configuring SNV. When configured, the SNV flash storage area is part of the stack image.
• Customer Configuration Area (CCA): the last sector of flash used to store customer-specific chip configuration (CCFG) parameters. The unused space of the CCA sector is allocated to the application project. See Customer Configuration Area.

For projects where the stack project builds a library:

• Application Image Code Space: used for the application project. This image is configured in the linker configuration file of the application: cc26xx_app.icf (IAR) and cc26xx_app.cmd (CCS).

For split image projects:

• Application Image Code Space: used for the application project. This image is configured in the linker configuration file of the application: cc26xx_app.icf (IAR) and cc26xx_app.cmd (CCS).
• Stack Image Code Space: use for the stack project. This image is configured in the linker configuration file of the stack: cc26xx_stack.icf (IAR) and cc26xx_ stack.cmd (CCS).

Flash Memory Map¶

This section describes the flash memory map at the system level for split image project configurations. As Figure 16. shows, the application linker file point to symbols with a solid arrow and the stack linker file point to symbols with a dashed arrow.

Figure 16. System Flash Map

Note

Projects that include the stack as a library, the Application Image Code Space and Stack Image Code Space are combined in the Application Image Code Space without any boundary requirements associated with split images.

Table 8. summarizes the Flash System Map definitions from Figure 16. and provides the associated linker definitions or symbols that can be found in the respective IDE linker files.

Table 8. Flash System Map Definitions¶

Symbol/Region	Meaning	Project	CCS Definition	IAR Definition
APP_FLASH_START	Start of flash/Start of App code image	App	FLASH_APP_BASE	FLASH_START
APP_FLASH_END	End of App code image. (ICALL_STACK0_ADDR-1)	App	ADJ_ICALL_STACK0_START - FLASH_APP_BASE	FLASH_END
STACK_FLASH_START	Start of Stack code image (ICALL_STACK0_ADDR)	Stack	FLASH_START
STACK_FLASH_END	End of Stack flash code image, including SNV	Stack	FLASH_SIZE - RESERVED_SIZE	FLASH_END
CCA sector	Last sector of flash. Contains the CCFG.	App	FLASH_LAST_PAGE
CCFG region	Location in CCA where Customer Configuration (CCFG) parameters are stored	App	Last 88 bytes (sizeof(ccfg_t) of CCA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// Device NV Items -    Range 0 - 0x1F
#define BLE_NVID_IRK                    0x02  //!< The Device's IRK
#define BLE_NVID_CSRK                   0x03  //!< The Device's CSRK
#define BLE_NVID_SIGNCOUNTER            0x04  //!< The Device's Sign Counter
#define BLE_LRU_BOND_LIST               0x05  //!< The Device's order of bond indexes in least recently used order

// Bonding NV Items -   Range  0x20 - 0x5F    - This allows for 10 bondings
#define BLE_NVID_GAP_BOND_START         0x20  //!< Start of the GAP Bond Manager's NV IDs
#define BLE_NVID_GAP_BOND_END           0x5f  //!< End of the GAP Bond Manager's NV IDs Range

// GATT Configuration NV Items - Range  0x70 - 0x79 - This must match the number of Bonding entries
#define BLE_NVID_GATT_CFG_START         0x70  //!< Start of the GATT Configuration NV IDs
#define BLE_NVID_GATT_CFG_END           0x79  //!< End of the GATT Configuration NV IDs

// Customer NV Items - Range  0x80 - 0x8F - This must match the number of Bonding entries
#define BLE_NVID_CUST_START             0x80  //!< Start of the Customer's NV IDs
#define BLE_NVID_CUST_END               0x8F  //!< End of the Customer's NV IDs

/*********************************************************************
* GLOBAL VARIABLES
*/
#define BUF_LEN 4
#define SNV_ID_APP 0x80
uint8 buf[BUF_LEN] ={0,};

static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1)
{
  // Initialize application
  SimpleBLEPeripheral_init();
  uint8 status = SUCCESS;

  status = osal_snv_read(SNV_ID_APP, BUF_LEN, (uint8 *)buf);
  if(status != SUCCESS)
  {
    Display_print1(dispHandle, 0, 0, "SNV READ FAIL: %d", status);
    //Write first time to initialize SNV ID
    osal_snv_write(SNV_ID_APP, BUF_LEN, (uint8 *)buf);
  }

  //Increment first element of array and write to SNV flash
  buf[0]++;
  status = osal_snv_write(SNV_ID_APP, BUF_LEN, (uint8 *)buf);
  if(status != SUCCESS)
  {
    Display_print1(dispHandle, 0, 0, "SNV WRITE FAIL: %d", status);
  }
  else
  {
    Display_print1(dispHandle, 0, 0, "Num of Resets: %d", buf[0]);
  }

  // Application main loop
  for (;;)
  {
  ...

RAM¶

Similar to flash, the RAM is shared between the application and stack projects. The RAM sections are configured in their respective linker files.

• Application Image: RAM space for the application and shared heaps. This image is configured in the linker configuration file of the application: cc26xx_app.icf (IAR) and cc26xx_app.cmd (CCS).
• Stack Image: RAM space for the .bss and .data sections of the stack. This image is configured in the linker configuration file of the stack: cc26xx_stack.icf (IAR) and cc26xx_stack.cmd (CCS).

RAM Memory Map¶

System Memory Map shows the system memory map for the default simple_peripheral project. This is a summary and the exact memory placement for a given compilation can be found in the simple_peripheral_app.map and simple_peripheral_stack.map files in the output folder in IAR or the FlashROM folder in CCS. In Check System Flash and RAM Usage With Map File, the application linker file contains symbols pointed with a solid arrow and the stack linker file contains symbols pointed with a dashed arrow.

System Memory Map

Figure 17. System Memory Map

////////////////////////////////////////////////////////////////////////////////
// Stack
define symbol STACK_SIZE            = 0x400;
define symbol STACK_START           = RAM_END + 1;
define symbol STACK_END             = STACK_START - STACK_SIZE;
//
define symbol STACK_TOP             = RAM_END + 1;
export symbol STACK_TOP;

// Runtime Stack
define block CSTACK with alignment = 8, size = STACK_SIZE { section .stack };
place at end of RAM { block CSTACK };

/* main() and Hwi, Swi stack size */
Program.stack = 1024;

/* Create global constant that points to top of stack */
/* CCS: Change stack size under Project Properties */
__STACK_TOP = __stack + __STACK_SIZE;

var HeapMem = xdc.useModule('xdc.runtime.HeapMem');

BIOS.heapSize = 1668;

//define pointer
uint8_t *pArray;
// Create dynamic pointer to array.
if (pArray = (uint8_t*)ICall_malloc(n*sizeof(uint8_t)))
{
//fill up array
}
else
{
//not able to allocate
}

ICall_free(pMsg->payload);

Frontier Tool¶

The frontier tool is a utility to automatically adjust the respective RAM and flash boundary address symbols shared between the application and stack projects built as split images. Project where the application consumes the stack as a library do not require the use of the Frontier Tool.

Frontier runs as a post-build step of the stack project, and adjusts the respective RAM and flash boundaries based on analysis of the stack linker and map files. No project files are modified by the frontier tool. The frontier tool does not modify any source code or perform any compiler or linker optimization; the tool adjusts and updates the respective flash and RAM boundary addresses, located in the compiler and linker configuration files used by the application and stack projects.

The frontier tool is installed to the following path within the SDK: <SDK_INSTALL_DIR>\examples\rtos\CC2640R2_LAUNCHXL\blestack\tools\frontier\frontier.exe

The python source for this tool is also included.

Table 10. shows the boundary address symbols updated by the frontier tool.

All sample application projects are, by default, configured to use the frontier tool; thus, no user configuration of the frontier tool is required. The boundary files may be updated when the stack configuration is changed, or when any files are updated in the stack project that result in a change in the size of the stack image. It is therefore required to rebuild the application project anytime the stack project is built.