SWRU439M October   2015  – April 2022

 

  1.   Trademarks
  2. 1Introduction
  3. 2Overview
    1. 2.1 Sensor Controller and AUX Domain Hardware Overview
      1. 2.1.1 Hardware Functionality
      2. 2.1.2 Power and Clock Management
        1. 2.1.2.1 CC13x0 and CC26x0 Operation Modes
        2. 2.1.2.2 CC13x2 and CC26x2 Operation Modes
        3. 2.1.2.3 Communication With the System CPU Application
    2. 2.2 Sensor Controller Interface Driver
      1. 2.2.1 Tailored How-To-Use Guide
      2. 2.2.2 Doxygen Documentation
    3. 2.3 Sensor Controller Programming Model
    4. 2.4 Sensor Controller Tasks
      1. 2.4.1 Data Structures
      2. 2.4.2 Task Code Blocks
      3. 2.4.3 High-Level Program Flow
    5. 2.5 Task Testing and Debugging
    6. 2.6 Run-Time Logging
  4. 3Prerequisites
    1. 3.1 Driver
    2. 3.2 Examples
  5. 4Installation
    1. 4.1 Sensor Controller Studio for Windows
      1. 4.1.1 Update Service
    2. 4.2 Sensor Controller Studio CLI for Linux (64-Bit)
  6. 5Sensor Controller Studio Tutorials
  7. 6Sensor Controller Studio Walkthrough
    1. 6.1  Start Page and Navigation
    2. 6.2  Documentation
    3. 6.3  Open the Example
    4. 6.4  Project Panel
    5. 6.5  Task Panel Settings
    6. 6.6  Constants and Data Structures Panel
    7. 6.7  Task Code Editor Panels
    8. 6.8  I/O Mapping Panel
    9. 6.9  Code Generator Panel
    10. 6.10 Compiling Example Applications in IAR or CCS
    11. 6.11 Task Testing Panel
      1. 6.11.1 Task Testing Setup
      2. 6.11.2 Task Testing Session
      3. 6.11.3 Data Handling
      4. 6.11.4 Task Debugging Panel
    12. 6.12 Run-Time Logging Panel
      1. 6.12.1 Run-Time Logging Setup
      2. 6.12.2 Run-Time Logging Session
  8. 7References
  9. 8Revision History

2 Overview

Sensor Controller Studio is used to write, test and debug code for the CC26xx and CC13xx Sensor Controller. The tool generates a Sensor Controller Interface driver, which is a set of C source files to be compiled into the System CPU ( Arm®Cortex®-M3 and Arm Cortex-M4 processors) application. These source files contain the Sensor Controller firmware image, associated definitions, and generic functions that allow the System CPU application to control the Sensor Controller and exchange data.

The Sensor Controller is a small CPU core that is highly optimized for low power consumption and efficient peripheral operation. The Sensor Controller is located in the CC26xx and CC13xx auxiliary (AUX) power/clock domain and can perform simple background tasks autonomously and independently of the System CPU and the MCU domain power state. These tasks include the following:

  • Analog sensor polling, using ADC or comparator
  • Digital sensor polling, using SPI, I2C, or other protocols
  • Capacitive sensing using current source, comparator, and time-to-digital converter (TDC)
  • Waveform generation, for example for LCDs

The Sensor Controller is user programmable, using a simple programming language with syntax similar to C. This programmability allows for sensor polling and other tasks to be specified as sequential algorithms rather than static configuration of complex peripheral modules, timers, DMA, register-programmable state machines, event routing, and so on. The main advantages are:

  • Flexibility
  • Dynamic reuse of hardware resources
  • Ability to perform simple data processing without the need for dedicated hardware
  • Observability and debugging options

For example, the following code samples an analog sensor and notifies the System CPU application if needed:

// Select ADC input
adcSelectGpioInput(AUXIO_A_SENSOR_OUTPUT);

// Enable the ADC (fixed reference, 2.7 us sample time, manual trigger)
adcEnableSync(ADC_REF_FIXED, ADC_SAMPLE_TIME_2P7_US, ADC_TRIGGER_MANUAL);

// Sample the sensor and store the ADC value
adcGenManualTrigger();
adcReadFifo(output.adcValue);

// Disable the ADC
adcDisable();

// Notify the application if above the threshold
if (output.adcValue > SENSOR_THRESHOLD) {
    fwGenAlertInterrupt();
}

The Sensor Controller task algorithms can efficiently be evaluated, debugged, and verified using the Sensor Controller Studio. The resulting Sensor Controller Interface driver can be treated as a black box, and can be integrated painlessly into the System CPU application.

There is a command line interface (CLI) that can be used for build automation.