sundp
/
WL55JC_AS923
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
WL55JC_AS923/TOF/App/app_tof.c

292 lines
8.5 KiB
C
Raw Blame History

/**
******************************************************************************
* @file : app_tof.c
* @author : IMG SW Application Team
* @brief : This file provides code for the configuration
* of the STMicroelectronics.X-CUBE-TOF1.3.4.2 instances.
******************************************************************************
*
* @attention
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "app_tof.h"
#include "main.h"
#include <stdio.h>
#include "53l8a1_ranging_sensor.h"
#include "app_tof_pin_conf.h"
#include "stm32wlxx_nucleo.h"
/*
* The purpose of this sample application is to showcase the threshold detection
* functionality of this device.
*
* When the device detects a target that match the configuration an IT is generated
* and the host will start printing the measurement information on the serial connection (UART).
*
* Here is the default configuration:
*
* ITConfig.Criteria = RS_IT_IN_WINDOW;
* ITConfig.LowThreshold = 200; // distance in mm
* ITConfig.HighThreshold = 600; // distance in mm
*
* Other availables interrupt generation criteria for this device are:
*
* - RS_IT_DEFAULT // IT if new measurement is ready (no thresholds)
* - RS_IT_IN_WINDOW // IT if distance > thresh_high
* - RS_IT_OUT_OF_WINDOW // IT if distance < LowThreshold OR distance > HighThreshold
* - RS_IT_BELOW_LOW // IT if distance <= LowThreshold
* - RS_IT_ABOVE_HIGH // IT if distance > HighThreshold
* - RS_IT_EQUAL_LOW // IT if distance == LowThreshold
* - RS_IT_NOT_EQUAL_LOW // IT if distance != LowThreshold
*/
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define TIMING_BUDGET (30U) /* 5 ms < TimingBudget < 100 ms */
#define RANGING_FREQUENCY (10U) /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
#define LOW_THRESHOLD (200U)
#define HIGH_THRESHOLD (600U)
/* Private variables ---------------------------------------------------------*/
static RANGING_SENSOR_Capabilities_t Cap;
static RANGING_SENSOR_ProfileConfig_t Profile;
static RANGING_SENSOR_Result_t Result;
static int32_t status = 0;
volatile uint8_t ToF_EventDetected = 0;
/* Private function prototypes -----------------------------------------------*/
static void MX_53L8A1_ThresholdDetection_Init(void);
static void MX_53L8A1_ThresholdDetection_Process(void);
static void print_result(RANGING_SENSOR_Result_t *Result);
void MX_TOF_Init(void)
{
/* USER CODE BEGIN SV */
/* USER CODE END SV */
/* USER CODE BEGIN TOF_Init_PreTreatment */
/* USER CODE END TOF_Init_PreTreatment */
/* Initialize the peripherals and the TOF components */
MX_53L8A1_ThresholdDetection_Init();
/* USER CODE BEGIN TOF_Init_PostTreatment */
/* USER CODE END TOF_Init_PostTreatment */
}
/*
* LM background task
*/
void MX_TOF_Process(void)
{
/* USER CODE BEGIN TOF_Process_PreTreatment */
/* USER CODE END TOF_Process_PreTreatment */
MX_53L8A1_ThresholdDetection_Process();
/* USER CODE BEGIN TOF_Process_PostTreatment */
/* USER CODE END TOF_Process_PostTreatment */
}
static void MX_53L8A1_ThresholdDetection_Init(void)
{
/* Initialize Virtual COM Port */
BSP_COM_Init(COM1);
/* Sensor reset */
HAL_GPIO_WritePin(VL53L8A1_PWR_EN_C_PORT, VL53L8A1_PWR_EN_C_PIN, GPIO_PIN_RESET);
HAL_Delay(2);
HAL_GPIO_WritePin(VL53L8A1_PWR_EN_C_PORT, VL53L8A1_PWR_EN_C_PIN, GPIO_PIN_SET);
HAL_Delay(2);
HAL_GPIO_WritePin(VL53L8A1_LPn_C_PORT, VL53L8A1_LPn_C_PIN, GPIO_PIN_RESET);
HAL_Delay(2);
HAL_GPIO_WritePin(VL53L8A1_LPn_C_PORT, VL53L8A1_LPn_C_PIN, GPIO_PIN_SET);
HAL_Delay(2);
printf("\033[2H\033[2J");
printf("53L8A1 Threshold Detection demo application\n");
printf("Sensor initialization...\n");
status = VL53L8A1_RANGING_SENSOR_Init(VL53L8A1_DEV_CENTER);
if (status != BSP_ERROR_NONE)
{
printf("VL53L8A1_RANGING_SENSOR_Init failed\n");
while (1);
}
}
static void MX_53L8A1_ThresholdDetection_Process(void)
{
uint32_t Id;
RANGING_SENSOR_ITConfig_t ITConfig;
VL53L8A1_RANGING_SENSOR_ReadID(VL53L8A1_DEV_CENTER, &Id);
VL53L8A1_RANGING_SENSOR_GetCapabilities(VL53L8A1_DEV_CENTER, &Cap);
Profile.RangingProfile = RS_PROFILE_4x4_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET;
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */
/* set the profile if different from default one */
VL53L8A1_RANGING_SENSOR_ConfigProfile(VL53L8A1_DEV_CENTER, &Profile);
/* threshold parameters */
ITConfig.Criteria = RS_IT_IN_WINDOW;
ITConfig.LowThreshold = LOW_THRESHOLD; /* mm */
ITConfig.HighThreshold = HIGH_THRESHOLD; /* mm */
VL53L8A1_RANGING_SENSOR_ConfigIT(VL53L8A1_DEV_CENTER, &ITConfig);
status = VL53L8A1_RANGING_SENSOR_Start(VL53L8A1_DEV_CENTER, RS_MODE_ASYNC_CONTINUOUS);
if (status != BSP_ERROR_NONE)
{
printf("VL53L8A1_RANGING_SENSOR_Start failed\n");
while (1);
}
printf("\033[2H\033[2J");
printf("53L8A1 Threshold Detection demo application\n");
printf("-------------------------------------------\n\n");
printf("please put a target between %d and %d millimeters from the sensor\n",
LOW_THRESHOLD, HIGH_THRESHOLD);
while (1)
{
/* interrupt mode */
if (ToF_EventDetected != 0)
{
ToF_EventDetected = 0;
status = VL53L8A1_RANGING_SENSOR_GetDistance(VL53L8A1_DEV_CENTER, &Result);
if (status == BSP_ERROR_NONE)
{
print_result(&Result);
}
}
}
}
static void print_result(RANGING_SENSOR_Result_t *Result)
{
int8_t i;
int8_t j;
int8_t k;
int8_t l;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
printf("%c[2H", 27); /* clear screen */
printf("53L8A1 Threshold Detection demo application\n");
printf("-------------------------------------------\n\n");
printf("Cell Format :\n\n");
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
printf(" \033[38;5;10m%20s\033[0m : %20s\n", "Distance [mm]", "Status");
if ((Profile.EnableAmbient != 0) || (Profile.EnableSignal != 0))
{
printf(" %20s : %20s\n", "Signal [kcps/spad]", "Ambient [kcps/spad]");
}
}
printf("\n\n");
for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (i = 0; i < zones_per_line; i++) /* number of zones per line */
{
printf(" -----------------");
}
printf("\n");
for (i = 0; i < zones_per_line; i++)
{
printf("| ");
}
printf("|\n");
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j + k].NumberOfTargets > 0)
printf("| \033[38;5;10m%5ld\033[0m : %5ld ",
(long)Result->ZoneResult[j + k].Distance[l],
(long)Result->ZoneResult[j + k].Status[l]);
else
printf("| %5s : %5s ", "X", "X");
}
printf("|\n");
if ((Profile.EnableAmbient != 0) || (Profile.EnableSignal != 0))
{
/* Print Signal and Ambient */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j + k].NumberOfTargets > 0)
{
if (Profile.EnableSignal != 0)
{
printf("| %5ld : ", (long)Result->ZoneResult[j + k].Signal[l]);
}
else
printf("| %5s : ", "X");
if (Profile.EnableAmbient != 0)
{
printf("%5ld ", (long)Result->ZoneResult[j + k].Ambient[l]);
}
else
printf("%5s ", "X");
}
else
printf("| %5s : %5s ", "X", "X");
}
printf("|\n");
}
}
}
for (i = 0; i < zones_per_line; i++)
{
printf(" -----------------");
}
printf("\n");
}
#ifdef __cplusplus
}
#endif
Reference in New Issue View Git Blame Copy Permalink