source: trunk/fw_g473rct/SES/src/main.c @ 38

Last change on this file since 38 was 25, checked in by f.jahn, 2 months ago

RTC implementiert
File size: 17.5 KB
RevLine 
[20]1/* USER CODE BEGIN Header */
2/**
3  ******************************************************************************
4  * @file           : main.c
5  * @brief          : Main program body
6  ******************************************************************************
7  * @attention
8  *
9  * Copyright (c) 2025 STMicroelectronics.
10  * All rights reserved.
11  *
12  * This software is licensed under terms that can be found in the LICENSE file
13  * in the root directory of this software component.
14  * If no LICENSE file comes with this software, it is provided AS-IS.
15  *
16  ******************************************************************************
17  */
18/* USER CODE END Header */
19/* Includes ------------------------------------------------------------------*/
20#include "main.h"
21#include "adc.h"
22#include "dma.h"
23#include "fdcan.h"
24#include "i2c.h"
25#include "spi.h"
26#include "usart.h"
27#include "usb.h"
28#include "gpio.h"
29
30/* Private includes ----------------------------------------------------------*/
31/* USER CODE BEGIN Includes */
32#include <stdio.h>
33#include "sysdata.h"
34#include "wh_counter.h"
35#include "ah_counter.h"
36#include "eeprom.h"
37#include "modbus.h"
38#include "chip_temperature.h"
[22]39#include "battery_voltage.h"
40#include "ads1260.h"
[24]41#include "shunt_voltage.h"
42#include "fast_current.h"
43#include "int_bat_voltage.h"
44#include "chip_temperature.h"
45#include "shunt_temperature.h"
[25]46#include "esr.h"
47#include "ads1260.h"
48#include "outputs.h"
49#include "crc.h"
[20]50/* USER CODE END Includes */
51
52/* Private typedef -----------------------------------------------------------*/
53/* USER CODE BEGIN PTD */
54
55/* USER CODE END PTD */
56
57/* Private define ------------------------------------------------------------*/
58/* USER CODE BEGIN PD */
59
60/* USER CODE END PD */
61
62/* Private macro -------------------------------------------------------------*/
63/* USER CODE BEGIN PM */
64
65/* USER CODE END PM */
66
67/* Private variables ---------------------------------------------------------*/
68
69/* USER CODE BEGIN PV */
[22]70modbus_t modbusData __attribute__((section(".RAM1")));
71
[24]72__IO uint16_t adc12Data[100][2] __attribute__((section(".RAM1")));
[20]73__IO uint32_t adc1Data[1] __attribute__((section(".RAM1")));
74__IO uint32_t adc2Data[1] __attribute__((section(".RAM1")));
75__IO uint32_t adc3Data[3] __attribute__((section(".RAM1")));
76__IO uint32_t adc4Data[1] __attribute__((section(".RAM1")));
77__IO uint32_t adc5Data[4] __attribute__((section(".RAM1")));
78int silentmode =0;
[24]79static volatile uint32_t newADC12Data = 0;
80static volatile uint32_t newADC3Data = 0;
81static volatile uint32_t newADC4Data = 0;
82static volatile uint32_t newADC5Data = 0;
[20]83/* USER CODE END PV */
84
85/* Private function prototypes -----------------------------------------------*/
86void SystemClock_Config(void);
87/* USER CODE BEGIN PFP */
[22]88bool SetFlashReadProtection(bool state);
89uint8_t printprotectionstate(void);
90bool SetBootFromFlashAndReadOutProtection(void);
[20]91/* USER CODE END PFP */
92
93/* Private user code ---------------------------------------------------------*/
94/* USER CODE BEGIN 0 */
95
96/* USER CODE END 0 */
97
98/**
99  * @brief  The application entry point.
100  * @retval int
101  */
102int main(void)
103{
104
105  /* USER CODE BEGIN 1 */
106    uint8_t firstStartCatcher;
[22]107        int mode_button_disable_time=0;
[24]108        uint32_t adc12_time;
109        uint32_t adc12_lasttime;
[20]110  /* USER CODE END 1 */
111
112  /* MCU Configuration--------------------------------------------------------*/
113
114  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
115  HAL_Init();
116
117  /* USER CODE BEGIN Init */
118
119  /* USER CODE END Init */
120
121  /* Configure the system clock */
122  SystemClock_Config();
123
124  /* USER CODE BEGIN SysInit */
125
126  /* USER CODE END SysInit */
127
128  /* Initialize all configured peripherals */
129  MX_GPIO_Init();
130  MX_DMA_Init();
131  MX_ADC1_Init();
132  MX_ADC2_Init();
133  MX_ADC3_Init();
134  MX_ADC4_Init();
135  MX_ADC5_Init();
136  MX_FDCAN2_Init();
137  MX_FDCAN3_Init();
138  MX_I2C3_Init();
139  MX_I2C4_Init();
140  MX_SPI3_Init();
141  MX_USART1_UART_Init();
142  MX_USART2_UART_Init();
143  MX_USB_PCD_Init();
144  /* USER CODE BEGIN 2 */
[25]145  MX_CRC_Init(); //Cube is not generating this call ?!
[20]146  printf("Test debug io\r\n");
147  SYS_DATA_Init();
148  WH_COUNTER_Init();
149  AH_COUNTER_Init();
150
151
152  startType_t startType = EEPROM_isFirstStart();
153
154  switch(startType)
155  {
156          case FIRST_START_AFTER_ERASE:                                 EEPROM_fullRestore(&sys_data);            break;
157          case FIRST_START_AFTER_COMPARTIBLE_UPDATE:    EEPROM_readConfig(&sys_data);             break;
158          case FIRST_START_AFTER_INCOMPARTIBLE_UPDATE:  EEPROM_factoryRestore(&sys_data, 0);  break;  // Preserving calibration and settings
159          case FIRST_START_ERROR:                                               EEPROM_fullRestore(&sys_data);            break;
160  }
161
162  if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
163  {
164    HAL_Delay(50);
165    if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
166    {
167      printf("factory restore...\n");
168      EEPROM_factoryRestore(&sys_data, 1);
169    }
170  }
171
172    // Modbus Initialisierung
173  mbInit(&modbusData, sys_data.s.parameter.baudrate, sys_data.s.parameter.parityMode, sys_data.s.parameter.stopBit, &huart2);
174
175    // STM32G0 Chiptemperatur Kalibrierung
[24]176  CHIP_TEMPERATURE_Calibration();
[20]177
178  HAL_ADCEx_Calibration_Start(&hadc1, ADC_DIFFERENTIAL_ENDED);
179  HAL_ADCEx_Calibration_Start(&hadc2, ADC_DIFFERENTIAL_ENDED);
180  HAL_ADCEx_Calibration_Start(&hadc3, ADC_SINGLE_ENDED);
181  HAL_ADCEx_Calibration_Start(&hadc4, ADC_DIFFERENTIAL_ENDED);
182  HAL_ADCEx_Calibration_Start(&hadc5, ADC_SINGLE_ENDED);
183
184
185  //SET_BIT(hadc2.Instance->CFGR, ADC_CFGR_DMAEN); //Enable DMA transfer for ADC slave (ADC12_CCR.MDMA = 0b00 -> MDMA mode disabled)
186  //HAL_DMA_Start(hadc2.DMA_Handle,(uint32_t)&hadc2.Instance->DR, (uint32_t)adc2Data,1); //Start ADC slave DMA
187  //SET_BIT(hadc1.Instance->CFGR, ADC_CFGR_DMAEN); //Enable DMA transfer for ADC master (ADC12_CCR.MDMA = 0b00 -> MDMA mode disabled)
188 
189    //HAL_ADC_Start_DMA(&hadc2, (uint32_t*)adc2Data, 1);
[24]190  if (HAL_ADCEx_MultiModeStart_DMA(&hadc1,(uint32_t *)adc12Data,100))  //Start ADC interleaved mode
[20]191  {
192     /* Start Error */
193     Error_Handler();
194  }
195
[24]196  if (HAL_ADC_Start_DMA(&hadc3, (uint32_t *) adc3Data , 3))
197  {
198     /* Start Error */
199     Error_Handler();
200  }
201
202  if (HAL_ADC_Start_DMA(&hadc4, (uint32_t *) adc4Data , 1))
203  {
204     /* Start Error */
205     Error_Handler();
206  }
207
208
[20]209  if (HAL_ADC_Start_DMA(&hadc5, (uint32_t *) adc5Data , 4))
210  {
211     /* Start Error */
212     Error_Handler();
213  }
214
[25]215
216  // ADS1260 Initialierung
217  ADS1260_init();
218  printf("ADS1260 Init\n");
219  OUTPUTS_Init();
220
[20]221  /* USER CODE END 2 */
222
223  /* Infinite loop */
224  /* USER CODE BEGIN WHILE */
225  while (1)
226  {
227    /* USER CODE END WHILE */
228
229    /* USER CODE BEGIN 3 */
[24]230        if (newADC12Data == 1)
[22]231    {
[24]232          //Mit ADC_DIV2,Sample time 12,5Cycklen, ADC Clock 50Mhz, Oversampling 256
233          //Tconv = 6400 Takte = 0,128ms Pro Konvertierung. Also für 100 messwerte 12,8mS
234          BATTERY_VOLTAGE_Exec( adc12Data[0][1]);
235          FAST_CURRENT_Exec(adc12Data[0][0]); 
236          newADC12Data = 0;
237          adc12_time = HAL_GetTick() - adc12_lasttime;
238          adc12_lasttime = HAL_GetTick();
239
[22]240        }
241
242
[24]243        if (newADC3Data == 1)
244    {
245          SHUNT_TEMPERATURE_Exec(adc3Data[0]);
246        }
247
248
249        if (newADC4Data == 1)
250    {
251          SHUNT_VOLTAGE_Exec( adc4Data[0]);
252        }
253
254
255        if (newADC5Data == 1)
256    {
257          CHIP_TEMPERATURE_Exec(adc5Data[0]);
258          INT_BAT_VOLTAGE_Exec( adc5Data[1]);
259          sys_data.s.values.ovp_sense =  (adc5Data[2] * VREF * 21 ) / 65536.0;
260      sys_data.s.values.lvp_sense =  (adc5Data[3] * VREF * 21 ) / 65536.0;
261        }
262
[25]263
264        if (newCurrentValue == 1)
265    {
266      ADS1260_ConversionFinished(); 
267      ESR_Exec();
268
269      newCurrentValue = 0;
270
271    }
272
[23]273        if(sys_data.s.parameter.command != 0)
[22]274    {
275      if  (modbusData.current_query ==  MB_QUERY_NOTHING)
276      {
277        //printf("CMD = %d\n", sys_data.s.parameter.command);
278        switch (sys_data.s.parameter.command )
279        {
280          case COMMAND_STORE_CONFIG:                          EEPROM_storeConfig(&sys_data,0);                                                                                    break;
281          case COMMAND_FULL_RESTORE:                          EEPROM_fullRestore(&sys_data);                                                                                      break;
282          case COMMAND_FACTORY_RESTORE:                       EEPROM_factoryRestore(&sys_data, 1);                                                                                break;
283          case COMMAND_RESTORE_LAST_SAVED_VALUES:             EEPROM_readConfig(&sys_data);                                                                                               break;
284          case COMMAND_STORE_WITH_SERIAL_NUMBER:              EEPROM_storeConfig(&sys_data,1);                                                                                    break;        // Seriennummer schreiben
285          case COMMAND_RESTART:                               NVIC_SystemReset();                                                                                                                 break;
286          case COMMAND_BATTERY_CURRENT_OFFSET_CAL:            ADS_1260_BatteryCurrentOffsetCalibrationStart(&sys_data);                                   break;
287          case COMMAND_BATTERY_CURRENT_OFFSET_COMMONMODE_CAL: ADS_1260_BatteryCurrentOffsetCommonModeErrorComepensationStart(&sys_data);  break;
288          case COMMAND_BATTERY_CURRENT_OFFSET_TEMP_CAL:       ADS_1260_BatteryCurrentOffsetTemperatureErrorComepensationStart();                  break;
289          case COMMAND_BATTERY_CURRENT_GAIN_CAL:              ADS_1260_BatteryCurrentGainCalibrationStart(&sys_data);                                     break;
290          case COMMAND_BATTERY_CURRENT_GAIN_TEMP_SHUNT_CAL:   ADS_1260_BatteryCurrentGainTemperatureCalibrationShuntStart();                      break;
291//        case COMMAND_BATTERY_CURRENT_GAIN_TEMP_CHIP_CAL:    ADS_1260_BatteryCurrentGainTemperatureCalibrationChipStart(); break;
292          case COMMAND_SET_RDP_LEVEL0:                        SetFlashReadProtection(false);                                                                                      break;
293          case COMMAND_SET_RDP_LEVEL1:                        SetFlashReadProtection(true);                                                                                               break;
294          case COMMAND_SET_RDP_LEVEL1_AND_BOOTSEL:            SetBootFromFlashAndReadOutProtection();                                                                     break;
295          default:                                            printf("UNKNOWN COMMAND\n");
296        }
297        sys_data.s.parameter.command = 0;
298      }
299      else
300      {
301        //printf("wait with execution till modbus communnikation finished\n");
302      }
303    }
304
305    if((HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET) && (mode_button_disable_time == 0))
306    {
307      HAL_Delay(10);
308      //Taste weiterhin gedrckt?
309      if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
310      {
311        //Ja, dann Silent Mode umschalten
312        mode_button_disable_time=500;
313        if (silentmode == 0)
314        {
315          silentmode = 1;
316          HAL_GPIO_WritePin(LED_FUNC_GPIO_Port, LED_FUNC_Pin,GPIO_PIN_SET);
317        }
318        else
319        {
320          silentmode = 0;
321        }
322       }
323    }
324
[20]325        // Modbus Kommunikation
[22]326
327//      printf("data12d1=%d,data12d2=%d,data5=%d\r\n", adc12Data[0], adc12Data[1] , adc5Data[2]);
[20]328    if (mbGetFrameComplete(&modbusData) == true)
329    {
330      if (mbSlaveCheckModbusRtuQuery(&modbusData) == RESPOND_TO_QUERY)
331      {
332          if (silentmode == 0)
333          {
334            mbSlaveProcessRtuQuery(&modbusData);
335          }
336      }
337      else
338      {
339        huart1.RxState = HAL_UART_STATE_BUSY_RX;
340      }
341    }
342
343  }
344  /* USER CODE END 3 */
345}
346
347/**
348  * @brief System Clock Configuration
349  * @retval None
350  */
351void SystemClock_Config(void)
352{
353  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
354  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
355
356  /** Configure the main internal regulator output voltage
357  */
358  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
359
360  /** Initializes the RCC Oscillators according to the specified parameters
361  * in the RCC_OscInitTypeDef structure.
362  */
363  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48|RCC_OSCILLATORTYPE_HSE;
364  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
365  RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
366  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
367  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
368  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
369  RCC_OscInitStruct.PLL.PLLN = 16;
370  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
371  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
372  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
373  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
374  {
375    Error_Handler();
376  }
377
378  /** Initializes the CPU, AHB and APB buses clocks
379  */
380  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
381                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
382  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
383  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
384  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
385  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
386
387  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
388  {
389    Error_Handler();
390  }
391}
392
393/* USER CODE BEGIN 4 */
[22]394 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
395 {
396    if (hadc->Instance==ADC1)
397        {
[24]398          newADC12Data=1;
[22]399        }
[20]400
[24]401        if (hadc->Instance==ADC3)
[22]402        {
[24]403          newADC3Data=1;
[22]404        }
[24]405
406
407        if (hadc->Instance==ADC4)
408        {
409          newADC4Data=1;
410        }
411
412        if (hadc->Instance==ADC5)
413        {
414          newADC5Data=1;
415        }
[22]416 }
[20]417
[22]418
419 
420/**
421
422  * @brief  Set flash read protection.
423
424  * @param  [in] state: Flash read protection state, true: enable protection, false: disable protection.
425
426  * @retval true:  Successful operation.
427
428  * @retval false: Operation failed.
429
430  */
431
432bool SetFlashReadProtection(bool state)
433{
434
435  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
436  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
437
438  if(state == true)
439  {
440    printf("Start enable readout protection\n");
441    if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_0)
442    {
443      OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
444      OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
445      if (HAL_FLASH_Unlock() != HAL_OK)
446      {
447        printf("Flash unlock error\n");
448      }
449      if (HAL_FLASH_OB_Unlock() != HAL_OK)
450      {
451        printf("Flash ob unlock error\n");
452      }
453
454      printf("...Flash unlock\n");
455      if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
456      {
457        printf("...Enable lock error\n");
458        HAL_FLASH_OB_Lock();
459        return false;
460      }
461      HAL_FLASH_OB_Lock();
462      printf("Flash Optionbyte locked\n");
463      HAL_FLASH_Lock();
464      printf("Flash  locked\n");
465      printf("...Enable lock process finished\n");
466    }
467    else
468    {
469      printf("...Flash lock already active\n");
470    }
471  }
472  else
473  {
474    if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_1)
475    {
476      OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
477      OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_0;
478
479      if (HAL_FLASH_Unlock() != HAL_OK)
480      {
481        printf("Flash unlock error\n");
482        return false;
483      }
484      printf("...Flash unlocked\n");
485
486      if (HAL_FLASH_OB_Unlock() != HAL_OK)
487      {
488        printf("Flash ob unlock error\n");
489        return false;
490      }
491      printf("...Flash ob unlocked\n");
492
493      if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
494      {
495        HAL_FLASH_OB_Lock();
496        printf("Flash Optionbyte programm failed\n");
497        return false;
498      }
499
500      printf("Flash Optionbyte programmed\n");
501      HAL_FLASH_OB_Lock();
502      printf("Flash Optionbyte locked\n");
503      HAL_FLASH_Lock();
504      printf("Flash  locked\n");
505      printf("...Disable lock process finished\n");
506
507;
508    }
509  }
510  return true;
511}
512
513bool SetBootFromFlashAndReadOutProtection(void)
514{
515
516  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
517  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
518
519  //Konfiguriere RDP fr Readoutprotection and USER OPTION BYTE FR Boot from Flash
520  OptionsBytesStruct.OptionType = OPTIONBYTE_USER | OPTIONBYTE_RDP;
521
522  //Set Readout Protection Level 1
523  OptionsBytesStruct.OptionType = OPTIONBYTE_USER|OPTIONBYTE_RDP;
524  OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
525
526  //Selecting Boot from Main Flash Memory
527  OptionsBytesStruct.USERType =    OB_USER_nBOOT0 | OB_USER_nSWBOOT0 | OB_USER_nBOOT1 ;
528  OptionsBytesStruct.USERConfig  = OB_USER_nBOOT0 | OB_USER_nSWBOOT0;
529
530  if (HAL_FLASH_Unlock() != HAL_OK)
531  {
532    printf("Flash unlock error\n");
533  }
534  if (HAL_FLASH_OB_Unlock() != HAL_OK)
535  {
536    printf("Flash ob unlock error\n");
537  }
538
539  printf("...Flash unlock\n");
540  if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
541  {
542    printf("...Enable lock error\n");
543    HAL_FLASH_OB_Lock();
544    return false;
545  }
546  HAL_FLASH_OB_Lock();
547  printf("Flash Optionbyte locked\n");
548  HAL_FLASH_Lock();
549  printf("Flash  locked\n");
550  printf("...Enable lock process finished\n");
551
552  return true;
553}
554uint8_t printprotectionstate(void)
555{
556  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
557  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
558  uint8_t result = 0;
559
560  if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_0)
561  {
562    //OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
563    //OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
564    printf("PROTECTION: OB_RDP_LEVEL_0\n");
565    result = 0;
566  }
567  else if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_1)
568  {
569    printf("PROTECTION: OB_RDP_LEVEL_1\n");
570    result = 1;
571  }
572  else if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_2)
573  {
574    printf("PROTECTION: OB_RDP_LEVEL_2\n");
575    result = 2;
576  }
577  return  result;
578}
579
[20]580/* USER CODE END 4 */
581
582/**
583  * @brief  This function is executed in case of error occurrence.
584  * @retval None
585  */
586void Error_Handler(void)
587{
588  /* USER CODE BEGIN Error_Handler_Debug */
589  /* User can add his own implementation to report the HAL error return state */
590  __disable_irq();
591  printf("error handler!\r\n");
592  while (1)
593  {
594  }
595  /* USER CODE END Error_Handler_Debug */
596}
597#ifdef USE_FULL_ASSERT
598/**
599  * @brief  Reports the name of the source file and the source line number
600  *         where the assert_param error has occurred.
601  * @param  file: pointer to the source file name
602  * @param  line: assert_param error line source number
603  * @retval None
604  */
605void assert_failed(uint8_t *file, uint32_t line)
606{
607  /* USER CODE BEGIN 6 */
608  /* User can add his own implementation to report the file name and line number,
609     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
610         printf("Wrong parameters value: file %s on line %d\r\n", file, line);
611  /* USER CODE END 6 */
612}
613#endif /* USE_FULL_ASSERT */
Note: See TracBrowser for help on using the repository browser.