Use a PCR Module to Rapidly Develop Accurate, Low-Power Radar-Based Sensors

By Stephen Evanczuk

Contributed By Digi-Key's North American Editors

High resolution 3D sensor technology has emerged as a critical capability in applications ranging from gesture-based user interfaces to automotive driver assistance systems (ADAS). Among 3D sensor alternatives, radar technology offers features and performance characteristics unavailable with more conventional approaches. Still, developers find it challenging to maintain high accuracy and low power consumption, and there is a steep learning curve for deploying radar sensor systems.

Using an advanced technology called pulsed coherent radar (PCR), Acconeer has developed an integrated radar sensor that provides the combination of high accuracy and low power consumption required for smart products and other emerging applications.

This article describes Acconeer’s PCR approach before introducing a radar module and associated development platform based on its technology. It then demonstrates how to use the platform to start designing sophisticated radar sensor technology into a wide range of systems including battery-powered smart products.

Why radar?

Able to provide millimeter scale resolution at high update frequencies, radar-based sensing technology can deliver highly accurate distance and motion data needed by applications for precision object detection, range measurement, position tracking, and more. By incorporating radar technology into smart product designs, however, developers are typically forced to choose between low power or high accuracy. As developers look to apply this technology in designs with limited power budgets, application requirements drive a growing need to maintain accuracy even at reduced power levels.

Advanced radar technology

An alternative approach to conventional radar designs offers a solution that combines the accuracy of sophisticated coherent radar methods with the reduced power requirements of pulsed radar systems. Pulsed radar designs shut down the transmitter between pulses, achieving lower power consumption but with lower accuracy. In contrast, coherent radar systems transmit a continuous train of pulses, using precise phase measurements of return signals to provide high accuracy measurements but at the cost of high power consumption.

Acconeer combines these techniques in the PCR technology used in its A111 radar sensor. Like pulsed radar, PCR technology keeps the radio turned off between transmissions, but as in coherent systems, the transmissions are bursts of pulses, or sweeps, with a known starting phase (Figure 1).

Graph of Acconeer A111 pulsed coherent radar device

Figure 1: The Acconeer A111 pulsed coherent radar device achieves high accuracy at low power by transmitting long or short wavelets with carefully controlled pulse repetition frequency (PRF), center frequency (fRF), and pulse duration (tpulse). (Image source: Acconeer)

By tuning parameters such as pulse duration (tpulse), developers can optimize signals for different applications. For example, developers can reduce tpulse to generate the shorter wavelets needed to resolve small movements of individual fingers in a gesture-controlled user interface application. Conversely, they can increase tpulse to generate the high energy long wavelets needed to resolve obstructions in an automotive self-parking application.

Despite the attraction of PCR’s technical advantages, few developers without significant expertise in radar technology could afford the time required to implement this technology on their own. Besides the challenges of designing an efficient millimeter wave (mmWave) front-end stage, developers would face the considerable challenge of converting the acquired amplitude and phase data of reflected radar signals into useful measurements of distance and motion.

Designed to address these challenges, the Acconeer PCR-based A111 radar device and associated software development kit (SDK) abstract the low-level details of radar signal processing, delivering data in forms that can be more easily consumed by applications.

Integrated PCR front-end simplifies development

Simplifying the hardware aspects of PCR technology implementation, the Acconeer A111 provides a complete radar sensor that integrates a mmWave radar front-end with an antenna-in-package (AIP) in a 5.2 x 5.5 x 0.88 millimeter (mm) flip chip chip-scale package (fcCSP) (Figure 2).

Diagram of Acconeer A111 integrates a millimeter wave (mmWave) radio

Figure 2: The Acconeer A111 integrates a millimeter wave (mmWave) radio, digital subsystem, timing, and power management to provide a complete front-end solution for radar sensing using pulse coherent radar technology. (Image source: Acconeer)

Along with its mmWave radio frequency (RF) subsystem, the A111 includes a digital subsystem with dedicated memory areas for program and data for managing the mmWave radio subsystem. Separate subsystems provide phase-locked loop (PLL) timing and power management features including power-on reset (PoR) and separate low dropout (LDO) regulators for the device’s multiple power domains.

With its picosecond scale time resolution, the device is typically capable of measuring distance with millimeter accuracy over a range of up to two meters. At the same time, its low power consumption allows developers to use it in battery-powered devices. Because of the A111 sensor’s high level of integration, developers need only a few additional components besides a host microcontroller to implement radar sensing in their designs (Figure 3). Because the A111 can operate without an aperture for its radar signals, developers can incorporate it in smart products without compromising existing ingress protection requirements.

Diagram of Acconeer A111 microcontroller

Figure 3: Because it integrates all the radio frequency and digital subsystems required for a radar front-end, the A111 enables developers to implement radar sensing with only a few additional components beyond the host microcontroller. (Image source: Acconeer)

The A111 functions as a conventional serial peripheral interface (SPI) device with serial data input (MOSI), serial output (MISO), clock (SPI_CLK), and slave select signal (SS) ports. The A111’s ENABLE pin allows developers to use the microcontroller to power up or power down the device, while the INTERRUPT pin allows developers to use the A111 to notify the microcontroller when measurements are ready.

By using ENABLE to turn off the A111 between pulse sweep transmissions, developers can reduce A111 power consumption to 66 µA (typical). Conversely, while the A111 performs a series of sweeps and measurements, developers can place the host microcontroller in a low-power sleep state using the wait-for-interrupt (WFI) instruction available in Arm® Cortex®-M-based processors to wake the microcontroller when the A111 completes its operations and issues an interrupt.

Designers can add their own precision clock source, or rely on the device’s internal clock circuit which only requires an external crystal oscillator such as EPSON's TSX-3225. The device works with a single 1.8 volt supply for RF (VIO_1 and VIO_2) and digital (VIO_3). Alternatively, developers can use separate supply sources for more power intensive applications. The VIO_Na and VIO_Nb pins shown in Figure 3 are connected within the device and Acconeer recommends that they be connected externally on the pc board as well.

Intended purely as a radar front-end device, A111 itself stores no firmware permanently, relying instead upon the host microcontroller to upload all sensor software as well as handle A111 sensor initiation, configuration, sweep acquisition and signal processing. Consequently, the choice of companion microcontroller is an important design decision. Acconeer notes that an Arm Cortex-M4-based microcontroller such as STMicroelectronics' STM32L476 or Nordic Semiconductor's NRF52840 is typically sufficient for handling relatively static operations such as distance measurement or basic motion detection. For more dynamic applications such as breathing motion detection or object tracking, Acconeer recommends an Arm Cortex-M7-based microcontroller such as Microchip Technology's ATSAME70. As such, Acconeer pairs the A111 PCR device with an ATSAME70 in its XM112 radar module.

The Acconeer XM112 module combines the A111 radar sensor with a Microchip Technology ATSAME70 microcontroller to provide a complete radar subsystem. Developers can use the XM112 together with the XB112 breakout board to immediately begin evaluating the A111 and building PCR-based software applications. Alternatively, developers can simply plug the 30-pin 24 mm x 16 mm module into their own PCBs to add a self-contained PCR subsystem to their custom designs. To perform radar sensing, developers can control the XM112 module through a serial connection with their development systems or execute software directly on the XM112 host ATSAME70 microcontroller.

Software interface

Regardless of hardware systems configuration, radar measurements are programmatically controlled using the Acconeer radar system software (RSS) application programming interface (API). The RSS API serves as the sole software interface for working with the A111. Acconeer does not support access to A111 registers through typical SPI transactions due to the complexity of the design, calibration, and processing requirements. Instead, all operations work through the RSS which provides A111 detector functionality. These detectors in turn build on lower level services through APIs for accessing different types of preprocessed data from the A111. These services include:

  • Envelope service which provides information about the amplitude of sensor data
  • Power Bin service which provides amplitude information in predefined range intervals (bins)
  • IQ service which provides IQ modulated data, allowing use phase and amplitude measurements to generate more accurate measurements than possible with amplitude only Envelope and Power Bin services

Within these services, developers can take advantage of special features for power management, range enhancement, and self-calibration, among others.

For power management, developers can place the device in one of four power modes that reduce power consumption by reducing the sensor update rate. The range enhancement feature allows developers to perform long sweeps that extend the measurement range up to 7 meters (m) under some conditions. Finally, the self-calibration feature allows developers to reduce power consumption associated with the calibration cycle that occurs whenever the device starts up. In battery-powered designs for the IoT, for example, devices may routinely be put in sleep mode or even turned off during extended periods of inactivity.

In many cases, performing self-calibration at the beginning of each wake cycle is unnecessary and simply wastes power. Instead, developers can store values from an initial calibration cycle in non-volatile memory and use those values to perform measurements reliably during later waking periods.

For production code development, engineers can download the full software distribution package which provides sample application source code along with the Acconeer SDK. The SDK includes header files along with precompiled RSS libraries for Arm Cortex-M4 and Arm Cortex-M7 microcontrollers in separate microcontroller-specific distributions.

The SDK’s C-language code samples illustrate the basic design pattern for using the RSS API to perform radar measurements in production applications. For any type of measurement, this design pattern begins by initializing the system and RSS, calling three routines in sequence:

  • acc_driver_hal_init(), which initializes the board and GPIOs
  • acc_driver_hal_get_implementation(), which instantiates a C structure, acc_hal_t, that holds sensor and board properties as well as pointers to runtime handlers for memory allocation, semaphores, and others.
  • acc_rss_activate_with_hal(), which activates the Radar System Services (RSS) utility itself

From this point, a typical measurement involves creating an object called a configuration that contains parameters associated with the sensor and the particular measurement. That configuration is then used to call an RSS API function to create the desired detector or service. The sample code illustrates the application of this design pattern in a module, example_detector_distance_peak.c, for creating and working with a distance peak detector. In that module, the main() routine (Listing 1) first performs initialization and RSS activation before creating a configuration (acc_detector_distance_peak_configuration_create()) and using that configuration to create a peak detector (distance_peak_detect_with_blocking_calls()).

Copy
int main(void)
{
   acc_detector_distance_peak_status_t detector_status;
 
   printf("Acconeer software version %s\n", ACC_VERSION);
   printf("Acconeer RSS version %s\n", acc_rss_version());
 
   if (!acc_driver_hal_init())
   {
      return EXIT_FAILURE;
   }
 
   acc_hal_t hal = acc_driver_hal_get_implementation();
 
   if (!acc_rss_activate_with_hal(&hal))
   {
      return EXIT_FAILURE;
   }
 
   //Create the detector configuration
   acc_detector_distance_peak_configuration_t distance_configuration = acc_detector_distance_peak_configuration_create();
 
   if (distance_configuration == NULL)
   {
      fprintf(stderr, "\nacc_service_distance_configuration_create() failed");
      return EXIT_FAILURE;
   }
 
   //Run distance peak detection in blocking mode
   detector_status = distance_peak_detect_with_blocking_calls(distance_configuration);
   if (detector_status != ACC_DETECTOR_DISTANCE_PEAK_STATUS_SUCCESS)
   {
      fprintf(stderr, "Running distance peak detector in blocking mode failed");
      acc_detector_distance_peak_configuration_destroy(&distance_configuration);
      acc_rss_deactivate();
      return EXIT_FAILURE;
   }
 
   detector_status = distance_peak_detect_with_blocking_calls_with_estimated_threshold(distance_configuration);
   if (detector_status != ACC_DETECTOR_DISTANCE_PEAK_STATUS_SUCCESS)
   {
      fprintf(stderr, "Running distance peak detector in blocking mode with estimated threshold failed");
      acc_detector_distance_peak_configuration_destroy(&distance_configuration);
      acc_rss_deactivate();
      return EXIT_FAILURE;
   }
 
   acc_detector_distance_peak_configuration_destroy(&distance_configuration);
 
   acc_rss_deactivate();
 
   return EXIT_SUCCESS;
}

Listing 1: Sample code included in the Acconeer software development kit distribution demonstrates the basic design pattern for using Acconeer Radar System Services (RSS) application programming interface (API) to perform measurements with the Acconeer A111 sensor. (Code source: Acconeer)

In this sample application, the actual distance peak measurements are performed in the routine distance_peak_detect_with_blocking_calls(). This routine in turn uses the RSS API function acc_detector_distance_peak_get_next() to retrieve the actual measurement data from the A111 device (Listing 2). In this case, the code places the acc_detector_distance_peak_get_next() measurement routine in a loop, decrementing a counter, detection_runs, until it performs 100 measurements.

Copy
   detector_status = acc_detector_distance_peak_activate(handle);
 
   if (detector_status == ACC_DETECTOR_DISTANCE_PEAK_STATUS_SUCCESS)
   {
      uint_fast8_t detection_runs = 100;
 
      while (detection_runs > 0)
      {
         reflection_count = 10;
 
         detector_status = acc_detector_distance_peak_get_next(handle,
                                                               reflections,
                                                               &reflection_count,
                                                               &result_info);
 
         if (detector_status == ACC_DETECTOR_DISTANCE_PEAK_STATUS_SUCCESS)
         {
            printf("Distance detector: Reflections: %u. Seq. nr: %u. (%u-%u mm): %s\n",
                   (unsigned int)reflection_count,
                   (unsigned int)result_info.sequence_number,
                   (unsigned int)(start_m * 1000.0f),
                   (unsigned int)(end_m * 1000.0f),
                   format_distances(reflection_count, reflections, metadata.free_space_absolute_offset));
         }
         else
         {
            fprintf(stderr, "reflection data not properly retrieved\n");
         }
 
         detection_runs--;
      }

Listing 2: In performing measurements with the Acconeer A111 sensor, developers work exclusively through the Acconeer Radar System Services (RSS) application programming interface (API), calling RSS routines such as acc_detector_distance_peak_get_next() that handle the low-level details as shown in this snippet. (Code source: Acconeer)

Developers can implement their own detectors, using service calls in a similar design pattern for initialization, RSS activation, configuration creation, and service instantiation. For example, to use the Envelope Service, developers would call acc_service_envelope_configuration_create() to create the necessary configuration and use that configuration as a parameter in calling acc_service_create() to instantiate a service object.

By exploring the C-language sample code, developers can quickly gain experience using the RSS API to build specialized radar applications with custom detectors. To help developers more rapidly gain familiarity with radar-based sensing in general and RSS services in particular, Acconeer also provides sample code in its Python Exploration Kit software repository.

Designed to work with the Acconeer SDK and evaluation kits such as the XM112, the Python Exploration Kit helps developers take advantage of Python’s productivity advantages for working with RSS services and detectors. Along with basic examples, the kit provides sample code for implementing very sophisticated measurement applications including detecting breathing patterns in sleeping subjects, using phase information to track relative movements, detecting approaching obstacles, and more.

Conclusion

Radar sensing technology can provide highly accurate measurements for distance and motion applications. However, it can consume a lot of power to achieve accuracy, and it typically involves a complex design process. By implementing PCR, the Acconeer A111 integrated radar sensor provides the combination of high accuracy and low power consumption required for smart products and other emerging applications. The companion software development kit (SDK) abstracts the complexity of radar signal processing, providing the kind of higher level data required at the application level.

Using the SDK with an A111-based development board, engineers can rapidly gain experience in radar sensing technology and quickly implement sophisticated applications able to discern objects and track movement with millimeter resolution.

Disclaimer: The opinions, beliefs, and viewpoints expressed by the various authors and/or forum participants on this website do not necessarily reflect the opinions, beliefs, and viewpoints of Digi-Key Electronics or official policies of Digi-Key Electronics.

About this author

Stephen Evanczuk

Stephen Evanczuk has more than 20 years of experience writing for and about the electronics industry on a wide range of topics including hardware, software, systems, and applications including the IoT. He received his Ph.D. in neuroscience on neuronal networks and worked in the aerospace industry on massively distributed secure systems and algorithm acceleration methods. Currently, when he's not writing articles on technology and engineering, he's working on applications of deep learning to recognition and recommendation systems.

About this publisher

Digi-Key's North American Editors