hal.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*!****************************************************************************
 *  @file       hal.h
 *  @brief      Hall Sensored Trap Motor Control Library HAL Module
 *  @defgroup   HALL_SENSORED_TRAP__MSPM0G1507_HAL MSPM0G1507 - \
 *  Hardware Abstraction Layer (HAL)
 *
 *
 *  @anchor hall_sensored_trap_lp_mpsm0g1507_hal_Overview
 *  # Overview
 *
 *  The HAL module provides micro-controller agnostic set of application
 *  programming interfaces (APIs) to be used by other module's in the library
 *  as well as in the user's application code.
 *
 *  <hr>
 ******************************************************************************/
#ifndef HAL_H
#define HAL_H

#include "ti_msp_dl_config.h"
#include <ti/iqmath/include/IQmathLib.h>

#ifdef __cplusplus
extern "C" {
#endif

#define HAL_SYSTEM_FREQ_MHZ                         ((int32_t)80)

#define HAL_PWM_TIMER_FREQ_MHZ                      ((int32_t)80)

#define HAL_CAPTURE_TIMER_FREQ                      ((int32_t)100000)

#define HAL_VDDA_REFVOLTAGE                         (3300)

#define MAX_ADC_VALUE                               (4095)

typedef enum
{
    HAL_GPIO_PIN_LOW = 0,
    HAL_GPIO_PIN_HIGH
}HAL_GPIO_STATE;

typedef enum
{
    HAL_ADC_CHAN_0 = 0,
    HAL_ADC_CHAN_1,
    HAL_ADC_CHAN_2,
    HAL_ADC_CHAN_MAX
}HAL_ADC_CHAN;

typedef enum
{
    HAL_GPIO_IN_01 = 0,
    HAL_GPIO_IN_02,
    HAL_GPIO_IN_03,
    HAL_GPIO_IN_04,
    HAL_GPIO_IN_05,
    HAL_GPIO_IN_MAX
}HAL_GPIO_IN;

typedef enum
{
    HAL_GPIO_OUT_01 = 0,
    HAL_GPIO_OUT_02,
    HAL_GPIO_OUT_03,
    HAL_GPIO_OUT_MAX
}HAL_GPIO_OUT;

typedef enum
{
    HAL_PWM_01 = 0,
    HAL_PWM_02,
    HAL_PWM_03,
    HAL_PWM_MAX
}HAL_PWM;

typedef enum
{
    HAL_CAPTURE_TIMER_01 = 0,
    HAL_CAPTURE_TIMER_MAX
}HAL_CAPTURE_TIMER;

typedef enum
{
    HAL_FAULT_INPUT_1,
    HAL_FAULT_INPUT_MAX
}HAL_FAULT_INPUT;

typedef enum {
    HAL_SPI_CHAN_0 = 0,
    HAL_SPI_CHAN_MAX
} HAL_SPI_CHAN;

typedef enum {
    HAL_SPI_CS_0 = 0,
    HAL_SPI_CS_1,
    HAL_SPI_CS_2,
    HAL_SPI_CS_3,
    HAL_SPI_CS_MAX
} HAL_SPI_CS;

typedef enum
{
    HAL_ADC_VREF_VDDA = 0,
    HAL_ADC_VREF_INTERNAL,
    HAL_ADC_VREF_EXTERNAL
}HAL_ADC_VREF;

typedef enum
{
    HAL_ADC_INT_VREF_2P5V = DL_VREF_BUFCONFIG_OUTPUT_2_5V,
    HAL_ADC_INT_VREF_1P4V = DL_VREF_BUFCONFIG_OUTPUT_1_4V
}HAL_ADC_INT_VREF;

typedef enum
{
    HAL_ADC_IIDX_OVERFLOW = DL_ADC12_IIDX_OVERFLOW,

    HAL_ADC_IIDX_TRIG_OVERFLOW = DL_ADC12_IIDX_TRIG_OVERFLOW,

    HAL_ADC_IIDX_WINDOW_COMP_HIGH = DL_ADC12_IIDX_WINDOW_COMP_HIGH,

    HAL_ADC_IIDX_WINDOW_COMP_LOW = DL_ADC12_IIDX_WINDOW_COMP_LOW,

    HAL_ADC_IIDX_INIFG = DL_ADC12_IIDX_INIFG,

    HAL_ADC_IIDX_DMA_DONE = DL_ADC12_IIDX_DMA_DONE,

    HAL_ADC_IIDX_UNDERFLOW = DL_ADC12_IIDX_UNDERFLOW,

    HAL_ADC_IIDX_MEM0_RESULT_LOADED = DL_ADC12_IIDX_MEM0_RESULT_LOADED,

    HAL_ADC_IIDX_MEM1_RESULT_LOADED = DL_ADC12_IIDX_MEM1_RESULT_LOADED,

    HAL_ADC_IIDX_MEM2_RESULT_LOADED = DL_ADC12_IIDX_MEM2_RESULT_LOADED,

    HAL_ADC_IIDX_MEM3_RESULT_LOADED = DL_ADC12_IIDX_MEM3_RESULT_LOADED,

    HAL_ADC_IIDX_MEM4_RESULT_LOADED = DL_ADC12_IIDX_MEM4_RESULT_LOADED,

    HAL_ADC_IIDX_MEM5_RESULT_LOADED = DL_ADC12_IIDX_MEM5_RESULT_LOADED,

    HAL_ADC_IIDX_MEM6_RESULT_LOADED = DL_ADC12_IIDX_MEM6_RESULT_LOADED,

    HAL_ADC_IIDX_MEM7_RESULT_LOADED = DL_ADC12_IIDX_MEM7_RESULT_LOADED,

    HAL_ADC_IIDX_MEM8_RESULT_LOADED = DL_ADC12_IIDX_MEM8_RESULT_LOADED,

    HAL_ADC_IIDX_MEM9_RESULT_LOADED = DL_ADC12_IIDX_MEM9_RESULT_LOADED,

    HAL_ADC_IIDX_MEM10_RESULT_LOADED = DL_ADC12_IIDX_MEM10_RESULT_LOADED,

    HAL_ADC_IIDX_MEM11_RESULT_LOADED = DL_ADC12_IIDX_MEM11_RESULT_LOADED,
}HAL_ADC_IIDX;

typedef struct HAL_GPIO_Instance_
{
    IOMUX_PINCM         iomux;
    GPIO_Regs *         port;
    uint32_t            pin;
    IRQn_Type           IRQn;
}HAL_GPIO_Instance;

typedef struct HAL_ADC_instance_
{
    ADC12_Regs *        inst;
    HAL_ADC_IIDX        endOfSeq;
    IRQn_Type           IRQn;
    uint16_t            value;
    uint16_t            refVoltagemV;
    DL_ADC12_MEM_IDX    memIdx;
}HAL_ADC_instance;

typedef struct HAL_Timer_Instance_
{
    GPTIMER_Regs        *gptimer;
    DL_TIMER_CC_INDEX   ccIndex;
    IRQn_Type           IRQn;
}HAL_Timer_Instance;

typedef struct HAL_fault_instance
{
    GPTIMER_Regs        *gptimer;
    GPIO_Regs *         port;
    uint32_t            pin;
}HAL_fault_instance;

extern HAL_GPIO_Instance   gpioInputPin[HAL_GPIO_IN_MAX];

extern HAL_Timer_Instance  PWMBase[HAL_PWM_MAX];

extern HAL_Timer_Instance  inputCapture[HAL_CAPTURE_TIMER_MAX];

extern HAL_ADC_instance    ADCChannel[HAL_ADC_CHAN_MAX];

extern HAL_fault_instance  faultInput[HAL_FAULT_INPUT_MAX];

void HAL_init();

bool HAL_readGPIOPin(HAL_GPIO_IN pin);

void HAL_writeGPIOPin(HAL_GPIO_OUT pin, HAL_GPIO_STATE value);

void HAL_setDeadband(HAL_PWM pwm, uint16_t deadband);

void HAL_setPWMFreq(HAL_PWM pwm, uint32_t PWMFreq);

void HAL_writeSPI16(HAL_SPI_CHAN chan, HAL_SPI_CS cs, uint16_t data);

uint16_t HAL_readSPI16(HAL_SPI_CHAN chan, HAL_SPI_CS cs);

void HAL_setADCRefVoltage(HAL_ADC_CHAN chan, uint16_t voltage_mV);

uint32_t HAL_getmvFromADC(HAL_ADC_CHAN chan);

_iq20 HAL_getIQ20VoltageFromADC(HAL_ADC_CHAN chan);

HAL_ADC_IIDX HAL_processADCIRQ(ADC12_Regs *adcInst);

void HAL_enableADCInterrupt(HAL_ADC_CHAN chan);

void HAL_enableGPIOInterrupt(HAL_GPIO_IN pin);

void HAL_enablePWMInterrupt(HAL_PWM PWM);

void HAL_enableCaptureInterrupt(HAL_CAPTURE_TIMER capture);

void HAL_setADCVRefVDDA(HAL_ADC_CHAN chan);

void HAL_setADCVRefInternal(HAL_ADC_CHAN chan, HAL_ADC_INT_VREF internalVRef);

void HAL_setADCVRefExternal(HAL_ADC_CHAN chan, uint16_t externalVRef);

void HAL_clearTimerFault(HAL_FAULT_INPUT fault);

bool HAL_getTimerFaultStatus(HAL_FAULT_INPUT fault);

uint32_t HAL_getCaptureFrequency(HAL_CAPTURE_TIMER capture);

void HAL_ADCVRefSel(HAL_ADC_VREF adcRef, HAL_ADC_CHAN chan,
                        HAL_ADC_INT_VREF internalVRef, uint16_t externalVRef);

uint32_t HAL_getGPIOEnabledInterruptStatus(HAL_GPIO_IN pin);

__STATIC_INLINE void HAL_delayMicroSeconds(uint32_t microSeconds)
{
  delay_cycles(HAL_SYSTEM_FREQ_MHZ * microSeconds);
  return;
}

__STATIC_INLINE void HAL_updatePWM(const HAL_PWM posPhase,
                                   const HAL_PWM gndPhase,
                                   const HAL_PWM opnPhase,
                                   const uint16_t PWMDuty)
{
    HAL_Timer_Instance *positivePhase = &PWMBase[posPhase];
    HAL_Timer_Instance *groundPhase = &PWMBase[gndPhase];
    HAL_Timer_Instance *openPhase = &PWMBase[opnPhase];

    /* get the timer load value */
    uint16_t PWMPeriod = DL_TimerA_getLoadValue(positivePhase->gptimer);
    /* Calculate the capture compare value  */
    uint16_t posPhase_cmpValue = PWMPeriod - (PWMPeriod * PWMDuty)/100;

    /* Set the capture compare value to positive phase  */
    DL_TimerA_setCaptureCompareValue(positivePhase->gptimer,
                                     posPhase_cmpValue,
                                     positivePhase->ccIndex);

    DL_Timer_overrideCCPOut(positivePhase->gptimer, DL_TIMER_FORCE_OUT_DISABLED,
                            DL_TIMER_FORCE_CMPL_OUT_DISABLED, positivePhase->ccIndex);

    DL_Timer_overrideCCPOut(groundPhase->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_HIGH, groundPhase->ccIndex);

    DL_Timer_overrideCCPOut(openPhase->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_LOW, openPhase->ccIndex);
}


__STATIC_INLINE void HAL_PWMOutputLow(const HAL_PWM gndPhase_1,
                                     const HAL_PWM gndPhase_2,
                                     const HAL_PWM gndPhase_3)
{
    HAL_Timer_Instance *groundPhase01 = &PWMBase[gndPhase_1];
    HAL_Timer_Instance *groundPhase02 = &PWMBase[gndPhase_2];
    HAL_Timer_Instance *groundPhase03 = &PWMBase[gndPhase_3];

    DL_Timer_overrideCCPOut(groundPhase01->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_LOW, groundPhase01->ccIndex);

    DL_Timer_overrideCCPOut(groundPhase02->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_LOW, groundPhase02->ccIndex);

    DL_Timer_overrideCCPOut(groundPhase03->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_LOW, groundPhase03->ccIndex);
}

__STATIC_INLINE void HAL_PWMOutputHigh(const HAL_PWM gndPhase_1,
                                   const HAL_PWM gndPhase_2,
                                   const HAL_PWM gndPhase_3)
{
    HAL_Timer_Instance *groundPhase01 = &PWMBase[gndPhase_1];
    HAL_Timer_Instance *groundPhase02 = &PWMBase[gndPhase_2];
    HAL_Timer_Instance *groundPhase03 = &PWMBase[gndPhase_3];

    DL_Timer_overrideCCPOut(groundPhase01->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_HIGH, groundPhase01->ccIndex);

    DL_Timer_overrideCCPOut(groundPhase02->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_HIGH, groundPhase02->ccIndex);

    DL_Timer_overrideCCPOut(groundPhase03->gptimer, DL_TIMER_FORCE_OUT_LOW,
                            DL_TIMER_FORCE_CMPL_OUT_HIGH, groundPhase03->ccIndex);
}

#ifdef __cplusplus
}
#endif
#endif /* HAL_H */