pwm2.c 8.1 KB

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