alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-09-20 10:46:02 -04:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

temperature_sensor: Add new interface and reference counts so that phy and driver can use together

Browse Source
This commit is contained in:
Cao Sen Miao 2023-07-24 12:35:30 +08:00
parent c9c7322678
commit 6bb129620f
8 changed files with 229 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
components/driver/esp32c3/include/driver/temp_sensor.h
View File

@ -23,6 +23,21 @@ typedef enum {
TSENS_DAC_DEFAULT = TSENS_DAC_L2, TSENS_DAC_DEFAULT = TSENS_DAC_L2,
} temp_sensor_dac_offset_t; } temp_sensor_dac_offset_t;
typedef struct {
int index;
int offset;
int set_val;
int range_min;
int range_max;
int error_max;
} tsens_dac_offset_t;
extern const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX];
#define TSENS_ADC_FACTOR (0.4386)
#define TSENS_DAC_FACTOR (27.88)
#define TSENS_SYS_OFFSET (20.52)
/** /**
* @brief Configuration for temperature sensor reading * @brief Configuration for temperature sensor reading
*/ */

14
components/driver/esp32c3/rtc_tempsensor.c
View File

@ -25,20 +25,8 @@
static const char *TAG = "tsens"; static const char *TAG = "tsens";
#define TSENS_XPD_WAIT_DEFAULT 0xFF /* Set wait cycle time(8MHz) from power up to reset enable. */ #define TSENS_XPD_WAIT_DEFAULT 0xFF /* Set wait cycle time(8MHz) from power up to reset enable. */
#define TSENS_ADC_FACTOR (0.4386)
#define TSENS_DAC_FACTOR (27.88)
#define TSENS_SYS_OFFSET (20.52)
typedef struct { const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX] = {
int index;
int offset;
int set_val;
int range_min;
int range_max;
int error_max;
} tsens_dac_offset_t;
static const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX] = {
/* DAC Offset reg_val min max error */ /* DAC Offset reg_val min max error */
{TSENS_DAC_L0, -2, 5, 50, 125, 3}, {TSENS_DAC_L0, -2, 5, 50, 125, 3},
{TSENS_DAC_L1, -1, 7, 20, 100, 2}, {TSENS_DAC_L1, -1, 7, 20, 100, 2},

15
components/driver/esp32s2/include/driver/temp_sensor.h
View File

@ -34,6 +34,21 @@ typedef struct {
uint8_t clk_div; /*!< Default: 6 */ uint8_t clk_div; /*!< Default: 6 */
} temp_sensor_config_t; } temp_sensor_config_t;
typedef struct {
int index;
int offset;
int set_val;
int range_min;
int range_max;
int error_max;
} tsens_dac_offset_t;
extern const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX];
#define TSENS_ADC_FACTOR (0.4386)
#define TSENS_DAC_FACTOR (27.88)
#define TSENS_SYS_OFFSET (20.52)
/** /**
* @brief temperature sensor default setting. * @brief temperature sensor default setting.
*/ */

14
components/driver/esp32s2/rtc_tempsensor.c
View File

@ -25,20 +25,8 @@
static const char *TAG = "tsens"; static const char *TAG = "tsens";
#define TSENS_XPD_WAIT_DEFAULT 0xFF /* Set wait cycle time(8MHz) from power up to reset enable. */ #define TSENS_XPD_WAIT_DEFAULT 0xFF /* Set wait cycle time(8MHz) from power up to reset enable. */
#define TSENS_ADC_FACTOR (0.4386)
#define TSENS_DAC_FACTOR (27.88)
#define TSENS_SYS_OFFSET (20.52)
typedef struct { const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX] = {
int index;
int offset;
int set_val;
int range_min;
int range_max;
int error_max;
} tsens_dac_offset_t;
static const tsens_dac_offset_t dac_offset[TSENS_DAC_MAX] = {
/* DAC Offset reg_val min max error */ /* DAC Offset reg_val min max error */
{TSENS_DAC_L0, -2, 5, 50, 125, 3}, {TSENS_DAC_L0, -2, 5, 50, 125, 3},
{TSENS_DAC_L1, -1, 7, 20, 100, 2}, {TSENS_DAC_L1, -1, 7, 20, 100, 2},

59
components/esp_hw_support/include/esp_private/sar_periph_ctrl.h
View File

@ -14,63 +14,32 @@
#pragma once #pragma once
#include <stdint.h>
#include <stdbool.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
* Initialise SAR related peripheral register settings * @brief Acquire the temperature sensor power
* Should only be used when running into app stage
*/ */
void sar_periph_ctrl_init(void); void temperature_sensor_power_acquire(void);
/*------------------------------------------------------------------------------
* ADC Power
*----------------------------------------------------------------------------*/
/**
* @brief Acquire the ADC oneshot mode power
*/
void sar_periph_ctrl_adc_oneshot_power_acquire(void);
/** /**
* @brief Release the ADC oneshot mode power * @brief Release the temperature sensor power
*/ */
void sar_periph_ctrl_adc_oneshot_power_release(void); void temperature_sensor_power_release(void);
/** /**
* @brief Acquire the ADC continuous mode power * @brief Get the temperature value and choose the temperature sensor range. Will be both used in phy and peripheral.
*
* @param range_changed Pointer to whether range has been changed here. If you don't need this param, you can
* set NULL directly.
*
* @return temperature sensor value.
*/ */
void sar_periph_ctrl_adc_continuous_power_acquire(void); int16_t temp_sensor_get_raw_value(bool *range_changed);
/**
* @brief Release the ADC ADC continuous mode power
*/
void sar_periph_ctrl_adc_continuous_power_release(void);
/*------------------------------------------------------------------------------
* PWDET Power
*----------------------------------------------------------------------------*/
/**
* @brief Acquire the PWDET Power
*/
void sar_periph_ctrl_pwdet_power_acquire(void);
/**
* @brief Release the PWDET Power
*/
void sar_periph_ctrl_pwdet_power_release(void);
/**
* @brief Enable SAR power when system wakes up
*/
void sar_periph_ctrl_power_enable(void);
/**
* @brief Disable SAR power when system goes to sleep
*/
void sar_periph_ctrl_power_disable(void);
#ifdef __cplusplus #ifdef __cplusplus
} }

181
components/esp_hw_support/port/esp32c3/sar_periph_ctrl.c
View File

@ -4,127 +4,114 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
/**
* SAR related peripherals are interdependent. This file
* provides a united control to these registers, as multiple
* components require these controls.
*
* Related peripherals are:
* - ADC
* - PWDET
* - Temp Sensor
*/
#include "sdkconfig.h" #include "soc/soc_caps.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "esp_private/sar_periph_ctrl.h" #include "esp_private/sar_periph_ctrl.h"
#include "hal/sar_ctrl_ll.h" #include "esp_log.h"
#include "hal/adc_ll.h" #include "soc/apb_saradc_struct.h"
#include "private_include/regi2c_saradc.h"
static const char *TAG = "sar_periph_ctrl"; #include "driver/temp_sensor.h"
extern portMUX_TYPE rtc_spinlock; #include "regi2c_ctrl.h"
void sar_periph_ctrl_init(void) extern __attribute__((unused)) portMUX_TYPE rtc_spinlock;
/*------------------------------------------------------------------------------------------------------------
-----------------------------------------Temperature Sensor---------------------------------------------------
------------------------------------------------------------------------------------------------------------*/
static const char *TAG_TSENS = "temperature_sensor";
#define INT_NOT_USED 999999
static int s_record_min = INT_NOT_USED;
static int s_record_max = INT_NOT_USED;
static int s_temperature_sensor_power_cnt;
static uint8_t s_tsens_idx = 2; // Index for temperature attribute, set 2(middle) as default value
void temperature_sensor_power_acquire(void)
{ {
//Put SAR control mux to FSM state portENTER_CRITICAL(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_FSM); s_temperature_sensor_power_cnt++;
if (s_temperature_sensor_power_cnt == 1) {
//Add other periph power control initialisation here APB_SARADC.apb_tsens_ctrl.tsens_pu = true;
}
void sar_periph_ctrl_power_enable(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_FSM);
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
}
void sar_periph_ctrl_power_disable(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_OFF);
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
}
/*------------------------------------------------------------------------------
* PWDET Power
*----------------------------------------------------------------------------*/
static int s_pwdet_power_on_cnt;
void sar_periph_ctrl_pwdet_power_acquire(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
s_pwdet_power_on_cnt++;
if (s_pwdet_power_on_cnt == 1) {
sar_ctrl_ll_set_power_mode_from_pwdet(SAR_CTRL_LL_POWER_ON);
} }
portEXIT_CRITICAL_SAFE(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
} }
void sar_periph_ctrl_pwdet_power_release(void) void temperature_sensor_power_release(void)
{ {
portENTER_CRITICAL_SAFE(&rtc_spinlock); portENTER_CRITICAL(&rtc_spinlock);
s_pwdet_power_on_cnt--; s_temperature_sensor_power_cnt--;
/* Sanity check */ /* Sanity check */
if (s_pwdet_power_on_cnt < 0) { if (s_temperature_sensor_power_cnt < 0) {
portEXIT_CRITICAL(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
ESP_LOGE(TAG, "%s called, but s_pwdet_power_on_cnt == 0", __func__); ESP_LOGE(TAG_TSENS, "%s called, but s_temperature_sensor_power_cnt == 0", __func__);
abort(); abort();
} else if (s_pwdet_power_on_cnt == 0) { } else if (s_temperature_sensor_power_cnt == 0) {
sar_ctrl_ll_set_power_mode_from_pwdet(SAR_CTRL_LL_POWER_FSM); APB_SARADC.apb_tsens_ctrl.tsens_pu = false;
} }
portEXIT_CRITICAL_SAFE(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
} }
static int temperature_sensor_get_raw_value(void)
/*------------------------------------------------------------------------------
* ADC Power
*----------------------------------------------------------------------------*/
static int s_saradc_power_on_cnt;
static void s_sar_adc_power_acquire(void)
{ {
portENTER_CRITICAL_SAFE(&rtc_spinlock); int raw_value = APB_SARADC.apb_tsens_ctrl.tsens_out;
s_saradc_power_on_cnt++; return (TSENS_ADC_FACTOR * raw_value - TSENS_DAC_FACTOR * dac_offset[s_tsens_idx].offset - TSENS_SYS_OFFSET);
if (s_saradc_power_on_cnt == 1) {
adc_ll_digi_set_power_manage(ADC_POWER_SW_ON);
}
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
} }
static void s_sar_adc_power_release(void) void temp_sensor_sync_tsens_idx(int tsens_idx)
{ {
portENTER_CRITICAL_SAFE(&rtc_spinlock); s_tsens_idx = tsens_idx;
s_saradc_power_on_cnt--; }
if (s_saradc_power_on_cnt < 0) {
int16_t temp_sensor_get_raw_value(bool *range_changed)
{
portENTER_CRITICAL(&rtc_spinlock);
int degree = temperature_sensor_get_raw_value();
uint8_t temperature_dac;
// 1. Check whether temperature value is in range
if (s_record_min != INT_NOT_USED && degree >= s_record_min && degree <= s_record_max) {
// If degree is in range, not needed to do any check to save time. Otherwise, choose proper range and record.
if (range_changed != NULL) {
*range_changed = false;
}
portEXIT_CRITICAL(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
ESP_LOGE(TAG, "%s called, but s_saradc_power_on_cnt == 0", __func__); return degree;
abort();
} else if (s_saradc_power_on_cnt == 0) {
adc_ll_digi_set_power_manage(ADC_POWER_BY_FSM);
} }
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
}
void sar_periph_ctrl_adc_oneshot_power_acquire(void) // 2. If temperature value is not in range, adjust to proper range
{ if (degree >= dac_offset[1].range_max) {
s_sar_adc_power_acquire(); s_tsens_idx = 0;
} } else if (degree >= dac_offset[2].range_max && degree < dac_offset[1].range_max) {
s_tsens_idx = 1;
} else if (degree <= dac_offset[2].range_min && degree > dac_offset[3].range_min) {
s_tsens_idx = 3;
} else if (degree <= dac_offset[3].range_min) {
s_tsens_idx = 4;
} else {
s_tsens_idx = 2;
}
ESP_EARLY_LOGD(TAG_TSENS, "range changed, change to index %d", s_tsens_idx);
temperature_dac = dac_offset[s_tsens_idx].set_val;
s_record_min = dac_offset[s_tsens_idx].range_min;
s_record_max = dac_offset[s_tsens_idx].range_max;
void sar_periph_ctrl_adc_oneshot_power_release(void) REGI2C_WRITE_MASK(I2C_SAR_ADC, I2C_SARADC_TSENS_DAC, temperature_dac);
{
s_sar_adc_power_release();
}
void sar_periph_ctrl_adc_continuous_power_acquire(void) // 3. Then, read value again
{ // Before reading the temperature value, ticks need to be delayed, otherwise a wrong value will be returned.
s_sar_adc_power_acquire(); // As what has been recommended and tested, 300us is a good interval to get the correct value after adjust range.
} esp_rom_delay_us(300);
degree = temperature_sensor_get_raw_value();
if (range_changed != NULL) {
*range_changed = true;
}
void sar_periph_ctrl_adc_continuous_power_release(void) portEXIT_CRITICAL(&rtc_spinlock);
{ return degree;
s_sar_adc_power_release();
} }

4
components/esp_hw_support/port/esp32s2/CMakeLists.txt
View File

@ -25,5 +25,9 @@ if(NOT BOOTLOADER_BUILD)
"sar_periph_ctrl.c") "sar_periph_ctrl.c")
endif() endif()
if (NOT BOOTLOADER_BUILD)
list(APPEND srcs "sar_periph_ctrl.c")
endif()
add_prefix(srcs "${CMAKE_CURRENT_LIST_DIR}/" "${srcs}") add_prefix(srcs "${CMAKE_CURRENT_LIST_DIR}/" "${srcs}")
target_sources(${COMPONENT_LIB} PRIVATE "${srcs}") target_sources(${COMPONENT_LIB} PRIVATE "${srcs}")

168
components/esp_hw_support/port/esp32s2/sar_periph_ctrl.c
View File

@ -4,101 +4,123 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
/**
* SAR related peripherals are interdependent. This file
* provides a united control to these registers, as multiple
* components require these controls.
*
* Related peripherals are:
* - ADC
* - PWDET
* - Temp Sensor
*/
#include "sdkconfig.h" #include "soc/soc_caps.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "esp_private/sar_periph_ctrl.h" #include "esp_private/sar_periph_ctrl.h"
#include "hal/sar_ctrl_ll.h" #include "esp_log.h"
#include "hal/adc_ll.h" #include "soc/apb_saradc_struct.h"
#include "soc/sens_struct.h"
static const char *TAG = "sar_periph_ctrl"; #include "private_include/regi2c_saradc.h"
extern portMUX_TYPE rtc_spinlock; #include "driver/temp_sensor.h"
#include "regi2c_ctrl.h"
void sar_periph_ctrl_init(void) extern __attribute__((unused)) portMUX_TYPE rtc_spinlock;
/*------------------------------------------------------------------------------------------------------------
-----------------------------------------Temperature Sensor---------------------------------------------------
------------------------------------------------------------------------------------------------------------*/
static const char *TAG_TSENS = "temperature_sensor";
#define INT_NOT_USED 999999
static int s_record_min = INT_NOT_USED;
static int s_record_max = INT_NOT_USED;
static int s_temperature_sensor_power_cnt;
static uint8_t s_tsens_idx = 2; // Index for temperature attribute, set 2(middle) as default value
void temperature_sensor_power_acquire(void)
{ {
//Put SAR control mux to FSM state portENTER_CRITICAL(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_FSM); s_temperature_sensor_power_cnt++;
if (s_temperature_sensor_power_cnt == 1) {
//Add other periph power control initialisation here SENS.sar_tctrl.tsens_power_up_force = true;
} SENS.sar_tctrl2.tsens_xpd_force = true;
SENS.sar_tctrl.tsens_power_up = true;
void sar_periph_ctrl_power_enable(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_FSM);
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
}
void sar_periph_ctrl_power_disable(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
sar_ctrl_ll_set_power_mode(SAR_CTRL_LL_POWER_OFF);
portEXIT_CRITICAL_SAFE(&rtc_spinlock);
}
/*------------------------------------------------------------------------------
* PWDET Power
*----------------------------------------------------------------------------*/
static int s_pwdet_power_on_cnt;
void sar_periph_ctrl_pwdet_power_acquire(void)
{
portENTER_CRITICAL_SAFE(&rtc_spinlock);
s_pwdet_power_on_cnt++;
if (s_pwdet_power_on_cnt == 1) {
sar_ctrl_ll_set_power_mode_from_pwdet(SAR_CTRL_LL_POWER_ON);
} }
portEXIT_CRITICAL_SAFE(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
} }
void sar_periph_ctrl_pwdet_power_release(void) void temperature_sensor_power_release(void)
{ {
portENTER_CRITICAL_SAFE(&rtc_spinlock); portENTER_CRITICAL(&rtc_spinlock);
s_pwdet_power_on_cnt--; s_temperature_sensor_power_cnt--;
/* Sanity check */ /* Sanity check */
if (s_pwdet_power_on_cnt < 0) { if (s_temperature_sensor_power_cnt < 0) {
portEXIT_CRITICAL(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
ESP_LOGE(TAG, "%s called, but s_pwdet_power_on_cnt == 0", __func__); ESP_LOGE(TAG_TSENS, "%s called, but s_temperature_sensor_power_cnt == 0", __func__);
abort(); abort();
} else if (s_pwdet_power_on_cnt == 0) { } else if (s_temperature_sensor_power_cnt == 0) {
sar_ctrl_ll_set_power_mode_from_pwdet(SAR_CTRL_LL_POWER_FSM); SENS.sar_tctrl.tsens_power_up_force = false;
SENS.sar_tctrl2.tsens_xpd_force = false;
SENS.sar_tctrl.tsens_power_up = false;
} }
portEXIT_CRITICAL_SAFE(&rtc_spinlock); portEXIT_CRITICAL(&rtc_spinlock);
} }
static int temperature_sensor_get_raw_value(void)
/*------------------------------------------------------------------------------
* ADC Power
*----------------------------------------------------------------------------*/
void sar_periph_ctrl_adc_oneshot_power_acquire(void)
{ {
//Keep oneshot mode power controlled by HW, leave this function for compatibility SENS.sar_tctrl.tsens_dump_out = 1;
while (!SENS.sar_tctrl.tsens_ready) {
}
SENS.sar_tctrl.tsens_dump_out = 0;
int raw_value = SENS.sar_tctrl.tsens_out;
return (TSENS_ADC_FACTOR * raw_value - TSENS_DAC_FACTOR * dac_offset[s_tsens_idx].offset - TSENS_SYS_OFFSET);
} }
void sar_periph_ctrl_adc_oneshot_power_release(void) void temp_sensor_sync_tsens_idx(int tsens_idx)
{ {
//Keep oneshot mode power controlled by HW, leave this function for compatibility s_tsens_idx = tsens_idx;
} }
void sar_periph_ctrl_adc_continuous_power_acquire(void) int16_t temp_sensor_get_raw_value(bool *range_changed)
{ {
adc_ll_digi_set_power_manage(ADC_POWER_SW_ON); portENTER_CRITICAL(&rtc_spinlock);
}
void sar_periph_ctrl_adc_continuous_power_release(void) int degree = temperature_sensor_get_raw_value();
{ uint8_t temperature_dac;
adc_ll_digi_set_power_manage(ADC_POWER_BY_FSM);
// 1. Check whether temperature value is in range
if (s_record_min != INT_NOT_USED && degree >= s_record_min && degree <= s_record_max) {
// If degree is in range, not needed to do any check to save time. Otherwise, choose proper range and record.
if (range_changed != NULL) {
*range_changed = false;
}
portEXIT_CRITICAL(&rtc_spinlock);
return degree;
}
// 2. If temperature value is not in range, adjust to proper range
if (degree >= dac_offset[1].range_max) {
s_tsens_idx = 0;
} else if (degree >= dac_offset[2].range_max && degree < dac_offset[1].range_max) {
s_tsens_idx = 1;
} else if (degree <= dac_offset[2].range_min && degree > dac_offset[3].range_min) {
s_tsens_idx = 3;
} else if (degree <= dac_offset[3].range_min) {
s_tsens_idx = 4;
} else {
s_tsens_idx = 2;
}
ESP_EARLY_LOGD(TAG_TSENS, "range changed, change to index %d", s_tsens_idx);
temperature_dac = dac_offset[s_tsens_idx].set_val;
s_record_min = dac_offset[s_tsens_idx].range_min;
s_record_max = dac_offset[s_tsens_idx].range_max;
REGI2C_WRITE_MASK(I2C_SAR_ADC, I2C_SARADC_TSENS_DAC, temperature_dac);
// 3. Then, read value again
// Before reading the temperature value, ticks need to be delayed, otherwise a wrong value will be returned.
// As what has been recommended and tested, 300us is a good interval to get the correct value after adjust range.
esp_rom_delay_us(300);
degree = temperature_sensor_get_raw_value();
if (range_changed != NULL) {
*range_changed = true;
}
portEXIT_CRITICAL(&rtc_spinlock);
return degree;
} }