[21] STM32F4 - Generacja liczb pseudolosowych

Ten post chciałbym poświecić na opisanie sprzętowego bloku pozwalającego na generowanie 32 bitowych liczb pseudolosowych.

Opis bloku [1]:

Ta część będzie poświęcona na opis bloku RNG. Generator liczb pseudolosowych, który jest oparty o część analogową, jest wykorzystywany w większości mikrokontrolerów z rodziny STM32F2, F4, F7, L0 oraz L4.

Jak już wspomniałem generator jest oparty o obwód analogowy, który generuje ciągły szum. Jest on wytwarzany do przygotowania 32 bitowych próbek. Część analogowa jest przygotowana z kilku oscylatorotów z wyjściamu XOR. Taktowanie odbywa się poprzez linię AHB1.

Programowanie:

W pierwszej kolejności należy włączyć sygnał zegarowy:

1. RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE);
2. //lub na rejestrach
3. RCC->AHB2ENR |= RCC_AHB2ENR_RNGEN; //((uint32_t)0x00000040)
4. __DSB();

Włączenie modułu odbywa się za pomocą funkcji RNG_Cmd(), która wygląda następująco:

1. void RNG_Cmd(FunctionalState NewState)
2. {
3.   //Sprawdzenie parametrow
4.   assert_param(IS_FUNCTIONAL_STATE(NewState));
6.   if (NewState != DISABLE)
7.   {
8.     //Wlaczenie RNG
9.     RNG->CR |= RNG_CR_RNGEN;
10.   }
11.   else
12.   {
13.     //Wylaczenie RNG
14.     RNG->CR &= ~RNG_CR_RNGEN;
15.   }
16. }

Włączenie odbywa się poprzez wprowadzenie instrukcji RNG_Cmd(ENABLE) wyłączenie natomiast poprzez RNG_Cmd(DISABLE). Funkcja ustawia w rejestrze kontrolnym RNG bity odpowiedzialne za włączenie układu (dokładnie podaje wartość 0x00000004).

Pobranie wartości odbywa się przy użyciu funkcji RNG_GetRandomNumber();

1. uint32_t RNG_GetRandomNumber(void)
2. {
3.   return RNG->DR;
4. }

Zwraca ona 32 bitową wartość wyprowadzoną z rejestru DR.

Poniżej przedstawię krótki program który będzie wykonywał dwie operacje, jedną z nich będzie przesłanie danych poprzez UART do komputera, druga będzie miała za zadanie mruganie diodami wbudowanymi na płytkę discovery w zależności od otrzymanej wartości.

1. #include "stm32f4xx.h"
2. #include "stm32f4xx_rcc.h"
3. #include "stm32f4xx_usart.h"
4. #include "stdio.h"
5. #include "misc.h"
7. struct __FILE {
8.     int parametr;
9. };
11. FILE __stdout;
12. void send_char(char);
13. void USART_Initialize(void);
14. void GPIO_Initialize(void);
15. void USART_Send(volatile char *s);
16. int PutFile(int ch, FILE *f);
17. void Send_Charc(volatile char c);
19. volatile uint16_t delay_count = 0;
21. uint8_t SYSTICK_ON()
22. {
23.    if (SysTick_Config(SystemCoreClock / 1000))
24.    {   while (1);  }
25. }
27. void delay_ms(uint16_t delay_temp)
28. {
29.     delay_count = delay_temp;
30.     while(delay_count) { }
31. }
33. int main()
34. {
35.     uint32_t RNG_Random = 0;
36.    
37.     SystemInit();
38.     LedInit();
39.     GPIO_Initialize();
40.     USART_Initialize();
41.     SystemCoreClockUpdate();
42.     SYSTICK_ON();
43.    
44.     RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE); //Wlaczenie zegara dla RNG
45.     RNG_Cmd(ENABLE);
47.     while(1)
48.     {
49.         RNG_Random = RNG_GetRandomNumber();
50.        
51.         printf("Wartosc: %zu \n", RNG_Random);
52.        
53.         GPIOD->BSRRH = GPIO_Pin_12;
54.         GPIOD->BSRRH = GPIO_Pin_13;
55.         GPIOD->BSRRH = GPIO_Pin_14;
56.         GPIOD->BSRRH = GPIO_Pin_15;
57.        
58.         if(RNG_Random < (0xFFFFFFFF >> 4))
59.         {
60.                 GPIOD->BSRRL = GPIO_Pin_12;
61.         }
62.         else if(RNG_Random < (0xFFFFFFFF >> 4)*2)
63.         {
64.                 GPIOD->BSRRL = GPIO_Pin_13;
66.         }
67.         else if(RNG_Random < (0xFFFFFFFF >> 4)*3)
68.         {
69.                 GPIOD->BSRRL = GPIO_Pin_14;
70.         }
71.         else
72.         {
73.                 GPIOD->BSRRL = GPIO_Pin_15;
74.         }
75.         delay_ms(200);
76.     }
77. }
79. void USART_Initialize(void)
80. {
81.      NVIC_InitTypeDef NVIC_InitStruct;
82.    
83.      USART_InitTypeDef USART_InitStructure;
84.      
85.      NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
86.    
87.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
88.      
89.      USART_InitStructure.USART_BaudRate = 9600;
90.      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
91.      USART_InitStructure.USART_StopBits = USART_StopBits_1;
92.      USART_InitStructure.USART_Parity = USART_Parity_No;
93.      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
94.      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
95.      
96.      USART_Init(USART1, &USART_InitStructure);
97.      USART_Cmd(USART1, ENABLE);
98.      
99.      USART1->CR1 |= USART_CR1_RXNEIE;
100.    
101.      NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
102.      NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
103.      NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
104.      NVIC_Init(&NVIC_InitStruct);
105. }
106. void GPIO_Initialize(void)
107. {
108.      GPIO_InitTypeDef  GPIO_In;
109.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
110.      
111.      //TX dla pinu PB6
112.      GPIO_In.GPIO_Pin = GPIO_Pin_6;
113.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
114.      GPIO_In.GPIO_OType = GPIO_OType_PP;
115.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
116.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
117.      GPIO_Init(GPIOB, &GPIO_In);
118.      
119.      //RX dla pinu PB7
120.      GPIO_In.GPIO_Pin = GPIO_Pin_7;
121.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
122.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
123.      GPIO_In.GPIO_OType = GPIO_OType_PP;
124.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
125.      GPIO_Init(GPIOB, &GPIO_In);
127.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);
128.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);
129. }
130. void USART_Send(volatile char *c)
131. {
132.      while(*c)
133.      {
134.         while( !(USART1->SR & 0x00000040) );
135.         USART_SendData(USART1, *c);
136.         *c++;
137.      }
138. }
140. int fputc(int ch, FILE *f)
141. {
142.     volatile char c = ch;
143.    
144.         USART1->DR = (uint16_t)(c & 0x01FF);
145.       while (!((USART1)->SR & USART_FLAG_TXE))
146.         {}
147.        
148.     return ch;
149. }
150. void Send_Charc(volatile char c)
151. {
152.  while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
153.  USART_SendData(USART1, c);
154. }
156. void SysTick_Handler(void)
157. {
158.     if(delay_count > 0)
159.     {
160.         delay_count--;
161.     }
162. }

Bibliografia:

[1] STM32 - RNG - DM00073853