Stikked @ k4be.pl

Bez tytułu

z Corrupt Rhinoceros, 8 miesiące temu, napisane w C, wyświetlone 113 razy. [paste_expire] 2 miesiące.
URL https://pastebin.k4be.pl/view/b149030b Udostępnij
Pobierz wklejkę lub Pokaż surowy tekst
  1. #define __SDCC__
  2.  
  3. #include "stdint.h"
  4. #include "stdlib.h"
  5. #include "stdbool.h"
  6. #include "stm8s_gpio.h"
  7. #include "stm8s_tim2.h"
  8. #include "stm8s_tim4.h"
  9. #include "stm8s_clk.h"
  10. #include "stm8s_it.h"
  11. #include "stm8s_exti.h"
  12.  
  13. #define _BV(x) (1 << x)
  14.  /*
  15.  
  16.    A
  17.   ___           A - PD1
  18.  |   |          B - PD4        DIG1 - PC7
  19. F| G |B         C - PB4        DIG2 - PA3
  20.  |___|          D - PC5        DIG3 - PD6
  21.  |   |          E - PC6        DIG4 - PC3
  22. E| D |C         F - PD5
  23.  |___|  .       G - PB5
  24.                 . - PC4
  25.  
  26.     0bABCDEFG.
  27. 0 - 0b00000011
  28. 1 - 0b10011111
  29. 2 - 0b00100101
  30. 3 - 0b00001101
  31. 4 - 0b10011001
  32. 5 - 0b01001001
  33. 6 - 0b01000001
  34. 7 - 0b00011111
  35. 8 - 0b00000001
  36. 9 - 0b00001001
  37.  
  38. */
  39.  
  40. volatile  uint16_t rpm=0;
  41. volatile static uint16_t current_period=0;
  42. volatile static uint16_t periods[8]={0};
  43. volatile static int16_t sum = 0;
  44. volatile static uint8_t pos = 0;
  45. volatile static bool filled = false;
  46. volatile static bool overflow = false;
  47. volatile  uint32_t average;
  48.  
  49.  
  50.  
  51. #define DISP_PB(pin) ((0x00000100ull)<<(pin))
  52. #define DISP_PC(pin) ((0x00010000ull)<<(pin))
  53. #define DISP_PD(pin) ((0x01000000ull)<<(pin))
  54.  
  55.  
  56. #define _DISP_V_PB(x) (((x)>>8) & 0xff)
  57. #define _DISP_V_PC(x) (((x)>>16) & 0xff)
  58. #define _DISP_V_PD(x) (((x)>>24) & 0xff)
  59.  
  60.  
  61. #define DISP_IDX_PB 0
  62. #define DISP_IDX_PC 1
  63. #define DISP_IDX_PD 2
  64.  
  65. #define DISP_V(x) {_DISP_V_PB(x), _DISP_V_PC(x), _DISP_V_PD(x)}
  66.  
  67. #define SEG_A     DISP_PD(1)
  68. #define SEG_B     DISP_PD(4)
  69. #define SEG_C     DISP_PB(4)
  70. #define SEG_D     DISP_PC(5)
  71. #define SEG_E     DISP_PC(6)
  72. #define SEG_F     DISP_PD(5)
  73. #define SEG_G     DISP_PB(5)
  74. #define SEG_DOT   DISP_PC(4)
  75. #define SEG_ALL   (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DOT)
  76.  
  77.  
  78.  
  79. static uint8_t get_digit_4(int16_t val, uint8_t idx) {
  80.  
  81.  
  82. }
  83.  
  84. void print(uint16_t value){
  85.         static uint8_t led_disp;
  86.         static const uint16_t digit_vals[4] = {1000, 100, 10, 1};
  87.  
  88.         uint8_t digit;
  89.  
  90.         static const uint8_t pins_symbol[10][3] = {
  91.                 [0] = DISP_V(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F        ),
  92.                 [1] = DISP_V(        SEG_B | SEG_C                                ),
  93.                 [2] = DISP_V(SEG_A | SEG_B         | SEG_D | SEG_E         | SEG_G),
  94.                 [3] = DISP_V(SEG_A | SEG_B | SEG_C | SEG_D                 | SEG_G),
  95.                 [4] = DISP_V(        SEG_B | SEG_C                 | SEG_F | SEG_G),
  96.                 [5] = DISP_V(SEG_A         | SEG_C | SEG_D         | SEG_F | SEG_G),
  97.                 [6] = DISP_V(SEG_A         | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G),
  98.                 [7] = DISP_V(SEG_A | SEG_B | SEG_C                                ),
  99.                 [8] = DISP_V(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G),
  100.                 [9] = DISP_V(SEG_A | SEG_B | SEG_C | SEG_D         | SEG_F | SEG_G),
  101.         };
  102.  
  103.         static const uint8_t pins_all[4] = DISP_V(SEG_ALL);
  104.  
  105.  
  106.         if(value>9999) value = 9999;
  107.  
  108.         GPIO_WriteLow(GPIOC, GPIO_PIN_7);
  109.         GPIO_WriteLow(GPIOA, GPIO_PIN_3);
  110.         GPIO_WriteLow(GPIOD, GPIO_PIN_6);
  111.         GPIO_WriteLow(GPIOC, GPIO_PIN_3);
  112.  
  113.  
  114.  
  115.         digit = (value / digit_vals[led_disp]) % 10;
  116.  
  117.         /* all cathodes high (off) */
  118.         /* GPIOA->ODR |= pins_all[DISP_IDX_PA]; */
  119.         GPIOB->ODR |= pins_all[DISP_IDX_PB];
  120.         GPIOC->ODR |= pins_all[DISP_IDX_PC];
  121.         GPIOD->ODR |= pins_all[DISP_IDX_PD];
  122.  
  123.  
  124.         /* GPIOA->ODR &= ~pins_symbol[digit][DISP_IDX_PA]; */
  125.         GPIOB->ODR &= ~pins_symbol[digit][DISP_IDX_PB];
  126.         GPIOC->ODR &= ~pins_symbol[digit][DISP_IDX_PC];
  127.         GPIOD->ODR &= ~pins_symbol[digit][DISP_IDX_PD];
  128.  
  129.         switch(led_disp){
  130.         case 0:
  131.                 GPIO_WriteHigh(GPIOC, GPIO_PIN_7);
  132.                 break;
  133.         case 1:
  134.                 GPIO_WriteHigh(GPIOA, GPIO_PIN_3);
  135.                 break;
  136.         case 2:
  137.                 GPIO_WriteHigh(GPIOD, GPIO_PIN_6);
  138.                 break;
  139.         case 3:
  140.                 GPIO_WriteHigh(GPIOC, GPIO_PIN_3);
  141.                 break;
  142.         }
  143.  
  144.         led_disp++;
  145.         if(led_disp >= 4)
  146.                 led_disp = 0;
  147. }
  148.  
  149. void main(void)
  150. {
  151.  
  152.  
  153.         GPIO_Init(GPIOA,
  154.                         GPIO_PIN_3,
  155.                         GPIO_MODE_OUT_PP_LOW_FAST);
  156.  
  157.         GPIO_Init(GPIOB,
  158.                         GPIO_PIN_4|
  159.                         GPIO_PIN_5,
  160.                         GPIO_MODE_OUT_PP_LOW_FAST);
  161.  
  162.         GPIO_Init(GPIOC,
  163.                         GPIO_PIN_3|
  164.                         GPIO_PIN_4|
  165.                         GPIO_PIN_5|
  166.                         GPIO_PIN_6|
  167.                         GPIO_PIN_7,
  168.                         GPIO_MODE_OUT_PP_LOW_FAST);
  169.  
  170.         GPIO_Init(GPIOD,
  171.                         GPIO_PIN_1|
  172.                         GPIO_PIN_4|
  173.                         GPIO_PIN_5|
  174.                         GPIO_PIN_6,
  175.                         GPIO_MODE_OUT_PP_LOW_FAST);
  176.  
  177.         //sensor
  178.         GPIO_Init(GPIOD,
  179.                         GPIO_PIN_2,
  180.                         GPIO_MODE_IN_PU_IT);
  181.         EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD,EXTI_SENSITIVITY_FALL_ONLY);
  182.  
  183.         CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSE, DISABLE, CLK_CURRENTCLOCKSTATE_DISABLE);
  184.  
  185.         CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4,ENABLE);
  186.         TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);
  187.         TIM4_TimeBaseInit(TIM4_PRESCALER_128, 255);
  188.         enableInterrupts();
  189.         TIM4_Cmd(ENABLE);
  190.  
  191.         CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);
  192.         TIM2_TimeBaseInit(TIM2_PRESCALER_256, 0xFFFF);
  193.         TIM2_ICInit(TIM2_CHANNEL_3, TIM2_ICPOLARITY_FALLING,TIM2_ICSELECTION_DIRECTTI, TIM2_ICPSC_DIV1,0x00);
  194.         TIM2_ITConfig(TIM2_IT_UPDATE, ENABLE);
  195.         TIM2_Cmd(ENABLE);
  196.  
  197.         while (1) {
  198.  
  199.                 if (overflow) {
  200.                         rpm = 0;
  201.  
  202.                 } else {
  203.  
  204.  
  205.                         rpm =  (uint32_t)(62500 * 60) / average;
  206.                 }
  207.  
  208.                 for (uint16_t i = 1; i < 65200; i++) {
  209.                         for (uint16_t j = 1; j < 3; j++);
  210.                 }
  211.  
  212.         }
  213.  
  214. }
  215.  
  216.  
  217. INTERRUPT_HANDLER(TIM4_UPD_OVF_IRQHandler, 23)
  218. {
  219.         print(rpm);
  220.         TIM4_ClearITPendingBit(TIM4_IT_UPDATE);
  221. }
  222.  
  223.  
  224. INTERRUPT_HANDLER(EXTI_PORTD_IRQHandler, 6)
  225. {
  226.         if(TIM2_GetFlagStatus(TIM2_FLAG_CC3)){
  227.                 current_period = TIM2_GetCapture3();
  228.  
  229.  
  230.                 sum = sum - periods[pos];
  231.                 periods[pos] = current_period;
  232.                 sum += current_period;
  233.  
  234.                 if(++pos == sizeof(periods)/sizeof(*periods))
  235.                 {
  236.                         pos = 0;
  237.                         filled = true;
  238.                 }
  239.                 size_t count = filled ? sizeof(periods)/sizeof(*periods) : pos;
  240.                 average = (sum < 0 ? sum - count / 2 : sum + count / 2 ) / count;
  241.  
  242.  
  243.                 TIM2_ClearFlag(TIM2_FLAG_CC3);
  244.                 overflow = false;
  245.                 TIM2_SetCounter(0);
  246.         }
  247.  
  248. }
  249.  
  250. INTERRUPT_HANDLER(TIM2_UPD_OVF_BRK_IRQHandler, 13)
  251. {
  252.         overflow = true;
  253.         TIM2_ClearITPendingBit(TIM2_IT_UPDATE);
  254. }
  255.  
  256.  

odpowiedź "Bez tytułu"

Tutaj możesz odpowiedzieć na wklejkę z góry

captcha
Wspierane przez Stikked