API tools faq
paste
Emania

Stopky

Emania
Nov 17th, 2018
149
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.74 KB | None | 0 0
raw download clone embed print report
  1. #include "stm32f4xx.h"
  2. #include <stdio.h>
  3.  
  4. #define setbit(reg, bit) ((reg) |= (1U << (bit)))       // set bit to 1
  5. #define clrbit(reg, bit) ((reg) &= (~(1U << (bit))))    // set bit to 0
  6. #define tglbit(reg, bit) ((reg) ^= (1U << (bit)))       // flip bit
  7. #define getbit(reg, bit) ((reg & (1U << bit))>>bit)     // read bit
  8.  
  9. /*
  10. MULTIFUNCTION SHIELD
  11. 4 red LEDs : PIN 10, 11, 12, 13
  12. 4-digit 7-sement LED : Latch 4, Clock 7, Data 8
  13. buttons: PIN A1, A2, A3
  14.  
  15. Zápis do Latch – pin 4 (start zápisu LOW, konec HIGH)
  16. Hodinový pulz (takt) – pin 7
  17. Sériová data – pin 8 – zápis 2× 8 bitů (2× Byte)
  18. (první Byte – data rozsvícených LED – rozsvícení LOW, vypnutí HIGH)
  19.  
  20. http://kabinet.fyzika.net/dilna/ARDUINO/Popis-Arduino_Multi-function_Shield.pd
  21. fmail
  22.  
  23. help code
  24.  
  25. # Write a decimal number between 0 and 9 to one of the 4 digits of the display
  26. void WriteNumberToSegment(byte Segment, byte Value){
  27.     digitalWrite(LATCH_DIO,LOW);
  28.     shiftOut(DATA_DIO, CLK_DIO, MSBFIRST, SEGMENT_MAP[Value]);
  29.     shiftOut(DATA_DIO, CLK_DIO, MSBFIRST, SEGMENT_SELECT[Segment] );
  30.     digitalWrite(LATCH_DIO,HIGH);
  31. }
  32.  
  33. LED:
  34. PB6 - D10 (led 4)
  35. PA7 - D11 (led 3)
  36. PA6 - D12 (led 2)
  37. PA5 - D13 (led 1)
  38.  
  39. DISPLAY:
  40. PB5 - D4 (Latch)
  41. PA8 - D7 (Clock)
  42. PA9 - D8 (Data)
  43.  
  44. BUTTONS:
  45. PA_1 - A1 (button 1)
  46. PA_4 - A2 (button 2)
  47. PB_0 - A3 (button 3)
  48.  
  49. read button: GPIOx_IDR
  50.  
  51. set buttons str. 158
  52. 00: No pull-up, pull-down
  53. 01: Pull-up
  54. 10: Pull-down
  55. 11: Reserved
  56.  
  57. */
  58.  
  59.  
  60.  
  61.  
  62.  
  63. int packet;
  64. void WriteToSegment();
  65.  
  66.  
  67. void display_num1(int num){
  68.     switch (num){
  69.             case 0:
  70.                 packet=0b1100000000001000;
  71.                     WriteToSegment();
  72.                 break;
  73.             case 1:
  74.                 packet=0b1111100100001000;
  75.                     WriteToSegment();
  76.                 break;
  77.             case 2:
  78.                 packet=0b1010010000001000;
  79.                     WriteToSegment();
  80.                 break;
  81.             case 3:
  82.                 packet=0b1011000000001000;
  83.                     WriteToSegment();
  84.                 break;
  85.             case 4:
  86.                 packet=0b1001100100001000;
  87.                     WriteToSegment();
  88.                 break;
  89.             case 5:
  90.                 packet=0b1001001000001000;
  91.                     WriteToSegment();
  92.                 break;
  93.             case 6:
  94.                 packet=0b1000001000001000;
  95.                     WriteToSegment();
  96.                 break;
  97.             case 7:
  98.                 packet=0b1111100000001000;
  99.                     WriteToSegment();
  100.                 break;
  101.             case 8:
  102.                 packet=0b1000000000001000;
  103.                     WriteToSegment();
  104.                 break;
  105.             case 9:
  106.                 packet=0b1001000000001000;
  107.                     WriteToSegment();
  108.                 break;
  109.             default:
  110.                 packet=0b1011111100001000;
  111.                     WriteToSegment();
  112.                 break;
  113.         }
  114. }
  115.  
  116. void display_num10(int num){
  117.     switch (num){
  118.             case 0:
  119.                 packet=0b1100000000000100;
  120.                     WriteToSegment();
  121.                 break;
  122.             case 1:
  123.                 packet=0b1111100100000100;
  124.                     WriteToSegment();
  125.                 break;
  126.             case 2:
  127.                 packet=0b1010010000000100;
  128.                     WriteToSegment();
  129.                 break;
  130.             case 3:
  131.                 packet=0b1011000000000100;
  132.                     WriteToSegment();
  133.                 break;
  134.             case 4:
  135.                 packet=0b1001100100000100;
  136.                     WriteToSegment();
  137.                 break;
  138.             case 5:
  139.                 packet=0b1001001000000100;
  140.                     WriteToSegment();
  141.                 break;
  142.             case 6:
  143.                 packet=0b1000001000000100;
  144.                     WriteToSegment();
  145.                 break;
  146.             case 7:
  147.                 packet=0b1111100000000100;
  148.                     WriteToSegment();
  149.                 break;
  150.             case 8:
  151.                 packet=0b1000000000000100;
  152.                     WriteToSegment();
  153.                 break;
  154.             case 9:
  155.                 packet=0b1001000000000100;
  156.                     WriteToSegment();
  157.                 break;
  158.             default:
  159.                 packet=0b1011111100000100;
  160.                     WriteToSegment();
  161.                 break;
  162.         }
  163. }
  164.  
  165. void display_num10_dot(int num){
  166.     switch (num){
  167.             case 0:
  168.                 packet=0b0100000000000100;
  169.                     WriteToSegment();
  170.                 break;
  171.             case 1:
  172.                 packet=0b0111100100000100;
  173.                     WriteToSegment();
  174.                 break;
  175.             case 2:
  176.                 packet=0b0010010000000100;
  177.                     WriteToSegment();
  178.                 break;
  179.             case 3:
  180.                 packet=0b0011000000000100;
  181.                     WriteToSegment();
  182.                 break;
  183.             case 4:
  184.                 packet=0b0001100100000100;
  185.                     WriteToSegment();
  186.                 break;
  187.             case 5:
  188.                 packet=0b0001001000000100;
  189.                     WriteToSegment();
  190.                 break;
  191.             case 6:
  192.                 packet=0b0000001000000100;
  193.                     WriteToSegment();
  194.                 break;
  195.             case 7:
  196.                 packet=0b0111100000000100;
  197.                     WriteToSegment();
  198.                 break;
  199.             case 8:
  200.                 packet=0b0000000000000100;
  201.                     WriteToSegment();
  202.                 break;
  203.             case 9:
  204.                 packet=0b0001000000000100;
  205.                     WriteToSegment();
  206.                 break;
  207.             default:
  208.                 packet=0b0011111100000100;
  209.                     WriteToSegment();
  210.                 break;
  211.         }
  212. }
  213.  
  214. void display_num100(int num){
  215.     switch (num){
  216.             case 0:
  217.                 packet=0b1100000000000010;
  218.                     WriteToSegment();
  219.                 break;
  220.             case 1:
  221.                 packet=0b1111100100000010;
  222.                     WriteToSegment();
  223.                 break;
  224.             case 2:
  225.                 packet=0b1010010000000010;
  226.                     WriteToSegment();
  227.                 break;
  228.             case 3:
  229.                 packet=0b1011000000000010;
  230.                     WriteToSegment();
  231.                 break;
  232.             case 4:
  233.                 packet=0b1001100100000010;
  234.                     WriteToSegment();
  235.                 break;
  236.             case 5:
  237.                 packet=0b1001001000000010;
  238.                     WriteToSegment();
  239.                 break;
  240.             case 6:
  241.                 packet=0b1000001000000010;
  242.                     WriteToSegment();
  243.                 break;
  244.             case 7:
  245.                 packet=0b1111100000000010;
  246.                     WriteToSegment();
  247.                 break;
  248.             case 8:
  249.                 packet=0b1000000000000010;
  250.                     WriteToSegment();
  251.                 break;
  252.             case 9:
  253.                 packet=0b1001000000000010;
  254.                     WriteToSegment();
  255.                 break;
  256.             default:
  257.                 packet=0b1011111100000010;
  258.                     WriteToSegment();
  259.                 break;
  260.         }
  261. }
  262.  
  263. void display_num1000(int num){
  264.     switch (num){
  265.             case 0:
  266.                 packet=0b1100000000000001;
  267.                     WriteToSegment();
  268.                 break;
  269.             case 1:
  270.                 packet=0b1111100100000001;
  271.                     WriteToSegment();
  272.                 break;
  273.             case 2:
  274.                 packet=0b1010010000000001;
  275.                     WriteToSegment();
  276.                 break;
  277.             case 3:
  278.                 packet=0b1011000000000001;
  279.                     WriteToSegment();
  280.                 break;
  281.             case 4:
  282.                 packet=0b1001100100000001;
  283.                     WriteToSegment();
  284.                 break;
  285.             case 5:
  286.                 packet=0b1001001000000001;
  287.                     WriteToSegment();
  288.                 break;
  289.             case 6:
  290.                 packet=0b1000001000000001;
  291.                     WriteToSegment();
  292.                 break;
  293.             case 7:
  294.                 packet=0b1111100000000001;
  295.                     WriteToSegment();
  296.                 break;
  297.             case 8:
  298.                 packet=0b1000000000000001;
  299.                     WriteToSegment();
  300.                 break;
  301.             case 9:
  302.                 packet=0b1001000000000001;
  303.                     WriteToSegment();
  304.                 break;
  305.             default:
  306.                 packet=0b1011111100000001;
  307.                     WriteToSegment();
  308.                 break;
  309.         }
  310. }
  311.  
  312.  
  313. void initBUTT(void){
  314.     setbit(RCC->AHB1ENR, 1);
  315.     setbit(RCC->AHB1ENR, 0);
  316.  
  317.     // PA_1 - A1
  318.     setbit(GPIOA->PUPDR, 2);
  319.     clrbit(GPIOA->PUPDR, 3);
  320.  
  321.     // PA_4 - A2
  322.     setbit(GPIOA->PUPDR, 8);
  323.     clrbit(GPIOA->PUPDR, 9);
  324.  
  325.     // PB_0 - A3
  326.     setbit(GPIOB->PUPDR, 0);
  327.     clrbit(GPIOB->PUPDR, 1);
  328. }
  329.  
  330. void initTIM2(void){
  331.     setbit(RCC->APB1ENR, 0);    /* enable Clock for TIM2 */
  332.     TIM2->PSC = 1;              /* prescaler - doplnte podle potreby */
  333.     TIM2->ARR = 1280000;        /* autoreload - doplnte podle potreby */
  334.     setbit(TIM2->CR1, 0);       /* enable TIM2 */
  335.     clrbit(TIM2->SR, 0);        /* status TIM2 */
  336. }
  337.  
  338. void initGPIO(void){
  339.  
  340.     //set clock
  341.     setbit(RCC->AHB1ENR, 0);
  342.     setbit(RCC->AHB1ENR, 1);
  343.  
  344.     // set to output - 01
  345.  
  346.     // PA 6 to output
  347.     setbit(GPIOA->MODER, 12);
  348.     clrbit(GPIOA->MODER, 13);
  349.  
  350.     // PA 7 to output
  351.     setbit(GPIOA->MODER, 14);
  352.     clrbit(GPIOA->MODER, 15);
  353.  
  354.     // PA 8 to output
  355.     setbit(GPIOA->MODER, 16);
  356.     clrbit(GPIOA->MODER, 17);
  357.  
  358.     // PA 9 to output
  359.     setbit(GPIOA->MODER, 18);
  360.     clrbit(GPIOA->MODER, 19);
  361.  
  362.     // PB 5 to output
  363.     setbit(GPIOB->MODER, 10);
  364.     clrbit(GPIOB->MODER, 11);
  365.  
  366.     // PB 6 to output
  367.     setbit(GPIOB->MODER, 12);
  368.     clrbit(GPIOB->MODER, 13);
  369. }
  370.  
  371.  
  372. void WriteToSegment(){
  373.     clrbit(GPIOB->ODR,5);   // PB5 - D4 (Latch)
  374.     for(int i=15; i > (-1); i--){
  375.         if(getbit(packet,i)==1){
  376.             setbit(GPIOA->ODR, 9);  // PA9 - D8 (Data)
  377.         }else{
  378.             clrbit(GPIOA->ODR,9);   // PA9 - D8 (Data)
  379.         }
  380.         setbit(GPIOA->ODR,8);   // PA8 - D7 (Clock)
  381.         clrbit(GPIOA->ODR,8);   // PA8 - D7 (Clock)
  382.     }
  383.     setbit(GPIOB->ODR,5);   // PB5 - D4 (Latch)
  384. }
  385.  
  386.  
  387.  
  388. // Sériová data – pin 8 – zápis 2× 8 bitů (2× Byte)
  389. // 1. byte: the 8 segment information (rozsvícení LOW, vypnutí HIGH)
  390. // 2. byte: 00001111 - show on all displays
  391. void display(int v){
  392.     switch (v){
  393.         case 0:
  394.             packet=0b1111011100000001;
  395.                 WriteToSegment();
  396.             break;
  397.         case 1:
  398.             packet=0b1110111100000001;
  399.                 WriteToSegment();
  400.             break;
  401.         case 2:
  402.             packet=0b1101111100000001;
  403.                 WriteToSegment();
  404.             break;
  405.         case 3:
  406.             packet=0b1111111000000001;
  407.                 WriteToSegment();
  408.             break;
  409.         case 4:
  410.             packet=0b1111111000000010;
  411.                 WriteToSegment();
  412.             break;
  413.         case 5:
  414.             packet=0b1111111000000100;
  415.                 WriteToSegment();
  416.             break;
  417.         case 6:
  418.             packet=0b1111111000001000;
  419.                 WriteToSegment();
  420.             break;
  421.         case 7:
  422.             packet=0b1111110100001000;
  423.                 WriteToSegment();
  424.             break;
  425.         case 8:
  426.             packet=0b1111101100001000;
  427.                 WriteToSegment();
  428.             break;
  429.         case 9:
  430.             packet=0b1111011100001000;
  431.                 WriteToSegment();
  432.             break;
  433.         case 10:
  434.             packet=0b1111011100000100;
  435.                 WriteToSegment();
  436.             break;
  437.         default:
  438.             packet=0b1111011100000010;
  439.                 WriteToSegment();
  440.             break;
  441.     }
  442. }
  443.  
  444. // LED
  445. void led(int status){
  446.     switch (status){
  447.         case 0:
  448.             clrbit(GPIOA->ODR,5);
  449.             setbit(GPIOA->ODR,6);
  450.             setbit(GPIOA->ODR,7);
  451.             setbit(GPIOB->ODR,6);
  452.             break;
  453.         case 1:
  454.             setbit(GPIOA->ODR,5);
  455.             clrbit(GPIOA->ODR,6);
  456.             setbit(GPIOA->ODR,7);
  457.             setbit(GPIOB->ODR,6);
  458.             break;
  459.         case 2:
  460.             setbit(GPIOA->ODR,5);
  461.             setbit(GPIOA->ODR,6);
  462.             clrbit(GPIOA->ODR,7);
  463.             setbit(GPIOB->ODR,6);
  464.             break;
  465.         default:
  466.             setbit(GPIOA->ODR,5);
  467.             setbit(GPIOA->ODR,6);
  468.             setbit(GPIOA->ODR,7);
  469.             clrbit(GPIOB->ODR,6);
  470.             break;
  471.     }
  472. }
  473.  
  474. void led1(int light){
  475.     if(light)
  476.         clrbit(GPIOA->ODR,6);
  477.     else
  478.         setbit(GPIOA->ODR,6);
  479. }
  480.  
  481. void led2(int light){
  482.     if(light)
  483.         clrbit(GPIOA->ODR,7);
  484.     else
  485.         setbit(GPIOA->ODR,7);
  486. }
  487.  
  488. void led3(int light){
  489.     if(light)
  490.         clrbit(GPIOB->ODR,6);
  491.     else
  492.         setbit(GPIOB->ODR,6);
  493. }
  494.  
  495. void ledRESET(void){
  496.     setbit(GPIOA->ODR,5);
  497.     setbit(GPIOA->ODR,6);
  498.     setbit(GPIOA->ODR,7);
  499.     setbit(GPIOB->ODR,6);
  500. }
  501.  
  502.  
  503. void display_time(int time){
  504.     display_num1(time % 10);
  505.     display_num10((time % 100) / 10);
  506.     display_num100((time % 1000) / 100);
  507.     display_num1000(time / 1000);
  508. }
  509.  
  510. void display_time_precise(int time_in_100ms){
  511.     display_num1(time_in_100ms % 10);
  512.         display_num10_dot((time_in_100ms % 100) / 10);
  513.         display_num100((time_in_100ms % 1000) / 100);
  514.         display_num1000(time_in_100ms / 1000);
  515. }
  516.  
  517.  
  518.  
  519. //hlavni chod programu
  520. int main(void){
  521.  
  522.     initBUTT();
  523.     initGPIO();
  524.     initTIM2();
  525.  
  526.     int time = 0;   // time in 100ms
  527.     int B1, B2, B3;
  528.     int PUSHED = 0;
  529.     int STATUS = 0; // 0 - running, 1 - stopped, 2 - reset
  530.     int PRECISE = 0; // 0 - slow, 1 - fast
  531.  
  532.  
  533.     int B1P = 0;
  534.     int B2P = 0;
  535.     int B3P = 0;
  536.  
  537.     while (1){
  538.         B1 = !getbit(GPIOA->IDR, 1); // button 1 is pushed down
  539.         B2 = !getbit(GPIOA->IDR, 4); // button 2 is pushed down
  540.         B3 = !getbit(GPIOB->IDR, 0); // button 3 is pushed down
  541.  
  542.  
  543.         if(B1 && B1P == 0){ // pushed B1 and was not previously pushed
  544.             B1P = 1;
  545.             STATUS = (STATUS + 1) % 3;
  546.         }
  547.  
  548.         if(B2 && B2P == 0){ // pushed B2 and was not previously pushed
  549.             B2P = 1;
  550.             PRECISE = (PRECISE + 1) % 2;
  551.         }
  552.  
  553.         if(B3 && B3P == 0){ // pushed B3 and was not previously pushed
  554.             B3P = 1;
  555.             time += 20;     // cheating ;-)
  556.         }
  557.  
  558.         if(!B1 && B1P == 1) // B1 is released
  559.             B1P = 0;
  560.         if(!B2 && B2P == 1) // B2 is released
  561.             B2P = 0;
  562.         if(!B3 && B3P == 1) // B3 is released
  563.             B3P = 0;
  564.  
  565.  
  566.         if(STATUS == 2) // reset
  567.             time = 0;
  568.  
  569.         led1(PRECISE == 1); // show if counting in precise mode
  570.         led2(STATUS == 1);  // show if stopped
  571.         led3(STATUS == 2);  // show if reset
  572.  
  573.         if(PRECISE == 0)
  574.             display_time(time / 10);
  575.         else
  576.             display_time_precise(time);
  577.  
  578.         if(getbit(TIM2->SR, 0)){
  579.             clrbit(TIM2->SR, 0);
  580.             if(STATUS == 0)
  581.                 time++;
  582.  
  583.             if(PUSHED && B3P)
  584.                 PUSHED = 0;
  585.         }
  586.     }
  587. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!