elbear_arduino_bsp/cores/arduino/wiring_analog.c

#include "Arduino.h"

#ifdef __cplusplus
extern "C" {
#endif

#include "mik32_hal_adc.h"
#include "mik32_hal_gpio.h"
#include "mik32_hal_timer32.h"


// -------------------------- Analog read -------------------------- //
#define ADC_SAMPLES_QTY           10  // samples quantity for averaging adc results
#define ADC_DEFAULT_RESOLUTION    10  // resolution for arduino compatibility

uint8_t currentResolution = ADC_DEFAULT_RESOLUTION; // resolution used for output results

// structure for ADC channel initialization. Only the channel number 
// changes, everything else is the same
static ADC_HandleTypeDef hadc = 
{
  .Instance    = ANALOG_REG,
  .Init.EXTClb = ADC_EXTCLB_ADCREF,
  .Init.EXTRef = ADC_EXTREF_OFF,
  .Init.Sel    = 0
};

void analogReadResolution(uint8_t resolution)
{
  // resolution limits
  if (resolution > 32) resolution = 32;
  if (resolution < 1)  resolution = 1;

  // save new resolution
  currentResolution = resolution;
}

// initialize the channel, run a single measurement, wait for the result
uint32_t analogRead(uint32_t PinNumber)
{
  uint32_t value = 0;
  uint32_t adcChannel = analogInputToChannelNumber(PinNumber);
  if (adcChannel != NC) 
  {
    additionalPinsInit(PinNumber);

    // init channel 
    hadc.Init.Sel = adcChannel;
    HAL_ADC_Init(&hadc);

    // start the dummy conversion in case another channel was polled before
    HAL_ADC_SINGLE_AND_SET_CH(hadc.Instance, adcChannel);
    HAL_ADC_WaitAndGetValue(&hadc);

    // accumulate results
    uint32_t acc = 0;
    for (uint8_t i = 0; i<ADC_SAMPLES_QTY; i++)
    {
      HAL_ADC_Single(&hadc);
      acc += HAL_ADC_WaitAndGetValue(&hadc);
    }
    // get value by averaging with MCU_ADC_RESOLUTION
    value = acc/ADC_SAMPLES_QTY;

    // map value to selected resolution
    if (currentResolution > MCU_ADC_RESOLUTION)
    {
      // extra least significant bits are padded with zeros
      value = (value << (currentResolution - MCU_ADC_RESOLUTION));
    }
    else
    {
      // extra least significant bits read from the ADC are discarded
      value = (value >> (MCU_ADC_RESOLUTION - currentResolution));
    }
    additionalPinsDeinit(PinNumber);
  }
  else
    ErrorMsgHandler("analogRead(): invalid analog pin number");
  
  return value;
}



// -------------------------- Analog write -------------------------- //
#define PWM_RESOLUTION_DEFAULT    8
#define WRITE_VAL_MAX_DEFAULT     ((1<<PWM_RESOLUTION_DEFAULT) - 1)
#define PWM_TOP_VAL_DEFAULT       32000   // corresponds 1000 Hz

static TIMER32_HandleTypeDef htimer32;
static TIMER32_CHANNEL_HandleTypeDef htimer32_channel;
static uint32_t WriteValMax = WRITE_VAL_MAX_DEFAULT;
static uint32_t pwmTopVal = PWM_TOP_VAL_DEFAULT;
static uint8_t pwmIsInited = 0;


/*
It is recommended to enable the timer in the following order:
- Set the required operating mode. In the INT_MASK register 0;
- Write 0xFFFFFFFF to the INT_CLEAR register;
- Set TIM_EN to 1;
- If you need interrupts from the timer, set the required interrupt mask in the INT_MASK register.
*/
void analogWrite(uint32_t PinNumber, uint32_t writeVal)
{
  if (writeVal > WriteValMax)   writeVal = WriteValMax;

  if (digitalPinPwmIsOn(PinNumber) > 0)      // pin has pwm and pwm is already on
  {
    // we can only change writeVal if it is differ from current value
    TIMER32_TypeDef* timer = pwmPinToTimer(PinNumber);
    uint32_t newOCR = (uint32_t) (((uint64_t)pwmTopVal * writeVal) / WriteValMax); 
    if (timer->CHANNELS[pwmPinToTimerChannel(PinNumber)].OCR != newOCR)
    {
      //  if new ocr differs from current, set new ocr
      timer->CHANNELS[pwmPinToTimerChannel(PinNumber)].OCR = newOCR;
    }
  }
  else if (digitalPinPwmIsOn(PinNumber) == 0) // pin has pwm and pwm is off
  {
    // init pin as pwm
    uint32_t OCRval = (uint32_t) (((uint64_t)pwmTopVal * writeVal) / WriteValMax);

    // initialization of the required timer
    htimer32.Instance         = pwmPinToTimer(PinNumber);
    htimer32.Top              = pwmTopVal;
    htimer32.State            = TIMER32_STATE_DISABLE;
    htimer32.Clock.Source     = TIMER32_SOURCE_PRESCALER;
    htimer32.Clock.Prescaler  = 0; // Prescaler = 1
    htimer32.InterruptMask    = 0;
    htimer32.CountMode        = TIMER32_COUNTMODE_FORWARD;
    HAL_Timer32_Init(&htimer32);
    
    // gpio init as timer channel pin
    HAL_GPIO_PinConfig(digitalPinToPort(PinNumber), digitalPinToBitMask(PinNumber), 
                      HAL_GPIO_MODE_TIMER_SERIAL, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);

    htimer32_channel.TimerInstance  = htimer32.Instance;
    htimer32_channel.ChannelIndex   = pwmPinToTimerChannel(PinNumber);
    htimer32_channel.PWM_Invert     = TIMER32_CHANNEL_NON_INVERTED_PWM;
    htimer32_channel.Mode           = TIMER32_CHANNEL_MODE_PWM;
    htimer32_channel.CaptureEdge    = TIMER32_CHANNEL_CAPTUREEDGE_RISING;
    htimer32_channel.OCR            = OCRval;
    htimer32_channel.Noise          = TIMER32_CHANNEL_FILTER_OFF;
    HAL_Timer32_Channel_Init(&htimer32_channel);

    // start timer with initialized channel
    HAL_Timer32_Channel_Enable(&htimer32_channel);
    HAL_Timer32_Value_Clear(&htimer32);
    HAL_Timer32_Start(&htimer32);
    pwmIsInited++; // increase inited channels qty
  }
  else  // pin doesn't have pwm
    ErrorMsgHandler("analogWrite(): invalid pwm pin number");
}

// Set the resolution of analogWrite parameters
void analogWriteResolution(uint8_t resolution)
{
  if ((resolution > 0) && (resolution < 32)) 
    WriteValMax = (1 << resolution) - 1;
  else if (resolution == 32)
    WriteValMax = UINT32_MAX;
  else
    ErrorMsgHandler("analogWriteResolution(): invalid resolution");
}

// Set the frequency of analogWrite
void analogWriteFrequency(uint32_t freq)
{
  if ((freq >= 1) && (freq <= PWM_FREQUENCY_MAX))
    pwmTopVal = F_CPU/freq;
  else
    ErrorMsgHandler("analogWriteFrequency(): invalid frequency");
}

/*
It is recommended to turn off the timer in the following order:
- Write 0 to the INT_MASK register;
- Write 0 to the TIM_PRESCALE register;
- Write 0 to the INT_CLEAR register;
- Set TIM_EN to 0.
*/
// use only if digitalPinPwmIsOn(PinNumber) > 0
void analogWriteStop(uint32_t PinNumber)
{
  if ((pwmIsInited > 0))
  {
    // load the timer address and channel number corresponding to the specified pin
    htimer32.Instance               = pwmPinToTimer(PinNumber);
    htimer32_channel.ChannelIndex   = pwmPinToTimerChannel(PinNumber);
    htimer32.Instance->CHANNELS[htimer32_channel.ChannelIndex].OCR = 0;
    htimer32_channel.TimerInstance  = htimer32.Instance;

    // deinit channel
    HAL_Timer32_Channel_DeInit(&htimer32_channel);
    pwmIsInited--; // decrease inited channels qty

    // stop timer if no inited channels left
    if (pwmIsInited == 0)
    {
      HAL_Timer32_Stop(&htimer32);
      HAL_Timer32_Deinit(&htimer32);
    }

    // config pin as input when timer channel off
    HAL_GPIO_PinConfig(digitalPinToPort(PinNumber), digitalPinToBitMask(PinNumber), 
                      HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
  }
}

#ifdef __cplusplus
}
#endif