digital_output.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436
  1. #include "at32f403a_407.h"
  2. #include "digital_output.h"
  3. #include "FreeRTOS.h"
  4. #include "task.h"
  5. #include "settings_api.h"
  6. #include "io_utils.h"
  7. #include "mux.h"
  8. #include <stdio.h>
  9. #if defined (MDIO_88)
  10. uint16_t output_state_bit;
  11. uint16_t output_mode_bit;
  12. uint16_t output_mode_save_bit;
  13. uint16_t output_pwm[DO_NUMBER];
  14. uint16_t output_pwm_save[DO_NUMBER];
  15. uint16_t output_pwm_period[DO_NUMBER];
  16. uint16_t output_pwm_period_save[DO_NUMBER];
  17. out_t outputs[DO_NUMBER] = {
  18. {GPIOC, GPIO_PINS_12, 0, 0, 0, false, 0, 0}, // -
  19. {GPIOD, GPIO_PINS_2, 0, 0, 0, false, 0, 0}, // -
  20. {GPIOE, GPIO_PINS_6, 0, 0, 0, false, 0, 0}, // TMR9_CH2 (remap)
  21. {GPIOC, GPIO_PINS_1, 0, 0, 0, false, 0, 0}, // -
  22. {GPIOC, GPIO_PINS_11, 0, 0, 0, false, 0, 0}, // -
  23. {GPIOD, GPIO_PINS_3, 0, 0, 0, false, 0, 0}, // -
  24. {GPIOE, GPIO_PINS_5, 0, 0, 0, false, 0, 0}, // TMR9_CH1 (remap)
  25. {GPIOC, GPIO_PINS_2, 0, 0, 0, false, 0, 0} // -
  26. };
  27. //
  28. void do_init(void)
  29. {
  30. // Таймер для выходов в режиме PWM
  31. di_out_pwm_tim_init();
  32. // TODO Битовые поля вынести из настроек.
  33. #if 1
  34. settings.dout[0].state = 1;
  35. settings.dout[1].state = 0;
  36. settings.dout[2].state = 1;
  37. settings.dout[7].state = 1;
  38. settings.dout_save[0].state = 0;
  39. settings.dout_save[1].state = 1;
  40. settings.dout_save[2].state = 0;
  41. settings.dout_save[7].state = 1;
  42. #endif
  43. // Актуализация битовых полей (используюся для управления по modbus)
  44. // Состояние выходов вкл/выкл.
  45. do_update_field(&settings.dout[0].state, &settings.do_state_bits);
  46. do_update_field(&settings.dout_save[0].state, &settings.do_state_save_bits);
  47. // Режим работы выходов
  48. do_update_field(&settings.dout[0].mode, &settings.do_mode_bits);
  49. do_update_field(&settings.dout_save[0].mode, &settings.do_mode_save_bits);
  50. // Значение на выходах
  51. do_update_field(&settings.dout[0].value, &settings.do_value_bits);
  52. do_update_field(&settings.dout_save[0].value, &settings.do_value_save_bits);
  53. for (int i = 0; i < DO_NUMBER; i++)
  54. {
  55. do_gpio_init(&outputs[i], i);
  56. if (save_mode_get()) {
  57. do_update(&settings.dout_save[i], i) ;
  58. }
  59. else {
  60. do_update(&settings.dout[i], i) ;
  61. }
  62. }
  63. #if 0
  64. output_state_bit = settings.do_bits;
  65. output_mode_bit = settings.do_mode_bits;
  66. output_mode_save_bit = settings.do_mode_save_bits;
  67. // Таймер для выходов в режиме PWM
  68. di_out_pwm_tim_init();
  69. for (int i = 0; i < DO_NUMBER; i++)
  70. {
  71. output_pwm[i] = settings.do_pwm[i];
  72. output_pwm_save[i] = settings.do_pwm_save[i];
  73. output_pwm_period[i] = settings.do_pwm_period[i];
  74. output_pwm_period_save[i] = settings.do_pwm_period_save[i];
  75. if (save_mode_get()) {
  76. outputs[i].pwm_duty = settings.do_pwm_save[i];
  77. outputs[i].pwm_period = settings.do_pwm_period_save[i];
  78. }
  79. else {
  80. outputs[i].pwm_duty = settings.do_pwm[i];
  81. outputs[i].pwm_period = settings.do_pwm_period[i];
  82. }
  83. do_gpio_init(&outputs[i], i);
  84. do_update(&outputs[i], i) ;
  85. }
  86. #endif
  87. }
  88. //
  89. void do_update_field(uint8_t *param, uint16_t *field)
  90. {
  91. for (int i = 0; i < DO_NUMBER; i++)
  92. {
  93. if (*param)
  94. *field |= 1 << i;
  95. else
  96. *field &= ~(1 << i);
  97. param += sizeof(do_t);
  98. }
  99. }
  100. //
  101. void do_gpio_init(out_t *out, uint8_t index)
  102. {
  103. gpio_init_type gpio_init_struct;
  104. gpio_default_para_init(&gpio_init_struct);
  105. gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  106. gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  107. gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  108. gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  109. gpio_init_struct.gpio_pins = out->pin;
  110. gpio_init(out->port, &gpio_init_struct);
  111. }
  112. // Установка состояний дискретных выходов (вкл./выкл.)
  113. void do_set_state(bool save_mode)
  114. {
  115. // Обычный режим работы
  116. if (!save_mode) {
  117. for (int i = 0; i < DO_NUMBER; i++) {
  118. settings.dout[i].state = (uint8_t)((settings.do_state_bits >> i) & 1);
  119. }
  120. }
  121. // Безопасный режим работы
  122. else {
  123. for (int i = 0; i < DO_NUMBER; i++) {
  124. settings.dout_save[i].state = (uint8_t)((settings.do_state_save_bits >> i) & 1);
  125. }
  126. }
  127. }
  128. //
  129. void do_set_common(void)
  130. {
  131. bool flag = false;
  132. for (int i = 0; i < DO_NUMBER; i++)
  133. {
  134. #if 0
  135. //
  136. if ((settings.do_bits & (1 << i)) != (output_state_bit & (1 << i))) {
  137. settings.do_bits = output_state_bit;
  138. flag = true;
  139. }
  140. else if ((settings.do_mode_bits & (1 << i)) != (output_mode_bit & (1 << i))) {
  141. settings.do_mode_bits ^= (1 << i);
  142. settings.do_mode_bits = output_mode_bit;
  143. flag = true;
  144. }
  145. else if (settings.do_pwm[i] != output_pwm[i]) {
  146. settings.do_pwm[i] = output_pwm[i];
  147. flag = true;
  148. }
  149. else if (settings.do_pwm_save[i] != output_pwm_save[i]) {
  150. settings.do_pwm_save[i] = output_pwm_save[i];
  151. flag = true;
  152. }
  153. else if (settings.do_pwm_period [i] != output_pwm_period[i]) {
  154. settings.do_pwm_period[i] = output_pwm_period[i];
  155. flag = true;
  156. }
  157. else if (settings.do_pwm_period_save[i] != output_pwm_period_save[i]) {
  158. settings.do_pwm_period_save[i] = output_pwm_period_save[i];
  159. flag = true;
  160. }
  161. if (flag)
  162. do_update(&outputs[i], i);
  163. #endif
  164. }
  165. }
  166. //
  167. void do_set(void)
  168. {
  169. #if 0
  170. if (output_state_bit == settings.do_bits)
  171. return;
  172. // Состояние выхода/выходов изменилось
  173. for (int i = 0; i < DO_NUMBER; i++)
  174. {
  175. if ((settings.do_bits & (1 << i)) != (output_state_bit & (1 << i)))
  176. {
  177. do_update(&outputs[i], i);
  178. }
  179. }
  180. // Сохраним новое значение выходов в настройках
  181. settings.do_bits = output_state_bit;
  182. #endif
  183. }
  184. // Установка значения на выходе
  185. void do_update(do_t *out, uint8_t i)
  186. {
  187. // Режим ШИМ
  188. if (out->mode) {
  189. do_set_pwm(out->pwm_period, out->pwm_duty, i);
  190. }
  191. // Режим обычного выхода
  192. else {
  193. do_set_out(&outputs[i], out->value);
  194. }
  195. }
  196. #if 0
  197. // Установка значения на выходе
  198. void do_update(out_t *out, uint8_t i)
  199. {
  200. // Режим ШИМ
  201. if (settings.do_mode_bits & (1 << i)) {
  202. // Безопасный режим включен
  203. if (save_mode_get())
  204. do_set_pwm(settings.do_pwm_period_save[i], settings.do_pwm_save[i], i);
  205. else
  206. do_set_pwm(settings.do_pwm_period[i], settings.do_pwm[i], i);
  207. }
  208. // Режим обычного выхода
  209. else {
  210. out->mode = 0;
  211. // Безопасный режим включен
  212. if (save_mode_get())
  213. do_set_out(out, settings.do_save_bits & (1 << i));
  214. else
  215. do_set_out(out, settings.do_bits & (1 << i));
  216. }
  217. }
  218. #endif
  219. //
  220. void do_set_mode(void)
  221. {
  222. #if 0
  223. if (output_mode_bit == settings.do_mode_bits)
  224. return;
  225. // Состояние выхода/выходов изменилось
  226. for (int i = 0; i < DO_NUMBER; i++)
  227. {
  228. if ((settings.do_mode_bits & (1 << i)) != (output_mode_bit & (1 << i)))
  229. {
  230. settings.do_mode_bits ^= (1 << i);
  231. do_update(&outputs[i], i);
  232. }
  233. }
  234. settings.do_mode_bits = output_mode_bit;
  235. #endif
  236. }
  237. //
  238. void do_set_pwm(uint16_t period, uint16_t duty, uint8_t index)
  239. {
  240. uint16_t duty_calc;
  241. if (duty == 0)
  242. duty_calc = 0;
  243. else
  244. duty_calc = (duty*period/100 < 1) ? 1 : duty*period/100;
  245. outputs[index].pwm_flag = false;
  246. outputs[index].pwm_period_cnt = 0;
  247. outputs[index].pwm_duty_cnt = 0;
  248. outputs[index].pwm_period = period;
  249. outputs[index].pwm_duty = duty_calc;
  250. outputs[index].mode = 1;
  251. }
  252. //
  253. void do_set_out(out_t *out, uint8_t val)
  254. {
  255. if (val) {
  256. gpio_bits_set(out->port, out->pin);
  257. }
  258. else {
  259. gpio_bits_reset(out->port, out->pin);
  260. }
  261. }
  262. //
  263. void out_as_pwm(void)
  264. {
  265. uint32_t timer_period;
  266. uint16_t pwm_pulse;
  267. crm_clocks_freq_type crm_clocks_freq_struct = {0};
  268. tmr_output_config_type tmr_output_struct;
  269. crm_periph_clock_enable(CRM_TMR9_PERIPH_CLOCK, TRUE);
  270. crm_clocks_freq_get(&crm_clocks_freq_struct);
  271. //timer_period = (crm_clocks_freq_struct.sclk_freq / 10 ) - 1;
  272. timer_period = 24000 - 1;
  273. pwm_pulse = 125*timer_period/1000;
  274. tmr_base_init(TMR9, 24000 - 1, 1000 - 1);
  275. tmr_cnt_dir_set(TMR9, TMR_COUNT_UP);
  276. tmr_output_default_para_init(&tmr_output_struct);
  277. tmr_output_struct.oc_mode = TMR_OUTPUT_CONTROL_PWM_MODE_A;
  278. tmr_output_struct.oc_output_state = TRUE;
  279. tmr_output_struct.oc_polarity = TMR_OUTPUT_ACTIVE_HIGH;
  280. tmr_output_struct.oc_idle_state = TRUE;
  281. tmr_output_channel_config(TMR9, TMR_SELECT_CHANNEL_1, &tmr_output_struct);
  282. tmr_channel_value_set(TMR9, TMR_SELECT_CHANNEL_1, pwm_pulse);
  283. tmr_flag_clear(TMR9, TMR_OVF_FLAG);
  284. nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  285. nvic_irq_enable(TMR1_BRK_TMR9_IRQn, 5, 0);
  286. //tmr_interrupt_enable(TMR9, TMR_OVF_INT, TRUE);
  287. tmr_interrupt_enable(TMR9, TMR_C1_INT, TRUE);
  288. tmr_counter_enable(TMR9, TRUE);
  289. }
  290. // -------------------------------------------------------------------------- //
  291. // PWM
  292. // Таймер для выходов в режиме PWM. Частота 10Гц.
  293. void di_out_pwm_tim_init(void)
  294. {
  295. uint16_t prescaler_value = 0;
  296. uint16_t timer_period = 1000 - 1;
  297. gpio_init_type gpio_init_struct;
  298. gpio_default_para_init(&gpio_init_struct);
  299. gpio_init_struct.gpio_pins = GPIO_PINS_15;
  300. gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  301. gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  302. gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  303. gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  304. gpio_init(GPIOB, &gpio_init_struct);
  305. crm_periph_clock_enable(CRM_TMR9_PERIPH_CLOCK, TRUE);
  306. prescaler_value = (uint16_t)(system_core_clock / 10000) - 1;
  307. tmr_base_init(TMR9, timer_period, prescaler_value);
  308. tmr_cnt_dir_set(TMR9, TMR_COUNT_UP);
  309. tmr_clock_source_div_set(TMR9, TMR_CLOCK_DIV1);
  310. nvic_irq_enable(TMR1_BRK_TMR9_IRQn, 5, 0);
  311. tmr_interrupt_enable(TMR9, TMR_OVF_INT, TRUE);
  312. tmr_counter_enable(TMR9, TRUE);
  313. }
  314. // Реализация программного PWM для цифровых выходов
  315. inline void pwm_proc(void)
  316. {
  317. for (int i = 0; i < DO_NUMBER; i++)
  318. {
  319. if (outputs[i].mode) // режим PWM
  320. {
  321. if (outputs[i].pwm_period_cnt == outputs[i].pwm_period /*PWM_PERIOD_TEST*/) {
  322. outputs[i].pwm_period_cnt = 0;
  323. }
  324. if (outputs[i].pwm_period_cnt == 0) {
  325. outputs[i].pwm_flag = false;
  326. gpio_bits_set(outputs[i].port, outputs[i].pin);
  327. //gpio_bits_set(GPIOB, GPIO_PINS_15);
  328. }
  329. if (outputs[i].pwm_duty_cnt == outputs[i].pwm_duty /*PWM_DUTY_TEST*/) {
  330. outputs[i].pwm_duty_cnt = 0;
  331. gpio_bits_reset(outputs[i].port, outputs[i].pin);
  332. //gpio_bits_reset(GPIOB, GPIO_PINS_15);
  333. outputs[i].pwm_flag = true;
  334. }
  335. outputs[i].pwm_period_cnt++;
  336. if (outputs[i].pwm_flag == false) {
  337. outputs[i].pwm_duty_cnt++;
  338. }
  339. }
  340. }
  341. }
  342. // Реализация программного PWM для цифровых выходов
  343. void TMR1_BRK_TMR9_IRQHandler(void)
  344. {
  345. if(tmr_flag_get(TMR9, TMR_OVF_FLAG) != RESET)
  346. {
  347. tmr_flag_clear(TMR9, TMR_OVF_FLAG);
  348. //GPIOB->odt ^= GPIO_PINS_15;
  349. pwm_proc();
  350. }
  351. }
  352. #endif