API tools faq
paste
Emania

MAM - UART

Emania
Jan 2nd, 2019
135
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.13 KB | None | 0 0
raw download clone embed print report
  1. #include "stm32f4xx.h"
  2.  
  3. #define setbit(reg, bit) ((reg) |= (1U << (bit)))       // set bit to 1
  4. #define clrbit(reg, bit) ((reg) &= (~(1U << (bit))))    // set bit to 0
  5. #define tglbit(reg, bit) ((reg) ^= (1U << (bit)))       // flip bit
  6. #define getbit(reg, bit) ((reg & (1U << bit))>>bit)     // get bit
  7. #define readbit(reg, bit) ((reg) & (1<<bit))            // read bit
  8.  
  9. int packet;
  10. int bytes = 0;
  11. char buffer;
  12. char to_display[5];
  13. char num;
  14.  
  15. void initDisp(void){
  16.  
  17.     //set clock
  18.     setbit(RCC->AHB1ENR, 0);
  19.     setbit(RCC->AHB1ENR, 1);
  20.  
  21.     // set to output - 01
  22.  
  23.     // PA 6 to output
  24.     setbit(GPIOA->MODER, 12);
  25.     clrbit(GPIOA->MODER, 13);
  26.  
  27.     // PA 7 to output
  28.     setbit(GPIOA->MODER, 14);
  29.     clrbit(GPIOA->MODER, 15);
  30.  
  31.     // PA 8 to output
  32.     setbit(GPIOA->MODER, 16);
  33.     clrbit(GPIOA->MODER, 17);
  34.  
  35.     // PA 9 to output
  36.     setbit(GPIOA->MODER, 18);
  37.     clrbit(GPIOA->MODER, 19);
  38.  
  39.     // PB 5 to output
  40.     setbit(GPIOB->MODER, 10);
  41.     clrbit(GPIOB->MODER, 11);
  42.  
  43.     // PB 6 to output
  44.     setbit(GPIOB->MODER, 12);
  45.     clrbit(GPIOB->MODER, 13);
  46. }
  47.  
  48. void initTIM2(void){
  49.     setbit(RCC->APB1ENR, 0);    /* enable Clock for TIM2 */
  50.     TIM2->PSC = 1;              /* prescaler - doplnte podle potreby */
  51.     TIM2->ARR = 3200000;        /* autoreload - doplnte podle potreby */
  52.     setbit(TIM2->CR1, 0);       /* enable TIM2 */
  53.     clrbit(TIM2->SR, 0);        /* status TIM2 */
  54. }
  55.  
  56. void initUART(void){
  57.  
  58.     setbit(RCC->AHB1ENR, 0);    // clock of port A
  59.     setbit(GPIOA->MODER, 5);    // PA2
  60.     setbit(GPIOA->MODER, 7);    // PA3
  61.  
  62.     setbit(RCC->APB1ENR, 17);    // UART clock
  63.     setbit(USART2->CR1, 13);     // USART interface
  64.     setbit(USART2->CR1, 2);      // UART receive
  65.     USART2->BRR =  (136 << 4) + 7; // speed 9600
  66.  
  67.     // alternate function register
  68.     setbit(GPIOA->AFR[0], 8);
  69.     setbit(GPIOA->AFR[0], 9);
  70.     setbit(GPIOA->AFR[0], 10);
  71.     setbit(GPIOA->AFR[0], 12);
  72.     setbit(GPIOA->AFR[0], 13);
  73.     setbit(GPIOA->AFR[0], 14);
  74. }
  75.  
  76. void write_to_segment(){
  77.     clrbit(GPIOB->ODR,5);   // PB5 - D4 (Latch)
  78.     for(int i=15; i > (-1); i--){
  79.         if(getbit(packet,i)==1){
  80.             setbit(GPIOA->ODR, 9);  // PA9 - D8 (Data)
  81.         }else{
  82.             clrbit(GPIOA->ODR,9);   // PA9 - D8 (Data)
  83.         }
  84.         setbit(GPIOA->ODR,8);   // PA8 - D7 (Clock)
  85.         clrbit(GPIOA->ODR,8);   // PA8 - D7 (Clock)
  86.     }
  87.     setbit(GPIOB->ODR,5);   // PB5 - D4 (Latch)
  88. }
  89.  
  90. void display_num3(int num){
  91.     switch (num){
  92.         case 0:
  93.             packet=0b1100000000001000;
  94.                 write_to_segment();
  95.             break;
  96.         case 1:
  97.             packet=0b1111100100001000;
  98.                 write_to_segment();
  99.             break;
  100.         case 2:
  101.             packet=0b1010010000001000;
  102.                 write_to_segment();
  103.             break;
  104.         case 3:
  105.             packet=0b1011000000001000;
  106.                 write_to_segment();
  107.             break;
  108.         case 4:
  109.             packet=0b1001100100001000;
  110.                 write_to_segment();
  111.             break;
  112.         case 5:
  113.             packet=0b1001001000001000;
  114.                 write_to_segment();
  115.             break;
  116.         case 6:
  117.             packet=0b1000001000001000;
  118.                 write_to_segment();
  119.             break;
  120.         case 7:
  121.             packet=0b1111100000001000;
  122.                 write_to_segment();
  123.             break;
  124.         case 8:
  125.             packet=0b1000000000001000;
  126.                 write_to_segment();
  127.             break;
  128.         case 9:
  129.             packet=0b1001000000001000;
  130.                 write_to_segment();
  131.             break;
  132.         default:
  133.             packet=0b1011111100001000;
  134.                 write_to_segment();
  135.             break;
  136.     }
  137. }
  138.  
  139. void display_num2(int num){
  140.     switch (num){
  141.             case 0:
  142.                 packet=0b1100000000000100;
  143.                     write_to_segment();
  144.                 break;
  145.             case 1:
  146.                 packet=0b1111100100000100;
  147.                     write_to_segment();
  148.                 break;
  149.             case 2:
  150.                 packet=0b1010010000000100;
  151.                     write_to_segment();
  152.                 break;
  153.             case 3:
  154.                 packet=0b1011000000000100;
  155.                     write_to_segment();
  156.                 break;
  157.             case 4:
  158.                 packet=0b1001100100000100;
  159.                     write_to_segment();
  160.                 break;
  161.             case 5:
  162.                 packet=0b1001001000000100;
  163.                     write_to_segment();
  164.                 break;
  165.             case 6:
  166.                 packet=0b1000001000000100;
  167.                     write_to_segment();
  168.                 break;
  169.             case 7:
  170.                 packet=0b1111100000000100;
  171.                     write_to_segment();
  172.                 break;
  173.             case 8:
  174.                 packet=0b1000000000000100;
  175.                     write_to_segment();
  176.                 break;
  177.             case 9:
  178.                 packet=0b1001000000000100;
  179.                     write_to_segment();
  180.                 break;
  181.             default:
  182.                 packet=0b1011111100000100;
  183.                     write_to_segment();
  184.                 break;
  185.         }
  186. }
  187.  
  188. void display_num1(int num){
  189.     switch (num){
  190.             case 0:
  191.                 packet=0b1100000000000010;
  192.                     write_to_segment();
  193.                 break;
  194.             case 1:
  195.                 packet=0b1111100100000010;
  196.                     write_to_segment();
  197.                 break;
  198.             case 2:
  199.                 packet=0b1010010000000010;
  200.                     write_to_segment();
  201.                 break;
  202.             case 3:
  203.                 packet=0b1011000000000010;
  204.                     write_to_segment();
  205.                 break;
  206.             case 4:
  207.                 packet=0b1001100100000010;
  208.                     write_to_segment();
  209.                 break;
  210.             case 5:
  211.                 packet=0b1001001000000010;
  212.                     write_to_segment();
  213.                 break;
  214.             case 6:
  215.                 packet=0b1000001000000010;
  216.                     write_to_segment();
  217.                 break;
  218.             case 7:
  219.                 packet=0b1111100000000010;
  220.                     write_to_segment();
  221.                 break;
  222.             case 8:
  223.                 packet=0b1000000000000010;
  224.                     write_to_segment();
  225.                 break;
  226.             case 9:
  227.                 packet=0b1001000000000010;
  228.                     write_to_segment();
  229.                 break;
  230.             default:
  231.                 packet=0b1011111100000010;
  232.                     write_to_segment();
  233.                 break;
  234.         }
  235. }
  236.  
  237. void display_num0(int num){
  238.     switch (num){
  239.             case 0:
  240.                 packet=0b1100000000000001;
  241.                     write_to_segment();
  242.                 break;
  243.             case 1:
  244.                 packet=0b1111100100000001;
  245.                     write_to_segment();
  246.                 break;
  247.             case 2:
  248.                 packet=0b1010010000000001;
  249.                     write_to_segment();
  250.                 break;
  251.             case 3:
  252.                 packet=0b1011000000000001;
  253.                     write_to_segment();
  254.                 break;
  255.             case 4:
  256.                 packet=0b1001100100000001;
  257.                     write_to_segment();
  258.                 break;
  259.             case 5:
  260.                 packet=0b1001001000000001;
  261.                     write_to_segment();
  262.                 break;
  263.             case 6:
  264.                 packet=0b1000001000000001;
  265.                     write_to_segment();
  266.                 break;
  267.             case 7:
  268.                 packet=0b1111100000000001;
  269.                     write_to_segment();
  270.                 break;
  271.             case 8:
  272.                 packet=0b1000000000000001;
  273.                     write_to_segment();
  274.                 break;
  275.             case 9:
  276.                 packet=0b1001000000000001;
  277.                     write_to_segment();
  278.                 break;
  279.             default:
  280.                 packet=0b1011111100000001;
  281.                     write_to_segment();
  282.                 break;
  283.         }
  284. }
  285.  
  286. void display_num(int num, int position){
  287.     // transfer char to int -> -48
  288.     switch(position){
  289.         case 3: display_num3(num - 48); break;
  290.         case 2: display_num2(num - 48); break;
  291.         case 1: display_num1(num - 48); break;
  292.         case 0: display_num0(num - 48); break;
  293.         default: break;
  294.     }
  295. }
  296.  
  297.  
  298. void read_buffer() {
  299.     do {
  300.         if (readbit(USART2->SR,5)) {
  301.             bytes++;
  302.             buffer = USART2->DR;
  303.         }
  304.         if (buffer == 13) {
  305.             to_display[4]= buffer;
  306.         } else {
  307.             to_display[bytes-1]=buffer;
  308.         }
  309.     } while (buffer != 13);
  310. }
  311.  
  312. int main(void) {
  313.     initDisp();
  314.     initTIM2();
  315.     initUART();
  316.  
  317.     while(1) {
  318.         bytes = 0;
  319.         read_buffer();
  320.         switch(bytes){
  321.             case 2:
  322.                 do {
  323.                     display_num(to_display[0],3);
  324.                 } while (!readbit(USART2->SR,5));
  325.                 break;
  326.             case 3:
  327.                 do {
  328.                     display_num(to_display[0],2);
  329.                     display_num(to_display[1],3);
  330.                 } while (!readbit(USART2->SR,5));
  331.                 break;
  332.             case 4:
  333.                 do {
  334.                     display_num(to_display[0],1);
  335.                     display_num(to_display[1],2);
  336.                     display_num(to_display[2],3);
  337.                 } while (!readbit(USART2->SR,5));
  338.                 break;
  339.             case 5:
  340.                 do{
  341.                     display_num(to_display[0],0);
  342.                     display_num(to_display[1],1);
  343.                     display_num(to_display[2],2);
  344.                     display_num(to_display[3],3);
  345.                 }while (!readbit(USART2->SR,5)); break;
  346.             default:
  347.                 do{
  348.                     display_num(-1,0);
  349.                     display_num(-1,1);
  350.                     display_num(-1,2);
  351.                     display_num(-1,3);
  352.                 } while (!readbit(USART2->SR,5)); break;
  353.         }
  354.     }
  355. }
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!