RAK3172 PWM tone function is working only with build-in LEDs

LPWAN Modules / EVBs RAK3172
1

Hello!

For my pet project I need enable PWM with 1.5MHz and read result with analogRead(pin_number);
The problem is: PWM is working only with build-in LED (Green and Blue on evaluation board).
Basically now, I am trying replicate following small project for ESP32 ESP32 PWM with Arduino IDE (Analog Output) | Random Nerd Tutorials with no luck so far.

Any ideas why tone function is working only for internal LEDs and how to fix it? Thanks!
Code:

uint8_t ledPin = PA1;	// BLUE LED - working
//uint8_t ledPin = PA0;	// GREEN LED - working
//uint8_t ledPin = PA8;	//IO2 - not working
//uint8_t ledPin = PB5;	//IO1 - not working

int freq = 5000;

void setup()
{
  Serial.begin(115200);
  delay(2000);
    
  pinMode(ledPin, OUTPUT);  
  tone(ledPin, freq);
}

void loop()
{
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
   	analogWrite(ledPin, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
   	analogWrite(ledPin, dutyCycle);
    delay(15);
  }
}
2

Well, it looks like build-in Timers are attached to specific pins and cannot be re-configured like in ESP32.
I didn’t find source code original firmware, but at least 2 pins (PA1 and PA0) able to generate PWM up to 186kHz which pretty low frequency :sob:

3

Welcome to RAK forum @Diaver ,

1.5Mhz is fast. Are you doing some kind of controller - power, motor, etc.?

You might need to use MCUs optimized for this. Maybe some parts from Microchip, TI, Freescale(NXP), etc.

4

Thank you for reply @carlrowan !
1.5Mhz it is not really any special. As far as I know, any STM32 chip able to provide that PWM signal and even more. Basically you just need in STM32Cube select the right options for a timer like Prescale and Period and that is it.

In your wrapper for Arduino it is possible to, but not from API. Insead you can update one C file which is going together with Arduino package:

image
image1755×1122 149 KB

And use tone function with some specific pin like PA1 or PA0.
That is it!

5

Your insight is helpful to the community @Diaver . Thanks for sharing!

I was wrong with regards to saying that 1.5Mhz is fast. It is relative to what type of application. STM32 chip can “of course” produce such frequency. However when it comes to PWM, it is a compromise on resolution. If the resolution you got on the frequency you generated is a fit on the application, the module then is a good fit :+1:

Unfortunately, changing this at exposed RUI3 API might not be possible since it will add more to the size of already big RUI3. However, if you think there is an optimized setting for the timer used in PWM generation, I will gladly share it to our development team.

6

To keep RUI API small, I just would probably update function “tone” and put as input argument parameter “Period/Resolution” and keep “Prescaler” as 1 or 0 hardcoded. It will help users receive whatever frequency they need with desired resolution.
Also, I would update documentation to describe what pins can be used to produce PWM signal -I tried PA1 and PA0 and they are working as expected.

7

Hello! I have tried to do as @Diaver suggest but after changing the couples of lines my rak3172 does not produce PWM but continuous high state.
I am trying with PA0, without changing code Im only able to produce 186Khz.
Am I missing something?

8

Hey @FernandoAg !
Also, you need set the following guys:

const int PWM_FREQ_HZ = 186000;
const int PWM_DUTY_PERCENT = 10;
const uint8_t PIN_PWM_OUT = PA0;

tone(PIN_PWM_OUT, PWM_FREQ_HZ);
analogWrite(PIN_PWM_OUT, PWM_DUTY_PERCENT );

// do whatever you want here

noTone(PIN_PWM_OUT);

Also, in your local file
“C:\Users[UserHere]\AppData\Local\Arduino15\packages\rak_rui\hardware\stm32\4.1.0\cores\STM32WLE\component\core\mcu\stm32wle5xx\uhal”

set on line 82:
htim.Init.Prescaler = 0;

9

Thank you for the input.

I got a couple of Mhz but seems like the function tone is useless, so the real result is from the analogWrite(PIN_PWM_OUT, PWM_DUTY_PERCENT );

The more I decrease the htim.Init.Period in the C file the more I have to reduce PWM_DUTY_PERCENT to keep it like “real” 50% duty pwm.

10

I ended up creating a custom function based on the “pwm_init”. For this I had to create the headers etc on the files:

  • uhal_pwm.c
  • uhal_pwm.h
  • udrv_pwm.c
  • udrv_pwm.h
  • ruiTop.h
  • wiringTone.cpp

I can post the function if needed, basically copied analogWrite function (which leads to “pwm_init”, fixed “htim.Init.Period = 3;” and duty cycle to “2” and put prescaler as an input to the function so it can generate pretty good 50% duty cycle high speed signals.

Here is the piece of code in the arduino program:

// Precaler values: 0 = 11.71Mhz / 1 = 5.86Mhz / 2 = 3.9Mhz / 3 = 2.93Mhz / 4 = 2.34Mhz / 5 = 1.95Mhz /  
//                  6 = 1.67Mhz / 7 = 1.46Mhz / 8 = 1.3Mhz /9 = 1.17Mhz / 10 = 1.06Mhz 
for (int PRESCALER = 11; PRESCALER >= 0; PRESCALER--) {
  Serial.println(PRESCALER);
  RAK3172_pwm_write(PWM_EN, PRESCALER);
  delay(3000);
}

you could reach up to 24mhz by decreasing “htim.Init.Period = 3;” down to 2 but the wave is not fully clean

11

@FernandoAg
Could you please post the whole solution? I am sure it will be very helpful.
Thanks!

12

In uhal_pwm.c

void uhal_rak3172_pwm_init(udrv_pwm_port port, uint8_t prescaler, uint32_t pin) {

    if (pin == 0 || pin == 1 || pin == 15) {
        htim.Instance = TIM2;
    } else {
        htim.Instance = TIM1;
    }

    htim.Init.Prescaler = prescaler;	
    htim.Init.CounterMode = TIM_COUNTERMODE_UP;
	htim.Init.Period = 3;
    htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim.Init.RepetitionCounter = 0;
    htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    if (HAL_TIM_PWM_Init(&htim) != HAL_OK)
    {
      Error_Handler();
    }

    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

    if (HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig) != HAL_OK)
    {
      Error_Handler();
    }
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
    sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    switch (pin) {
        case 0:
        case 15:
            if (HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
            {
              Error_Handler();
            }
            break;
        case 1:
        case 9:
            if (HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
            {
              Error_Handler();
            }
            break;
        case 10:
            if (HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
            {
              Error_Handler();
            }
            break;
        case 8:
            if (HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
            {
              Error_Handler();
            }
            break;
    }
    sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
    sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
    sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
    sBreakDeadTimeConfig.DeadTime = 0;
    sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
    sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
    sBreakDeadTimeConfig.BreakFilter = 0;
    sBreakDeadTimeConfig.BreakAFMode = TIM_BREAK_AFMODE_INPUT;
    sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
    sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
    sBreakDeadTimeConfig.Break2Filter = 0;
    sBreakDeadTimeConfig.Break2AFMode = TIM_BREAK_AFMODE_INPUT;
    sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
    if (HAL_TIMEx_ConfigBreakDeadTime(&htim, &sBreakDeadTimeConfig) != HAL_OK)
    {
      Error_Handler();
    }
  
    uhal_pwm_pin_init(pin);
}

int32_t uhal_rak3172_pwm_set_duty(udrv_pwm_port port, uint8_t prescaler, uint32_t duty) {
    pwm_disable(port);
    pwm_deinit(port);

    sConfigOC.Pulse = duty;

    uhal_rak3172_pwm_init(port, prescaler, pwm_status[port].pin);
    pwm_enable(port);
}

in uhal_pwm.h

void uhal_rak3172_pwm_init(udrv_pwm_port port, uint8_t prescaler, uint32_t pin);
int32_t uhal_rak3172_pwm_set_duty(udrv_pwm_port port, uint8_t prescaler, uint32_t duty);

in wiringTone.cpp (rak_rui\hardware\stm32\4.2.0\cores\STM32WLE\component\rui_v3_api)

void RAK3172_pwm_write(uint8_t pin, uint8_t prescaler)
{
    int i;
    for(i=0;i<UDRV_PWM_MAX;i++)
    {
        if(used_pwm_ports.pins[i] == pin || used_pwm_ports.pins[i] ==0)
        {
            used_pwm_ports.cur_port = i;
            used_pwm_ports.pins[i] = pin;
            break;
        }
        if(i == UDRV_PWM_MAX-1)
        {
            used_pwm_ports.cur_port = 0;
            used_pwm_ports.pins[0] = pin;
        }

    }
    udrv_pwm_disable((udrv_pwm_port)used_pwm_ports.cur_port);
    udrv_pwm_deinit((udrv_pwm_port)used_pwm_ports.cur_port);
    udrv_rak3172_pwm((udrv_pwm_port)used_pwm_ports.cur_port, prescaler, pin);
    udrv_pwm_enable((udrv_pwm_port)used_pwm_ports.cur_port, PWM_NO_TIMEOUT);
    udrv_rak3172_pwm_set_duty((udrv_pwm_port)used_pwm_ports.cur_port, prescaler, 2);
}

in ruiTop.h

void RAK3172_pwm_write(uint8_t pin, uint8_t prescaler);

in udrv_pwm.c (rak_rui\hardware\stm32\4.2.0\cores\STM32WLE\component\udrv\pwm)

void udrv_rak3172_pwm(udrv_pwm_port port, uint8_t prescaler, uint32_t pin) {
    uhal_rak3172_pwm_init(port, prescaler, pin);
}
int32_t udrv_rak3172_pwm_set_duty(udrv_pwm_port port, uint8_t prescaler, uint32_t duty) {
    return uhal_rak3172_pwm_set_duty(port, prescaler, duty);
}

in udrv_pwm.h (rak_rui\hardware\stm32\4.2.0\cores\STM32WLE\component\udrv\pwm)

void udrv_rak3172_pwm(udrv_pwm_port port, uint8_t prescaler, uint32_t pin);
int32_t udrv_rak3172_pwm_set_duty(udrv_pwm_port port, uint8_t prescaler, uint32_t duty);