SHARE
TWEET

Untitled

a guest Feb 18th, 2020 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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****/
RAW Paste Data
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
Top