181 lines
3.5 KiB
C
181 lines
3.5 KiB
C
/* Implementation of PWM support for the Espressif SDK.
|
|
*
|
|
* Part of esp-open-rtos
|
|
* Copyright (C) 2015 Guillem Pascual Ginovart (https://github.com/gpascualg)
|
|
* Copyright (C) 2015 Javier Cardona (https://github.com/jcard0na)
|
|
* BSD Licensed as described in the file LICENSE
|
|
*/
|
|
#include "pwm.h"
|
|
|
|
#include <espressif/esp_common.h>
|
|
#include <espressif/sdk_private.h>
|
|
#include <FreeRTOS.h>
|
|
#include <esp8266.h>
|
|
|
|
typedef struct PWMPinDefinition
|
|
{
|
|
uint8_t pin;
|
|
uint8_t divider;
|
|
} PWMPin;
|
|
|
|
typedef enum {
|
|
PERIOD_ON = 0,
|
|
PERIOD_OFF = 1
|
|
} pwm_step_t;
|
|
|
|
|
|
typedef struct pwmInfoDefinition
|
|
{
|
|
uint8_t running;
|
|
|
|
uint16_t freq;
|
|
uint16_t dutyCicle;
|
|
|
|
/* private */
|
|
uint32_t _maxLoad;
|
|
uint32_t _onLoad;
|
|
uint32_t _offLoad;
|
|
pwm_step_t _step;
|
|
|
|
uint16_t usedPins;
|
|
PWMPin pins[8];
|
|
} PWMInfo;
|
|
|
|
static PWMInfo pwmInfo;
|
|
|
|
static void frc1_interrupt_handler(void)
|
|
{
|
|
uint8_t i = 0;
|
|
bool out = true;
|
|
uint32_t load = pwmInfo._onLoad;
|
|
pwm_step_t step = PERIOD_ON;
|
|
|
|
if (pwmInfo._step == PERIOD_ON)
|
|
{
|
|
out = false;
|
|
load = pwmInfo._offLoad;
|
|
step = PERIOD_OFF;
|
|
}
|
|
|
|
for (; i < pwmInfo.usedPins; ++i)
|
|
{
|
|
gpio_write(pwmInfo.pins[i].pin, out);
|
|
}
|
|
|
|
timer_set_load(FRC1, load);
|
|
pwmInfo._step = step;
|
|
}
|
|
|
|
void pwm_init(uint8_t npins, uint8_t* pins)
|
|
{
|
|
/* Assert number of pins is correct */
|
|
if (npins > MAX_PWM_PINS)
|
|
{
|
|
printf("Incorrect number of PWM pins (%d)\n", npins);
|
|
return;
|
|
}
|
|
|
|
/* Initialize */
|
|
pwmInfo._maxLoad = 0;
|
|
pwmInfo._onLoad = 0;
|
|
pwmInfo._offLoad = 0;
|
|
pwmInfo._step = PERIOD_ON;
|
|
|
|
/* Save pins information */
|
|
pwmInfo.usedPins = npins;
|
|
|
|
uint8_t i = 0;
|
|
for (; i < npins; ++i)
|
|
{
|
|
pwmInfo.pins[i].pin = pins[i];
|
|
|
|
/* configure GPIOs */
|
|
gpio_enable(pins[i], GPIO_OUTPUT);
|
|
}
|
|
|
|
/* Stop timers and mask interrupts */
|
|
pwm_stop();
|
|
|
|
/* set up ISRs */
|
|
_xt_isr_attach(INUM_TIMER_FRC1, frc1_interrupt_handler);
|
|
|
|
/* Flag not running */
|
|
pwmInfo.running = 0;
|
|
}
|
|
|
|
void pwm_set_freq(uint16_t freq)
|
|
{
|
|
pwmInfo.freq = freq;
|
|
|
|
/* Stop now to avoid load being used */
|
|
if (pwmInfo.running)
|
|
{
|
|
pwm_stop();
|
|
pwmInfo.running = 1;
|
|
}
|
|
|
|
timer_set_frequency(FRC1, freq);
|
|
pwmInfo._maxLoad = timer_get_load(FRC1);
|
|
|
|
if (pwmInfo.running)
|
|
{
|
|
pwm_start();
|
|
}
|
|
}
|
|
|
|
void pwm_set_duty(uint16_t duty)
|
|
{
|
|
bool output;
|
|
|
|
pwmInfo.dutyCicle = duty;
|
|
if (duty > 0 && duty < UINT16_MAX) {
|
|
pwm_restart();
|
|
return;
|
|
}
|
|
|
|
// 0% and 100% duty cycle are special cases: constant output.
|
|
pwm_stop();
|
|
pwmInfo.running = 1;
|
|
output = (duty == UINT16_MAX);
|
|
for (uint8_t i = 0; i < pwmInfo.usedPins; ++i)
|
|
{
|
|
gpio_write(pwmInfo.pins[i].pin, output);
|
|
}
|
|
}
|
|
|
|
void pwm_restart()
|
|
{
|
|
if (pwmInfo.running)
|
|
{
|
|
pwm_stop();
|
|
pwm_start();
|
|
}
|
|
}
|
|
|
|
void pwm_start()
|
|
{
|
|
pwmInfo._onLoad = pwmInfo.dutyCicle * pwmInfo._maxLoad / UINT16_MAX;
|
|
pwmInfo._offLoad = pwmInfo._maxLoad - pwmInfo._onLoad;
|
|
pwmInfo._step = PERIOD_ON;
|
|
|
|
// Trigger ON
|
|
uint8_t i = 0;
|
|
for (; i < pwmInfo.usedPins; ++i)
|
|
{
|
|
gpio_write(pwmInfo.pins[i].pin, true);
|
|
}
|
|
|
|
timer_set_load(FRC1, pwmInfo._onLoad);
|
|
timer_set_reload(FRC1, false);
|
|
timer_set_interrupts(FRC1, true);
|
|
timer_set_run(FRC1, true);
|
|
|
|
pwmInfo.running = 1;
|
|
}
|
|
|
|
void pwm_stop()
|
|
{
|
|
timer_set_interrupts(FRC1, false);
|
|
timer_set_run(FRC1, false);
|
|
pwmInfo.running = 0;
|
|
}
|