Advertisement
Guest User

Untitled

a guest
Feb 18th, 2020
134
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.86 KB | None | 0 0
  1. /* USER CODE BEGIN Header */
  2. /**
  3. ******************************************************************************
  4. * @file : main.c
  5. * @brief : Main program body
  6. ******************************************************************************
  7. ** This notice applies to any and all portions of this file
  8. * that are not between comment pairs USER CODE BEGIN and
  9. * USER CODE END. Other portions of this file, whether
  10. * inserted by the user or by software development tools
  11. * are owned by their respective copyright owners.
  12. *
  13. * COPYRIGHT(c) 2020 STMicroelectronics
  14. *
  15. * Redistribution and use in source and binary forms, with or without modification,
  16. * are permitted provided that the following conditions are met:
  17. * 1. Redistributions of source code must retain the above copyright notice,
  18. * this list of conditions and the following disclaimer.
  19. * 2. Redistributions in binary form must reproduce the above copyright notice,
  20. * this list of conditions and the following disclaimer in the documentation
  21. * and/or other materials provided with the distribution.
  22. * 3. Neither the name of STMicroelectronics nor the names of its contributors
  23. * may be used to endorse or promote products derived from this software
  24. * without specific prior written permission.
  25. *
  26. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  27. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  29. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  30. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  32. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  33. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  34. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36. *
  37. ******************************************************************************
  38. */
  39. /* USER CODE END Header */
  40.  
  41. /* Includes ------------------------------------------------------------------*/
  42. #include "main.h"
  43.  
  44. /* Private includes ----------------------------------------------------------*/
  45. /* USER CODE BEGIN Includes */
  46. #include "string.h"
  47. #include "stdarg.h"
  48.  
  49. #define FRAME_STARTSTOP 0x30 //znak początku i końca ramki "zero" 0
  50. #define UNIK_PZU 0x2D //myślnik, Pierwszy Znak Ucieczki "minus" -
  51. #define UNIK_DZU 0x2E //kropka, Drugi Znak Ucieczki "kropka" .
  52. #define UNIKANIE_UNIKU 0x2F //aby móc wpisac w ramce myślnik /. to - "slash" /
  53. #define CONTINUUE 10
  54. #define UNIK1 20
  55. #define UNIK2 30
  56. #define INFORMATION_MESSAGE 40
  57. #define FRAME_RECEIVED 50
  58. #define BUFF_SIZE 256 //zdefiniowanie rozmiaru bufora
  59. #define COMMAND_SIZE 128 //zdefiniowanie rozmiaru komendy
  60.  
  61. /* USER CODE END Includes */
  62.  
  63. /* Private typedef -----------------------------------------------------------*/
  64. /* USER CODE BEGIN PTD */
  65. uint8_t frame_state = CONTINUUE;
  66. int idx;
  67.  
  68. char Buff_Rx[BUFF_SIZE]; //zdefiniowanie rozmiaru bufora odbiorczego (256)
  69. char Buff_Tx[BUFF_SIZE]; //zdefiniowanie rozmiaru bufora nadawczego (256)
  70.  
  71. volatile uint8_t Busy_Tx = 0;//deklaracja wskaźnika na bufory 0 (zmienna ulotna)
  72. volatile uint8_t Empty_Tx = 0; //deklaracja wskaźnika na bufory 0
  73. volatile uint8_t Busy_Rx = 0; //deklaracja wskaźnika na bufory 0
  74. volatile uint8_t Empty_Rx = 0; //deklaracja wskaźnika na bufory 0
  75.  
  76. uint8_t pir_state = 0; //zdefiniowanie stanu czujki na 0
  77. uint8_t previous_pir_state = 0; //zdefiniowanie poprzedniego stanu czujki na 0
  78. uint8_t alarm_armed = 0; //zdefiniowanie uzbrojenia alarmu na 0
  79. uint8_t ap, p; //zdefiniowanie zmiennych potrzebnych do alarmu
  80. uint8_t bajty_idle = 0; //zdefiniowanie bufora ramki na 0
  81. char frame[128]; //zdefiniowanie rozmiaru ramki
  82. char command[COMMAND_SIZE]; //zdefiniowanie rozmiaru komendy command=128
  83.  
  84. /* USER CODE END PTD */
  85.  
  86. /* Private define ------------------------------------------------------------*/
  87. /* USER CODE BEGIN PD */
  88.  
  89. /* USER CODE END PD */
  90.  
  91. /* Private macro -------------------------------------------------------------*/
  92. /* USER CODE BEGIN PM */
  93.  
  94. /* USER CODE END PM */
  95.  
  96. /* Private variables ---------------------------------------------------------*/
  97. TIM_HandleTypeDef htim4;
  98.  
  99. UART_HandleTypeDef huart2;
  100.  
  101. /* USER CODE BEGIN PV */
  102.  
  103. /* USER CODE END PV */
  104.  
  105. /* Private function prototypes -----------------------------------------------*/
  106. void SystemClock_Config(void);
  107. static void MX_GPIO_Init(void);
  108. static void MX_USART2_UART_Init(void);
  109. static void MX_TIM4_Init(void);
  110. /* USER CODE BEGIN PFP */
  111.  
  112. /* USER CODE END PFP */
  113.  
  114. /* Private user code ---------------------------------------------------------*/
  115. /* USER CODE BEGIN 0 */
  116. void USART_fsend(char* format, ...) {
  117.  
  118. char tmp_rs[128]; //zmiena tymczasowa tmp_rs
  119. int i;
  120. __IO int idx; // __IO to zmienna typu volatile, indeks naszej tablicy
  121. va_list valist; //tworzymy liste ze zmienna iloscia argumentu
  122. va_start(valist, format);//inicjalizuje valist, aby pobrac dodatkowe argumenty po parametrze
  123. vsprintf(tmp_rs, format, valist); //do zmiennej tmp_rs jest zapisywany sformatowany juz ciag znaków
  124. va_end(valist); //zakonczenie listy ze zmienna iloscia argumentow
  125. idx = Empty_Tx; //naszemu indeksowi przypisujemy wskaznik na puste miejsce w buforze nadawczym
  126. for (i = 0; i < strlen(tmp_rs); i++) { //wypelniamy bufor nadawczy znakami
  127. Buff_Tx[idx] = tmp_rs[i];
  128. idx++;
  129. if (idx >= BUFF_SIZE)//jezeli przekroczymy rozmiar bufora, to zerujemy index
  130. idx = 0;
  131. }
  132. __disable_irq(); //wylaczamy przerwania
  133.  
  134. if ((Empty_Tx == Busy_Tx)
  135. && (__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TXE) == SET))
  136. //jezeli wskazniki na puste i zajete miejsce w buforze sa takie same oraz UART nic nie nadaje oraz UART nic nie nadaje
  137. { //to rozpoczynamy wysylanie
  138. Empty_Tx = idx; //przypisujemy wskazniki pustego miejsca nasz indeks
  139. uint8_t tmp = Buff_Tx[Busy_Tx]; //zmiennej tymczasowej przypisujemy element z bufora nadawczego
  140. Busy_Tx++; //zwiekszamy wskaznik miejsca zajetego w buforze
  141. if (Busy_Tx >= BUFF_SIZE)//jezeli przekroczymy zakres bufora to... zerujemy wskaznik
  142. Busy_Tx = 0;
  143. HAL_UART_Transmit_IT(&huart2, &tmp, 1); //transmitujemy pierwszy bajt danych
  144. //po przeslaniu tego bajtu zostanie wywolaane przerwanie z callbacku
  145. } else {
  146. Empty_Tx = idx; //wskaznikowi pustego miejsca przypisujemy nasz indeks
  147. }
  148. __enable_irq(); //wlaczamy przerwania
  149. }
  150.  
  151. char getchar_BuffRx() //pobierz znak z bufora
  152. {
  153. char tmp;
  154. if (Busy_Rx != Empty_Rx)//jeżeli miejsce zajęte bufora odczytu jest różne od pustego miejsca buforu odczytu
  155. {
  156. tmp = Buff_Rx[Busy_Rx]; //pod tymczasową zmiennę, do bufora odczytu wpisz zajęte miejsce bufora odczytu
  157. Busy_Rx++; //zwiększ wskaźnik
  158. if (Busy_Rx > BUFF_SIZE)
  159. Busy_Rx = 0;//jeżeli zajęte miejsce jest większe niż rozmiar bufora, to przejdź do elementu "0" w tym buforze (zatocz koło)
  160. return tmp;
  161. }
  162. return -1;
  163. }
  164.  
  165. void DoCommand(char *comm) //funkcja, która wykonuje polecenie z ramki
  166. {
  167. if (strncmp(comm, "alarm", 5) == 0) {
  168. ap = sscanf(comm, "alarm:%d", &p);//wyszukaj po usarcie kombinacji alarm: tj. 0alarm:costam0
  169. if (ap == 1) //jeżeli wpisano kombinację alarm:
  170. {
  171. alarm_armed = p; //uzbrajamy alarm
  172. USART_fsend("OK, działamy! \n\r");//wysyłamy komunikat, że alarm został uzbrojony
  173. } else {
  174. USART_fsend("Brak wszystkich potrzebnych parametrów! :-( \n\r"); //alarm nie został uzbrojony
  175. }
  176. }
  177. }
  178.  
  179. void clear_data() {
  180. for (int i = 0; i < COMMAND_SIZE; i++)
  181. command[i] = 0;
  182. idx = 0;
  183. }
  184.  
  185. void framee() {
  186. if (Busy_Rx != Empty_Rx) {//jeżeli miejsce zajęte odczytu jest różne od pustego
  187. char a = getchar_BuffRx(); //ZNAK Z BUFORA
  188. __HAL_TIM_SET_COUNTER(&htim4, 0); //nasłuch na linii dzięki Timer 4.
  189. switch (frame_state) //ODCZYT DANYCH
  190. {
  191. case CONTINUUE: {
  192. if (a == FRAME_STARTSTOP) { //a jest znakiem początka ramki - "zero" 0
  193. clear_data(); //wyczyśc dane
  194. frame_state = INFORMATION_MESSAGE;//stan ramki na tryb przesył wiadomości (opcja jednego z case)
  195. }
  196. break;
  197. }
  198.  
  199. case INFORMATION_MESSAGE: {
  200. if (a == FRAME_STARTSTOP) { //znak przesłany z bufora odbiorczego to znak początku i końca ramki
  201. DoCommand(command); //command wykonuje polecenie z ramki
  202. clear_data(); //wyczysc dane
  203. frame_state = INFORMATION_MESSAGE;///stan ramki na tryb przesył wiadomości (opcja jednego z case)
  204. } else if (a == UNIK_PZU)//jeżeli znak to pierwszy znak uniku to...
  205. frame_state = UNIK2;//status ramki będzie interpretowany w case UNIK2 który jest niżej żeby sprawdzic czy bedzie drugi znak uniku
  206. //zwiększenie wskaźnika //zawiesi sie
  207. }
  208. break;
  209. }
  210.  
  211. case UNIK2:
  212. {
  213. if (a == UNIK_DZU) { //jeżeli odebrany znak to drugi znak uniku
  214. command[idx] = FRAME_STARTSTOP; //to nasza ramka się nie wysypie i mmożemy korzystac w środku treści ramki z "zera"
  215. ///////
  216. if (idx >= 30) {
  217. frame_state = CONTINUUE;
  218. USART_fsend = "nieprawidłowe dane";
  219. break;
  220. } else {
  221. command[idx] = a;
  222. if (idx >= 30) {
  223. frame_state = CONTINUUE;
  224. USART_fsend = "nieprawidłowe dane";
  225. break;
  226. } else {
  227. idx++;
  228. }
  229.  
  230. }
  231. break;
  232. } else if (a == UNIKANIE_UNIKU) { //aby moc w ramce wpisac "myślnik" -
  233. command[idx] = UNIK_PZU;//slash z myślnikiem jest po to, aby moc wpisac do ramki myślnik
  234. if (idx >= 30) {
  235. frame_state = CONTINUUE;
  236. USART_fsend = "nieprawidłowe dane";
  237. break;
  238. } else {
  239. idx++;
  240. }
  241.  
  242. } else {
  243. frame_state = CONTINUUE;
  244. USART_fsend("nieprawidłowe dane");
  245. break;
  246. }
  247.  
  248. frame_state = INFORMATION_MESSAGE; //znak jest znakiem ramki
  249. break;
  250. }
  251. }
  252. }
  253. }
  254. uint8_t pir_move() { //ustawienie PINu dla czujki ruchu
  255. if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5) == GPIO_PIN_SET)
  256. return 1;
  257. else
  258. return 0;
  259. }
  260.  
  261. uint8_t pir_move_detected() {
  262. previous_pir_state = pir_state; //na początku oba są zerami (zadeklarowane w #include)
  263. pir_state = pir_move(); //stan ruchu pobierz z funkcji pirmove
  264. if (previous_pir_state == 0 && pir_state == 1) //jeżeli wykryto ruch (stan wysoki w obecnym pir_state)
  265. return 1;
  266. else
  267. return 0;
  268. }
  269. /* USER CODE END 0 */
  270.  
  271. /**
  272. * @brief The application entry point.
  273. * @retval int
  274. */
  275. int main(void) {
  276. /* USER CODE BEGIN 1 */
  277.  
  278. /* USER CODE END 1 */
  279.  
  280. /* MCU Configuration--------------------------------------------------------*/
  281.  
  282. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  283. HAL_Init();
  284.  
  285. /* USER CODE BEGIN Init */
  286.  
  287. /* USER CODE END Init */
  288.  
  289. /* Configure the system clock */
  290. SystemClock_Config();
  291.  
  292. /* USER CODE BEGIN SysInit */
  293.  
  294. /* USER CODE END SysInit */
  295.  
  296. /* Initialize all configured peripherals */
  297. MX_GPIO_Init();
  298. MX_USART2_UART_Init();
  299. MX_TIM4_Init();
  300. /* USER CODE BEGIN 2 */
  301. HAL_UART_Receive_IT(&huart2, (uint8_t *) &Buff_Rx[Empty_Rx], 1);
  302. USART_fsend("Halo to ja, Twój STM32! :-)\n\r"); //komunikat powitalny po USARTcie
  303. /* USER CODE END 2 */
  304.  
  305. /* Infinite loop */
  306. /* USER CODE BEGIN WHILE */
  307. while (1) {
  308. /* USER CODE END WHILE */
  309. framee(); //funkcja z ramką
  310. if (pir_move_detected()) //jeżeli wykryto ruch (który sprawdza funkcja pir_move_detected)
  311. {
  312. if (alarm_armed) //jeżeli alarm jest uzbrojony
  313. {
  314. USART_fsend("I see you, sioooooooo :-) \n\r"); //wypisz po USART
  315. }
  316. }
  317. /* USER CODE BEGIN 3 */
  318. }
  319. /* USER CODE END 3 */
  320. }
  321.  
  322. /**
  323. * @brief System Clock Configuration
  324. * @retval None
  325. */
  326. void SystemClock_Config(void) {
  327. RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
  328. RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
  329. RCC_PeriphCLKInitTypeDef PeriphClkInit = { 0 };
  330.  
  331. /**Initializes the CPU, AHB and APB busses clocks
  332. */
  333. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  334. RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  335. RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  336. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  337. RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  338. RCC_OscInitStruct.PLL.PLLM = 1;
  339. RCC_OscInitStruct.PLL.PLLN = 10;
  340. RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  341. RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  342. RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  343. if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
  344. Error_Handler();
  345. }
  346. /**Initializes the CPU, AHB and APB busses clocks
  347. */
  348. RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
  349. | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  350. RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  351. RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  352. RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  353. RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  354.  
  355. if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) {
  356. Error_Handler();
  357. }
  358. PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
  359. PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
  360. if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) {
  361. Error_Handler();
  362. }
  363. /**Configure the main internal regulator output voltage
  364. */
  365. if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK) {
  366. Error_Handler();
  367. }
  368. }
  369.  
  370. /**
  371. * @brief TIM4 Initialization Function
  372. * @param None
  373. * @retval None
  374. */
  375. static void MX_TIM4_Init(void) {
  376.  
  377. /* USER CODE BEGIN TIM4_Init 0 */
  378.  
  379. /* USER CODE END TIM4_Init 0 */
  380.  
  381. TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
  382. TIM_MasterConfigTypeDef sMasterConfig = { 0 };
  383.  
  384. /* USER CODE BEGIN TIM4_Init 1 */
  385.  
  386. /* USER CODE END TIM4_Init 1 */
  387. htim4.Instance = TIM4;
  388. htim4.Init.Prescaler = 31;
  389. htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  390. htim4.Init.Period = 103;
  391. htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  392. htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  393. if (HAL_TIM_Base_Init(&htim4) != HAL_OK) {
  394. Error_Handler();
  395. }
  396. sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  397. if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK) {
  398. Error_Handler();
  399. }
  400. sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  401. sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  402. if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK) {
  403. Error_Handler();
  404. }
  405. /* USER CODE BEGIN TIM4_Init 2 */
  406.  
  407. /* USER CODE END TIM4_Init 2 */
  408.  
  409. }
  410.  
  411. /**
  412. * @brief USART2 Initialization Function
  413. * @param None
  414. * @retval None
  415. */
  416. static void MX_USART2_UART_Init(void) {
  417.  
  418. /* USER CODE BEGIN USART2_Init 0 */
  419.  
  420. /* USER CODE END USART2_Init 0 */
  421.  
  422. /* USER CODE BEGIN USART2_Init 1 */
  423.  
  424. /* USER CODE END USART2_Init 1 */
  425. huart2.Instance = USART2;
  426. huart2.Init.BaudRate = 9600;
  427. huart2.Init.WordLength = UART_WORDLENGTH_8B;
  428. huart2.Init.StopBits = UART_STOPBITS_1;
  429. huart2.Init.Parity = UART_PARITY_NONE;
  430. huart2.Init.Mode = UART_MODE_TX_RX;
  431. huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  432. huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  433. huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  434. huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  435. if (HAL_UART_Init(&huart2) != HAL_OK) {
  436. Error_Handler();
  437. }
  438. /* USER CODE BEGIN USART2_Init 2 */
  439.  
  440. /* USER CODE END USART2_Init 2 */
  441.  
  442. }
  443.  
  444. /**
  445. * @brief GPIO Initialization Function
  446. * @param None
  447. * @retval None
  448. */
  449. static void MX_GPIO_Init(void) {
  450. GPIO_InitTypeDef GPIO_InitStruct = { 0 };
  451.  
  452. /* GPIO Ports Clock Enable */
  453. __HAL_RCC_GPIOC_CLK_ENABLE()
  454. ;
  455. __HAL_RCC_GPIOH_CLK_ENABLE()
  456. ;
  457. __HAL_RCC_GPIOA_CLK_ENABLE()
  458. ;
  459. __HAL_RCC_GPIOB_CLK_ENABLE()
  460. ;
  461.  
  462. /*Configure GPIO pin : B1_Pin */
  463. GPIO_InitStruct.Pin = B1_Pin;
  464. GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  465. GPIO_InitStruct.Pull = GPIO_NOPULL;
  466. HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);
  467.  
  468. /*Configure GPIO pin : PA5 */
  469. GPIO_InitStruct.Pin = GPIO_PIN_5;
  470. GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  471. GPIO_InitStruct.Pull = GPIO_NOPULL;
  472. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  473.  
  474. }
  475.  
  476. /* USER CODE BEGIN 4 */
  477. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
  478. if (huart == &huart2) //sprawdzenie, czy funkcja była wywołana przez interfejs USART2
  479. {
  480. Empty_Rx++; //zwiększenie wskaźnika na miejsce puste w buforze
  481. if (Empty_Rx >= BUFF_SIZE) //jeżeli wskaźnik przekroczył rozmiar bufora
  482. Empty_Rx = 0; //wróc do początku (zatocz koło)
  483. HAL_UART_Receive_IT(&huart2, (uint8_t *) &Buff_Rx[Empty_Rx], 1);
  484. } //oczekuj na odbiór jednego kolejnego znaku na przerwaniu z interfejsu USART2
  485. } //do pustego miejsca w buforze odbiorczym
  486.  
  487. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
  488. if (huart == &huart2) //sprawdzenie, czy funkcja była wywołana przez interfejs USART2
  489. {
  490. if (Empty_Tx != Busy_Tx) {//jeżeli wskaźnik miejsca zajętego i miejsca pustego w buforze nadawczym się różnią (bufor nie jest pusty)
  491. uint8_t tmp = Buff_Tx[Busy_Tx]; //przypisanie do tymczasowej zmiennej tmp znaku znajdującego się w ostatnim zajętym miejscuw buforze nadawczym
  492. Busy_Tx++; //zwiększenie wskaźnika na zajęte miejsce w buforze nadawczym
  493. if (Busy_Tx >= BUFF_SIZE) //jeżeli wskaźnik przekroczył rozmiar bufora, wróc do początku (zatocz koło)
  494. Busy_Tx = 0;
  495. HAL_UART_Transmit_IT(&huart2, &tmp, 1); //prześlij na przerwaniu jeden znak znajdujący się w zmiennej tmp (traktuj tą zmienną jak jednoelementowy bufor)
  496. }
  497. }
  498. }
  499. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
  500. if (htim == &htim4) {
  501. if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE)
  502. == SET&& frame_state == INFORMATION_MESSAGE) //
  503. {
  504. bajty_idle++;
  505. if (bajty_idle >= 3) //jeśli nic nie jest nadawane na linii przez 3 sekundy, to czyścimy bufor ramki do czasu wystąpienia ciszy (nie bufor odbiorczy)
  506. { //o ile nie nie nastąpił znak końca ramki.
  507. bajty_idle = 0;
  508. frame_state = CONTINUUE;
  509. }
  510. }
  511. }
  512.  
  513. }
  514. /* USER CODE END 4 */
  515.  
  516. /**
  517. * @brief This function is executed in case of error occurrence.
  518. * @retval None
  519. */
  520. void Error_Handler(void) {
  521. /* USER CODE BEGIN Error_Handler_Debug */
  522. /* User can add his own implementation to report the HAL error return state */
  523.  
  524. /* USER CODE END Error_Handler_Debug */
  525. }
  526.  
  527. #ifdef USE_FULL_ASSERT
  528. /**
  529. * @brief Reports the name of the source file and the source line number
  530. * where the assert_param error has occurred.
  531. * @param file: pointer to the source file name
  532. * @param line: assert_param error line source number
  533. * @retval None
  534. */
  535. void assert_failed(char *file, uint32_t line)
  536. {
  537. /* USER CODE BEGIN 6 */
  538. /* User can add his own implementation to report the file name and line number,
  539. tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  540. /* USER CODE END 6 */
  541. }
  542. #endif /* USE_FULL_ASSERT */
  543.  
  544. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement