hpm_tsns_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
 
#ifndef HPM_TSNS_DRV_H
#define HPM_TSNS_DRV_H
 
#include "hpm_common.h"
#include "hpm_tsns_regs.h"
 
/***********************************************************************************************************************
 *
 * Definitions
 *
 **********************************************************************************************************************/
#define TSNS_TEMP_SCALE 256
 
typedef enum {
    tsns_clear_min = TSNS_FLAG_RECORD_MIN_CLR_MASK,
    tsns_clear_max = TSNS_FLAG_RECORD_MAX_CLR_MASK,
    tsns_clear_under_temp = TSNS_FLAG_UNDER_TEMP_MASK,
    tsns_clear_over_temp = TSNS_FLAG_OVER_TEMP_MASK,
    tsns_clear_irq = TSNS_FLAG_IRQ_MASK,
} tsns_clear_type_mask_t;
 
typedef enum {
    tsns_event_irq = 0,
    tsns_event_reset,
} tsns_event_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
static inline void tsns_enable(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_ENABLE_MASK;
}
 
static inline void tsns_disable(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_ENABLE_MASK;
}
 
static inline bool tsns_temperature_is_valid(TSNS_Type *ptr)
{
    return ptr->STATUS & TSNS_STATUS_VALID_MASK;
}
 
static inline int32_t tsns_get_max_temp_raw(TSNS_Type *ptr)
{
    return TSNS_TMAX_T_GET(ptr->TMAX);
}
 
static inline int32_t tsns_get_min_temp_raw(TSNS_Type *ptr)
{
    return TSNS_TMIN_T_GET(ptr->TMIN);
}
 
static inline int32_t tsns_get_current_temp_in_raw(TSNS_Type *ptr)
{
    while (!tsns_temperature_is_valid(ptr)) {
        ;
    }
    return TSNS_T_T_GET(ptr->T);
}
 
static inline float tsns_get_current_temp(TSNS_Type *ptr)
{
    return (float)(((int32_t)tsns_get_current_temp_in_raw(ptr) / TSNS_TEMP_SCALE));
}
 
static inline uint32_t tsns_get_temp_age(TSNS_Type *ptr)
{
    return TSNS_AGE_AGE_GET(ptr->AGE);
}
 
static inline void tsns_set_reset_threshold_high(TSNS_Type *ptr, uint32_t high)
{
    ptr->UPPER_LIM_IRQ = TSNS_UPPER_LIM_RST_T_SET(high);
}
 
static inline void tsns_set_reset_threshold_low(TSNS_Type *ptr, uint32_t low)
{
    ptr->LOWER_LIM_IRQ = TSNS_LOWER_LIM_RST_T_SET(low);
}
 
static inline void tsns_enable_limit_trigger_reset(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_RST_EN_MASK;
}
 
static inline void tsns_disable_limit_trigger_irq(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_RST_EN_MASK;
}
 
static inline void tsns_set_irq_threshold_high(TSNS_Type *ptr, uint32_t high)
{
    ptr->UPPER_LIM_IRQ = TSNS_UPPER_LIM_IRQ_T_SET(high);
}
 
static inline void tsns_set_irq_threshold_low(TSNS_Type *ptr, uint32_t low)
{
    ptr->LOWER_LIM_IRQ = TSNS_LOWER_LIM_IRQ_T_SET(low);
}
 
static inline void tsns_enable_limit_trigger_irq(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_IRQ_EN_MASK;
}
 
static inline void tsns_set_validity(TSNS_Type *ptr, uint32_t validity)
{
    ptr->VALIDITY = TSNS_VALIDITY_VALIDITY_SET(validity);
}
 
static inline void tsns_config_irq_threshold(TSNS_Type *ptr, uint32_t high, uint32_t low)
{
    tsns_set_irq_threshold_low(ptr, low);
    tsns_set_irq_threshold_high(ptr, high);
}
 
static inline void tsns_config_reset_threshold(TSNS_Type *ptr, uint32_t high, uint32_t low)
{
    tsns_set_reset_threshold_low(ptr, low);
    tsns_set_reset_threshold_high(ptr, high);
}
 
static inline void tsns_enable_compare_max(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_COMPARE_MAX_EN_MASK;
}
 
static inline void tsns_enable_compare_min(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_COMPARE_MIN_EN_MASK;
}
 
static inline void tsns_disable_compare_max(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_COMPARE_MAX_EN_MASK;
}
 
static inline void tsns_disable_compare_min(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_COMPARE_MIN_EN_MASK;
}
 
static inline void tsns_set_speed(TSNS_Type *ptr, uint8_t speed)
{
    assert(speed >= 24);
    ptr->CONFIG = (ptr->CONFIG & ~TSNS_CONFIG_SPEED_MASK) | TSNS_CONFIG_SPEED_SET(speed);
}
 
static inline void tsns_set_average(TSNS_Type *ptr, uint8_t average)
{
    ptr->CONFIG = (ptr->CONFIG & ~TSNS_CONFIG_AVERAGE_MASK) | TSNS_CONFIG_AVERAGE_SET(average);
}
 
static inline void tsns_enable_async_mode(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_ASYNC_MASK;
}
 
static inline void tsns_disable_async_mode(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_ASYNC_MASK;
}
 
static inline void tsns_enable_trigger_mode(TSNS_Type *ptr)
{
    ptr->CONFIG &= ~TSNS_CONFIG_CONTINUOUS_MASK;
}
 
static inline void tsns_enable_continuous_mode(TSNS_Type *ptr)
{
    ptr->CONFIG |= TSNS_CONFIG_CONTINUOUS_MASK;
}
 
static inline void tsns_trigger_measurement(TSNS_Type *ptr)
{
    uint32_t tmp = ptr->CONFIG;
    ptr->CONFIG &= ~TSNS_CONFIG_CONTINUOUS_MASK;
    ptr->STATUS |= TSNS_STATUS_TRIGGER_MASK;
    ptr->CONFIG = tmp;
}
 
static inline void tsns_clear_with_mask(TSNS_Type *ptr, tsns_clear_type_mask_t mask)
{
    ptr->FLAG |= mask;
}
 
static inline uint32_t tsns_get_flag_value(TSNS_Type *ptr)
{
    return ptr->FLAG;
}
 
 
void tsns_configure_low_limit_event(TSNS_Type *ptr, int32_t low, tsns_event_t e);
 
void tsns_configure_high_limit_event(TSNS_Type *ptr, int32_t high, tsns_event_t e);
 
void tsns_configure_limit_event(TSNS_Type *ptr, int32_t high, int32_t low, tsns_event_t e);
 
#ifdef __cplusplus
}
#endif
#endif /* HPM_TSNS_DRV_H */