pwm2.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253
  1. /*
  2. * Software PWM using soft-interrupt timer1.
  3. * Supports higher frequencies compared to Espressif provided one.
  4. *
  5. * Nikolay Fiykov
  6. */
  7. #include <stddef.h>
  8. #include <stdint.h>
  9. #include <string.h>
  10. #include "mem.h"
  11. #include "pin_map.h"
  12. #include "platform.h"
  13. #include "hw_timer.h"
  14. #include "driver/pwm2.h"
  15. #include "user_interface.h"
  16. #define PWM2_TMR_MAGIC_80MHZ 16
  17. #define PWM2_TMR_MAGIC_160MHZ 32
  18. // module vars, lazy initialized, allocated only if pwm2 is being used
  19. static pwm2_module_data_t *moduleData = NULL;
  20. //############################
  21. // tools
  22. static bool isPinSetup(const pwm2_module_data_t *data, const uint8_t pin) {
  23. return data->setupData.pin[pin].pulseResolutions > 0;
  24. }
  25. static uint32_t getCPUTicksPerSec() {
  26. return system_get_cpu_freq() * 1000000;
  27. }
  28. static uint8_t getCpuTimerTicksDivisor() {
  29. return system_get_cpu_freq() == 80 ? PWM2_TMR_MAGIC_80MHZ : PWM2_TMR_MAGIC_160MHZ;
  30. }
  31. static uint32_t findGCD(uint32_t n1, uint32_t n2) {
  32. uint32_t n3;
  33. while (n2 != 0) {
  34. n3 = n1;
  35. n1 = n2;
  36. n2 = n3 % n2;
  37. }
  38. return n1;
  39. }
  40. static uint32_t findGreatesCommonDividerForTimerTicks(uint32_t newTimerTicks, uint32_t oldTimerTicks) {
  41. return oldTimerTicks == 0 ? newTimerTicks : findGCD(newTimerTicks, oldTimerTicks);
  42. }
  43. static uint16_t findAllEnabledGpioMask(pwm2_module_data_t *moduleData) {
  44. uint16_t enableGpioMask = 0;
  45. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  46. if (moduleData->setupData.pin[i].pulseResolutions > 0) {
  47. enableGpioMask |= moduleData->interruptData.pin[i].gpioMask;
  48. }
  49. }
  50. return enableGpioMask;
  51. }
  52. static uint32_t findCommonCPUTicksDivisor(pwm2_module_data_t *moduleData) {
  53. uint32_t gcdCPUTicks = 0;
  54. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  55. if (moduleData->setupData.pin[i].pulseResolutions > 0) {
  56. gcdCPUTicks = findGreatesCommonDividerForTimerTicks(moduleData->setupData.pin[i].resolutionCPUTicks, gcdCPUTicks);
  57. }
  58. }
  59. return gcdCPUTicks;
  60. }
  61. static uint32_t cpuToTimerTicks(uint32_t cpuTicks) {
  62. return cpuTicks / getCpuTimerTicksDivisor();
  63. }
  64. static void updatePinResolutionToInterruptsMultiplier(pwm2_pin_setup_t *sPin, uint32_t timerCPUTicks) {
  65. sPin->resolutionInterruptCounterMultiplier = sPin->resolutionCPUTicks / timerCPUTicks;
  66. }
  67. static void updatePinPulseToInterruptsCounter(pwm2_pin_interrupt_t *iPin, pwm2_pin_setup_t *sPin) {
  68. iPin->pulseInterruptCcounter = (sPin->pulseResolutions + 1) * sPin->resolutionInterruptCounterMultiplier;
  69. }
  70. static uint8_t getDutyAdjustment(const uint32_t duty, const uint32_t pulse) {
  71. if (duty == 0) {
  72. return 0;
  73. } else if (duty == pulse) {
  74. return 2;
  75. } else {
  76. return 1;
  77. }
  78. }
  79. static void updatePinOffCounter(pwm2_pin_interrupt_t *iPin, pwm2_pin_setup_t *sPin) {
  80. iPin->offInterruptCounter = (sPin->duty + getDutyAdjustment(sPin->duty, sPin->pulseResolutions)) * sPin->resolutionInterruptCounterMultiplier;
  81. }
  82. static void reCalculateCommonToAllPinsData(pwm2_module_data_t *moduleData) {
  83. moduleData->interruptData.enabledGpioMask = findAllEnabledGpioMask(moduleData);
  84. moduleData->setupData.interruptTimerCPUTicks = findCommonCPUTicksDivisor(moduleData);
  85. moduleData->setupData.interruptTimerTicks = cpuToTimerTicks(moduleData->setupData.interruptTimerCPUTicks);
  86. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  87. if (isPinSetup(moduleData, i)) {
  88. updatePinResolutionToInterruptsMultiplier(&moduleData->setupData.pin[i], moduleData->setupData.interruptTimerCPUTicks);
  89. updatePinPulseToInterruptsCounter(&moduleData->interruptData.pin[i], &moduleData->setupData.pin[i]);
  90. updatePinOffCounter(&moduleData->interruptData.pin[i], &moduleData->setupData.pin[i]);
  91. }
  92. }
  93. }
  94. static uint64_t enduserFreqToCPUTicks(const uint64_t divisableFreq, const uint64_t freqDivisor, const uint64_t resolution) {
  95. return (getCPUTicksPerSec() / (freqDivisor * resolution)) * divisableFreq;
  96. }
  97. static uint16_t getPinGpioMask(uint8_t pin) {
  98. return 1 << GPIO_ID_PIN(pin_num[pin]);
  99. }
  100. static void set_duty(pwm2_module_data_t *moduleData, const uint8_t pin, const uint32_t duty) {
  101. pwm2_pin_setup_t *sPin = &moduleData->setupData.pin[pin];
  102. pwm2_pin_interrupt_t *iPin = &moduleData->interruptData.pin[pin];
  103. sPin->duty = duty;
  104. updatePinOffCounter(iPin, sPin);
  105. }
  106. static void configureAllPinsAsGpioOutput(pwm2_module_data_t *moduleData) {
  107. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  108. if (isPinSetup(moduleData, i)) {
  109. PIN_FUNC_SELECT(pin_mux[i], pin_func[i]); // set pin as gpio
  110. PIN_PULLUP_EN(pin_mux[i]); // set pin pullup on
  111. }
  112. }
  113. }
  114. static void resetPinCounters(pwm2_module_data_t *moduleData) {
  115. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  116. if (isPinSetup(moduleData, i)) {
  117. moduleData->interruptData.pin[i].currentInterruptCounter = 0;
  118. }
  119. }
  120. }
  121. //############################
  122. // interrupt handler related
  123. static inline void computeIsPinOn(pwm2_pin_interrupt_t *pin, uint16_t *maskOn) {
  124. if (pin->currentInterruptCounter == pin->pulseInterruptCcounter) {
  125. pin->currentInterruptCounter = 1;
  126. } else {
  127. pin->currentInterruptCounter++;
  128. }
  129. // ets_printf("curr=%u on=%u\n", pin->currentInterruptCounter, (pin->currentInterruptCounter < pin->offInterruptCounter));
  130. if (pin->currentInterruptCounter < pin->offInterruptCounter) {
  131. *maskOn |= pin->gpioMask;
  132. }
  133. }
  134. static inline bool isPinSetup2(const pwm2_interrupt_handler_data_t *data, const uint8_t pin) {
  135. return data->pin[pin].gpioMask > 0;
  136. }
  137. static inline uint16_t findAllPinOns(pwm2_interrupt_handler_data_t *data) {
  138. uint16_t maskOn = 0;
  139. for (int i = 1; i < GPIO_PIN_NUM; i++) {
  140. if (isPinSetup2(data, i)) {
  141. computeIsPinOn(&data->pin[i], &maskOn);
  142. }
  143. }
  144. return maskOn;
  145. }
  146. static inline void setGpioPins(const uint16_t enabledGpioMask, const register uint16_t maskOn) {
  147. GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, maskOn);
  148. const register uint16_t maskOff = ~maskOn & enabledGpioMask;
  149. GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, maskOff);
  150. }
  151. static void ICACHE_RAM_ATTR timerInterruptHandler(os_param_t arg) {
  152. pwm2_interrupt_handler_data_t *data = (pwm2_interrupt_handler_data_t *)arg;
  153. setGpioPins(data->enabledGpioMask, findAllPinOns(data));
  154. }
  155. //############################
  156. // driver's public API
  157. void pwm2_init() {
  158. moduleData = os_malloc(sizeof(pwm2_module_data_t));
  159. memset(moduleData, 0, sizeof(*moduleData));
  160. }
  161. pwm2_module_data_t *pwm2_get_module_data() {
  162. return moduleData;
  163. }
  164. bool pwm2_is_pin_setup(const uint8_t pin) {
  165. return isPinSetup(moduleData, pin);
  166. }
  167. void pwm2_setup_pin(
  168. const uint8_t pin,
  169. const uint32_t divisableFreq,
  170. const uint32_t freqDivisor,
  171. const uint32_t resolution,
  172. const uint32_t initDuty
  173. )
  174. {
  175. moduleData->setupData.pin[pin].pulseResolutions = resolution;
  176. moduleData->setupData.pin[pin].divisableFrequency = divisableFreq;
  177. moduleData->setupData.pin[pin].frequencyDivisor = freqDivisor;
  178. moduleData->setupData.pin[pin].resolutionCPUTicks = enduserFreqToCPUTicks(divisableFreq, freqDivisor, resolution);
  179. moduleData->interruptData.pin[pin].gpioMask = getPinGpioMask(pin);
  180. reCalculateCommonToAllPinsData(moduleData);
  181. set_duty(moduleData, pin, initDuty);
  182. }
  183. void pwm2_release_pin(const uint8_t pin) {
  184. moduleData->setupData.pin[pin].pulseResolutions = 0;
  185. moduleData->interruptData.pin[pin].gpioMask = 0;
  186. }
  187. void pwm2_stop() {
  188. if (!moduleData->setupData.isStarted) {
  189. return;
  190. }
  191. platform_hw_timer_close_exclusive();
  192. GPIO_REG_WRITE(GPIO_ENABLE_W1TC_ADDRESS, moduleData->interruptData.enabledGpioMask); // clear pins of being gpio output
  193. moduleData->setupData.isStarted = false;
  194. }
  195. bool pwm2_start() {
  196. if (moduleData->setupData.isStarted) {
  197. return true;
  198. }
  199. if (!platform_hw_timer_init_exclusive(FRC1_SOURCE, TRUE, timerInterruptHandler, (os_param_t)&moduleData->interruptData, (void (*)(void))NULL)) {
  200. return false;
  201. }
  202. configureAllPinsAsGpioOutput(moduleData);
  203. resetPinCounters(moduleData);
  204. GPIO_REG_WRITE(GPIO_ENABLE_W1TS_ADDRESS, moduleData->interruptData.enabledGpioMask); // set pins as gpio output
  205. moduleData->setupData.isStarted = true;
  206. platform_hw_timer_arm_ticks_exclusive(moduleData->setupData.interruptTimerTicks);
  207. return true;
  208. }
  209. bool pwm2_is_started() {
  210. return moduleData->setupData.isStarted;
  211. }
  212. void pwm2_set_duty(const uint8_t pin, const uint32_t duty) {
  213. set_duty(moduleData, pin, duty);
  214. }