zhangzhiwei01
/
TrainCamp_zhangzhiwei_duandianxvchuan
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
47 MiB
 
 
 
 
 
Tree: c7d9f29759
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c7d9f29759'
${ noResults }
TrainCamp_zhangzhiwei_duand.../ddxc/Core/Src/main.c

537 lines
18 KiB
Raw Blame History 

  1. #include "main.h"

  2. #include "sys.h"

  3. #include "delay.h"

  4. #include "usart.h"

  5. #include "led.h"

  6. #include "usmart.h"

  7. #include "malloc.h"

  8. #include "mpu.h"

  9. #include "lan8720.h"

  10. #include "lwip/netif.h"

  11. #include "lwip_comm.h"

  12. #include "lwipopts.h"

  13. #include "includes.h"

  14. #include "stmflash.h"

  15. #include "lwip/opt.h"

  16. #include "lwip/lwip_sys.h"

  17. #include "lwip/api.h"

  18. #include "lwip/sockets.h"

  19. #define TCP_CLIENT_RX_BUFSIZE	2000	//接收缓冲区长度

  20. #define REMOTE_PORT				6666	//定义远端主机的IP地址

  21. #define LWIP_SEND_DATA			0X80    //定义有数据发送

  22. void SystemClock_Config(void);

  23. void MX_GPIO_Init(void);

  24. int read_progress();

  25. INT8U tcp_client_init(void);

  26. OS_EVENT *PREVENT;                                    //发送eth信号量

  27. OS_EVENT *MAIL;                                          //邮箱

  28. INT8U   err;                                            //错误地址

  29. struct netconn *tcp_clientconn=NULL;					//TCP CLIENT网络连接结构体

  30. u8 tcp_client_flag;		                            //TCP客户端数据发送标志位

  31. u8 eth_send=0;

  32. u8 xc_send[4]={0};

  33. u32 bufff=0;          //大存

  34. u8 sml_buf[1024]={0};         //小存

  35. u32 *qq = (u32*)&sml_buf;

  36. int chunchucishu=0;          //写flash次数      //要与flash存储进度挂钩      //最多28

  37. u32 W_head_Addr=0x0803FC00;     //每加了0x400才起作用

  38. u32 W_tail_Addr=0x081FFFF4;     //往上减

  39. int Progress=0;

  40. u16_t server_port;

  41. ip_addr_t server_ipaddr;

  42. 

  43. //START任务

  44. //任务优先级

  45. #define START_TASK_PRIO		10

  46. //任务堆栈大小

  47. #define START_STK_SIZE		128

  48. //任务堆栈

  49. OS_STK START_TASK_STK[START_STK_SIZE];

  50. //任务函数

  51. void start_task(void *pdata); 

  52. 

  53. //ORDER任务

  54. //任务优先级

  55. #define ORDER_TASK_PRIO		2

  56. //任务堆栈大小

  57. #define ORDER_STK_SIZE		512

  58. //任务堆栈

  59. OS_STK	ORDER_TASK_STK[ORDER_STK_SIZE];

  60. //任务函数

  61. void order_task(void *pdata);  

  62. 

  63. //TCP客户端任务

  64. #define TCPCLIENT_PRIO		6

  65. //任务堆栈大小

  66. #define TCPCLIENT_STK_SIZE	512

  67. //任务堆栈

  68. OS_STK TCPCLIENT_TASK_STK[TCPCLIENT_STK_SIZE];

  69. //tcp客户端任务函数

  70. static void tcp_client_thread(void *arg);

  71. 

  72. //ETH发送任务

  73. //任务优先级

  74. #define ETH_SEND_TASK_PRIO		8

  75. //任务堆栈大小

  76. #define ETH_SEND_STK_SIZE		128

  77. //任务堆栈

  78. OS_STK	ETH_SEND_TASK_STK[ETH_SEND_STK_SIZE];

  79. //任务函数

  80. void eth_send_task();  

  81. 

  82. int connect_chack();

  83. void write_flash(); 

  84. void ethsend(u8 eth_sendd);

  85. 

  86. 

  87. int main(void)

  88. {

  89.   Write_Through();                //开启强制透写！

  90.   MPU_Memory_Protection();        //保护相关存储区域

  91.   Cache_Enable();                 //打开L1-Cache

  92. 

  93.   HAL_Init();

  94.   SystemClock_Config();

  95.   delay_init(216);                //延时初始化

  96.   MX_GPIO_Init();

  97.   MX_USART1_UART_Init();

  98.   HAL_UART_Receive_IT(&huart1,&eth_send,1);

  99. //    server_port = REMOTE_PORT;

  100. //	IP4_ADDR(&server_ipaddr, lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  101. 	

  102. 

  103. //    ersae_all();

  104. //  STMFLASH_Write(0x081FFFFC,&bufff[0],1); //完成标志写入flash

  105.   if(STMFLASH_ReadWord(0x081FFFFC) != 0xFFFFFFFF)ersae_all();//如果最后一个地址里面被写了数据，代表之前文件已经传完，擦除空间

  106. //  else Progress = read_progress();//查后面的，存到第几个包了，记录一下，一会接着要

  107.   LED0_Toggle();

  108.   OSInit(); 					    //UCOS初始化

  109.   while(lwip_comm_init());         //lwip初始化

  110.   while(tcp_client_init());	    //初始化tcp_server(创建tcp_server程)

  111.   printf("客户端创建成功！\r\n");

  112.   OSTaskCreate(start_task,(void*)0,(OS_STK*)&START_TASK_STK[START_STK_SIZE-1],START_TASK_PRIO);

  113.     OSStart();          //开启UCOS		

  114. }

  115. 

  116. 

  117. 

  118. //tcp客户端任务函数

  119. static void tcp_client_thread(void *arg)

  120. {

  121. 	OS_CPU_SR cpu_sr;

  122. 	u32 data_len = 0;

  123. 	struct pbuf *q;

  124.     struct netbuf *recvbuf;

  125. 	err_t recv_err;

  126. //	static ip_addr_t server_ipaddr,loca_ipaddr;

  127. //	static u16_t 		 server_port,loca_port;

  128. 

  129. 	LWIP_UNUSED_ARG(arg);

  130. //	server_port = REMOTE_PORT;

  131. //	IP4_ADDR(&server_ipaddr, lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  132. 	

  133. 	while (1) 

  134. 	{

  135. 		if(connect_chack() == 1)

  136.         {

  137.             while(1)

  138. 			{					/*recv_err = netconn_recv(tcp_clientconn,&recvbuf)*/

  139.                                 /*recv( tcp_clientconn->socket, &recvbuf, 1024, 0)*/

  140.                 if((recv_err = netconn_recv(tcp_clientconn,&recvbuf)) == ERR_OK)  //接收到数据

  141.                 {	

  142.                     OS_ENTER_CRITICAL(); //关中断

  143.                     memset(sml_buf,0,TCP_CLIENT_RX_BUFSIZE);  //数据接收缓冲区清零

  144.                     for(q=recvbuf->p;q!=NULL;q=q->next)  //遍历完整个pbuf链表

  145.                     {

  146.                         //判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于

  147.                         //的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据

  148.                         if(q->len > (TCP_CLIENT_RX_BUFSIZE-data_len)) memcpy(sml_buf+data_len,q->payload,(TCP_CLIENT_RX_BUFSIZE-data_len));//拷贝数据

  149.                         else memcpy(sml_buf+data_len,q->payload,q->len);

  150.                         data_len += q->len;  	

  151.                         if(data_len > TCP_CLIENT_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出	

  152.                     }

  153.                     OS_EXIT_CRITICAL();  //开中断

  154.                     

  155.                     if((data_len<10)&&(sml_buf[0]==0x6F)&&(sml_buf[1]==0x76)&&(sml_buf[2]==0x65)&&(sml_buf[3]==0x72))

  156.                     {                               //如果接到结束符

  157.                         ethsend(0x35);    

  158.                         data_len=0;  //复制完成后data_len要清零。					

  159.                         netbuf_delete(recvbuf);

  160.                     

  161.                         while(1)        //等服务器发校验数目

  162.                         {

  163.                             if((recv_err = netconn_recv(tcp_clientconn,&recvbuf)) == ERR_OK)  //接收到数据

  164.                             {	

  165.                                 OS_ENTER_CRITICAL(); //关中断

  166.                                 memset(sml_buf,0,TCP_CLIENT_RX_BUFSIZE);  //数据接收缓冲区清零

  167.                                 for(q=recvbuf->p;q!=NULL;q=q->next)  //遍历完整个pbuf链表

  168.                                 {

  169.                                     //判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于

  170.                                     //的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据

  171.                                     if(q->len > (TCP_CLIENT_RX_BUFSIZE-data_len)) memcpy(sml_buf+data_len,q->payload,(TCP_CLIENT_RX_BUFSIZE-data_len));//拷贝数据

  172.                                     else memcpy(sml_buf+data_len,q->payload,q->len);

  173.                                     data_len += q->len;  	

  174.                                     if(data_len > TCP_CLIENT_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出	

  175.                                 }

  176.                                 OS_EXIT_CRITICAL();  //开中断

  177.                                 data_len=0;  //复制完成后data_len要清零。					

  178.                                 netbuf_delete(recvbuf);

  179.                                 break;

  180.                             }                            

  181.                         }

  182.                         int a=(int)sml_buf[0]*256+(int)sml_buf[1];

  183.                         if(a == chunchucishu+Progress)//成功

  184.                         {

  185.                             ethsend(0x36);                       //回馈传输成功信息                           

  186. //                            chunchucishu=0;

  187.                             STMFLASH_Write(0x081FFFFC,&bufff,1); //完成标志写入flash

  188.                             netconn_close(tcp_clientconn);

  189.                             netconn_delete(tcp_clientconn);

  190.                             printf("服务器%d.%d.%d.%d断开连接\r\n",lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  191.                             break;

  192.                         }

  193.                         else //失败

  194.                         {

  195.                             ethsend(0x37); 

  196. //                            chunchucishu=0;

  197.                             STMFLASH_Write(0x081FFFFC,&bufff,1);//传输失败也要写东西

  198.                             netconn_close(tcp_clientconn);

  199.                             netconn_delete(tcp_clientconn);

  200.                             printf("服务器%d.%d.%d.%d断开连接\r\n",lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  201.                             break;

  202.                         }

  203.                     }

  204.                     else    //如果不是结束符，正常工作

  205.                     {

  206.                         data_len=0;  //复制完成后data_len要清零。					

  207.                         netbuf_delete(recvbuf);

  208.                         W_head_Addr += 0x400;

  209.                         write_flash();

  210.                     }

  211.                 }

  212.                 else if(recv_err == ERR_CLSD)  //关闭连接

  213.                 {

  214.                     netconn_close(tcp_clientconn);

  215.                     netconn_delete(tcp_clientconn);

  216.                     printf("服务器%d.%d.%d.%d断开连接\r\n",lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  217.                     break;

  218.                 }

  219. 

  220.             }

  221.         }

  222.     }

  223. }

  224. 

  225. int read_progress()

  226. {

  227.     u32 addr = 0x081FFFF4;

  228.     int a=0;

  229.     while(STMFLASH_ReadWord(addr)!=0xFFFFFFFF)

  230.     {

  231.         a++;

  232.         addr-=4;

  233.     }

  234.     return a;

  235. }

  236. 

  237. void write_flash()

  238. {

  239.        chunchucishu++;   

  240. //       if(STMFLASH_ReadWord(W_tail_Addr)==0XFFFFFFFF)

  241.        STMFLASH_Write(W_tail_Addr,qq,1);         //先把坑占了，先声明这个坑我要用了

  242.        W_tail_Addr-=4;

  243.        STMFLASH_Write(W_head_Addr,qq,256);       //再用这个坑

  244.        ethsend(0x34);     

  245. }

  246. 

  247. int connect_chack()

  248. {

  249.     err_t err;

  250.     

  251.     static ip_addr_t loca_ipaddr;

  252.     static u16_t loca_port;

  253.     tcp_clientconn=netconn_new(NETCONN_TCP);  //创建一个TCP链接

  254.     server_port = REMOTE_PORT;

  255. 	IP4_ADDR(&server_ipaddr, lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]);

  256. 	

  257.     err = netconn_connect(tcp_clientconn,&server_ipaddr,server_port);//连接服务器

  258.     if(err != ERR_OK)

  259.     { 

  260.       netconn_delete(tcp_clientconn); //返回值不等于ERR_OK,删除tcp_clientconn连接

  261.       return 0;

  262.     }

  263.     else    //处理新连接的数据

  264.     { 

  265. //        struct netbuf *recvbuf;

  266.         tcp_clientconn->recv_timeout = 10;

  267.         netconn_getaddr(tcp_clientconn,&loca_ipaddr,&loca_port,1); //获取本地IP主机IP地址和端口号

  268.         printf("连接上服务器%d.%d.%d.%d,本机端口号为:%d\r\n",lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3],loca_port);

  269.         

  270.         if((STMFLASH_ReadWord(0x081FFFF8) != 0xFFFFFFFF)&&(STMFLASH_ReadWord(0x081FFFFC) == 0xFFFFFFFF))

  271.         {

  272.             Progress = read_progress();

  273.             xc_send[0]=0x30;

  274.             xc_send[1]=(u8)STMFLASH_ReadWord(0x081FFFF8);

  275.             xc_send[2]=Progress/256;

  276.             xc_send[3]=Progress%256;

  277.             netconn_write(tcp_clientconn ,&xc_send,4,NETCONN_COPY);

  278.             W_tail_Addr = 0x081FFFF4 - 4*Progress;

  279.             W_head_Addr = 0x0803FC00 + 0x400*Progress;

  280.             printf("要续传了\n");

  281.         }

  282.         return 1;

  283.     }

  284. }

  285. 

  286. void	USART1_IRQHandler()

  287. {

  288.     OSIntEnter();   

  289.     HAL_UART_Receive_IT(&huart1,&eth_send,1);

  290.     

  291.     OSMboxPost(MAIL,&eth_send);                    //往邮箱MAIL里面发intrpt的地址

  292.     

  293. //    if(eth_send==0xca)caca=1;

  294. //    else OSSemPost(PREVENT);

  295.     HAL_UART_IRQHandler(&huart1);

  296.     __HAL_UART_ENABLE_IT(&huart1, UART_IT_ERR);

  297.     __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);

  298.     OSIntExit();  

  299. }

  300. 

  301. void ethsend(u8 eth_sendd)

  302. {

  303.     err = netconn_write(tcp_clientconn ,&eth_sendd,1,NETCONN_COPY); //发送串口收到的指令

  304.     if(err != ERR_OK)

  305.     {

  306.         printf("发送失败\r\n");

  307.     }

  308.     else printf("发送成功%d\r\n",eth_sendd);

  309.     tcp_client_flag &= ~LWIP_SEND_DATA;

  310. }

  311. 

  312. 

  313. void order_task(void *pdata)

  314. {

  315.     static void *M_num;        //接收邮箱数据

  316.     static char num = 0; 

  317.     while(1)

  318.     {

  319.         M_num = OSMboxPend(MAIL,0,&err);  //获取邮箱里面数据的地址

  320.         if(M_num != NULL)

  321.         {                  

  322.             num = *(char*)M_num;

  323.             if(num == 0xca)                 //恢复如初

  324.             {

  325.                 LED0_Toggle();

  326.                 chunchucishu=0;

  327.                 W_head_Addr=0x0803FC00;     //每加了0x400才起作用

  328.                 W_tail_Addr=0x081FFFF4;     //往上减

  329.                 Progress=0;

  330.                 ersae_all();    

  331.                 LED0_Toggle();

  332.             }  

  333.             else if((num == 0x31)||(num == 0x32)||(num == 0x33))

  334.             {

  335.                 eth_send = num;

  336.                 OSSemPost(PREVENT);

  337. //                if(STMFLASH_ReadWord(0x081FFFF8) == 0xFFFFFFFF)

  338. //                {

  339.                 u32 a;

  340.                 a=(u32)num;

  341.                 STMFLASH_Write(0x081FFFF8,&a,1);//记录文件序号

  342. //                }

  343. 

  344.             }

  345.             else if((num == 0x38)||(num == 0x39)||(num == 0x3a))

  346.             {

  347.                 eth_send = num;

  348.                 OSSemPost(PREVENT);

  349.             }

  350.             else if(num == 0x22)

  351.             {

  352.                 printf("连接结果是%d",connect_chack());

  353.             }

  354.             else if(num == 0x11)

  355.             {

  356.                 Progress = read_progress();

  357.                 xc_send[0]=0x30;

  358.                 xc_send[1]=(u8)STMFLASH_ReadWord(0x081FFFF8);

  359.                 xc_send[2]=Progress/256;

  360.                 xc_send[3]=Progress%256;

  361.                 netconn_write(tcp_clientconn ,&xc_send,4,NETCONN_COPY);

  362.                 W_tail_Addr = 0x081FFFF4 - 4*Progress;

  363.                 W_head_Addr = 0x0803FC00 + 0x400*Progress;

  364.                 chunchucishu=0;

  365.                 printf("要续传了\n");

  366.             }

  367.         }

  368.         OSTimeDlyHMSM(0,0,0,500);  //延时500ms

  369.     }

  370. }

  371. //ETH发送任务

  372. void eth_send_task(void *pdata)

  373. {

  374.     while(1)

  375.     {

  376.         OSSemPend(PREVENT,0,&err);        //申请信号量

  377.         err = netconn_write(tcp_clientconn ,&eth_send,1,NETCONN_COPY); //发送串口收到的指令

  378.         if(err != ERR_OK)

  379.         {

  380.             printf("发送失败\r\n");

  381.         }

  382.         else printf("发送成功%d\r\n",eth_send);

  383.         tcp_client_flag &= ~LWIP_SEND_DATA;

  384. 

  385.         

  386.         OSTimeDlyHMSM(0,0,0,500);  //延时500ms

  387.     }

  388. }

  389. 

  390. 

  391. 

  392. //创建TCP客户端线程

  393. //返回值:0 TCP客户端创建成功

  394. //		其他 TCP客户端创建失败

  395. INT8U tcp_client_init(void)

  396. {

  397. 	INT8U res;

  398. 	OS_CPU_SR cpu_sr;

  399. 	

  400. 	OS_ENTER_CRITICAL();	//关中断              

  401. 	

  402.     OSTaskCreate(eth_send_task,(void*)0,(OS_STK*)&ETH_SEND_TASK_STK[ETH_SEND_STK_SIZE-1],ETH_SEND_TASK_PRIO); //显示任务

  403. 	

  404.     res = OSTaskCreate(tcp_client_thread,(void*)0,(OS_STK*)&TCPCLIENT_TASK_STK[TCPCLIENT_STK_SIZE-1],TCPCLIENT_PRIO); //创建TCP客户端线程

  405. 	PREVENT = OSSemCreate(1);              //创建信号量

  406. //    W_FLASH = OSSemCreate(1);              //创建信号量

  407.     OSSemPend(PREVENT,0,&err);

  408. //    OSSemPend(W_FLASH,0,&err);

  409.     OS_EXIT_CRITICAL();		//开中断

  410. 	

  411. 	return res;

  412. }

  413. 

  414. /* USER CODE BEGIN 4 */

  415. //start任务

  416. void start_task(void *pdata)

  417. {

  418. 	OS_CPU_SR cpu_sr;

  419. 	pdata = pdata ;

  420. 	static INT8U  mbox;        //邮箱

  421. 	OSStatInit();  			//初始化统计任务

  422. 	OS_ENTER_CRITICAL();  	//关中断

  423. 	

  424. 	OSTaskCreate(order_task,(void*)0,(OS_STK*)&ORDER_TASK_STK[ORDER_STK_SIZE-1],ORDER_TASK_PRIO);//创建ORDER任务

  425. //    OSTaskCreate(write_flash,(void*)0,(OS_STK*)&FLASH_TASK_STK[FLASH_STK_SIZE-1],FLASH_TASK_PRIO);//创建LED任务

  426.     MAIL = OSMboxCreate((void*)mbox);           //创建邮箱

  427.     OSTaskSuspend(OS_PRIO_SELF); //挂起start_task任务

  428. 	OS_EXIT_CRITICAL();  		//开中断

  429. }

  430. 

  431. 

  432. /**

  433.   * @brief System Clock Configuration

  434.   * @retval None

  435.   */

  436. void SystemClock_Config(void)

  437. {

  438.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  439.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  440. 

  441.   /** Configure the main internal regulator output voltage

  442.   */

  443.   __HAL_RCC_PWR_CLK_ENABLE();

  444.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  445.   /** Initializes the RCC Oscillators according to the specified parameters

  446.   * in the RCC_OscInitTypeDef structure.

  447.   */

  448.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  449.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;

  450.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

  451.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  452.   RCC_OscInitStruct.PLL.PLLM = 6;

  453.   RCC_OscInitStruct.PLL.PLLN = 216;

  454.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;

  455.   RCC_OscInitStruct.PLL.PLLQ = 2;

  456.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

  457.   {

  458.     Error_Handler();

  459.   }

  460.   /** Activate the Over-Drive mode

  461.   */

  462.   if (HAL_PWREx_EnableOverDrive() != HAL_OK)

  463.   {

  464.     Error_Handler();

  465.   }

  466.   /** Initializes the CPU, AHB and APB buses clocks

  467.   */

  468.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

  469.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

  470.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  471.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  472.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;

  473.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  474. 

  475.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)

  476.   {

  477.     Error_Handler();

  478.   }

  479. }

  480. 

  481. /* USER CODE END 4 */

  482. 

  483. /**

  484.   * @brief  This function is executed in case of error occurrence.

  485.   * @retval None

  486.   */

  487. void Error_Handler(void)

  488. {

  489.   /* USER CODE BEGIN Error_Handler_Debug */

  490.   /* User can add his own implementation to report the HAL error return state */

  491.   __disable_irq();

  492.   while (1)

  493.   {

  494.   }

  495.   /* USER CODE END Error_Handler_Debug */

  496. }

  497. 

  498. #ifdef  USE_FULL_ASSERT

  499. /**

  500.   * @brief  Reports the name of the source file and the source line number

  501.   *         where the assert_param error has occurred.

  502.   * @param  file: pointer to the source file name

  503.   * @param  line: assert_param error line source number

  504.   * @retval None

  505.   */

  506. void assert_failed(uint8_t *file, uint32_t line)

  507. {

  508.   /* USER CODE BEGIN 6 */

  509.   /* User can add his own implementation to report the file name and line number,

  510.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  511.   /* USER CODE END 6 */

  512. }

  513. #endif /* USE_FULL_ASSERT */

  514. void MX_GPIO_Init(void)

  515. {

  516. 

  517.   GPIO_InitTypeDef GPIO_InitStruct = {0};

  518. 

  519.   /* GPIO Ports Clock Enable */

  520.   __HAL_RCC_GPIOA_CLK_ENABLE();

  521.   __HAL_RCC_GPIOH_CLK_ENABLE();

  522.   __HAL_RCC_GPIOF_CLK_ENABLE();

  523.   __HAL_RCC_GPIOB_CLK_ENABLE();

  524.   

  525.   /*Configure GPIO pin Output Level */

  526.   HAL_GPIO_WritePin(GPIOF, GPIO_PIN_7|GPIO_PIN_6|GPIO_PIN_8, GPIO_PIN_SET);

  527. 

  528.   /*Configure GPIO pins : PF7 PF6 PF8 */

  529.   GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6|GPIO_PIN_8;

  530.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  531.   GPIO_InitStruct.Pull = GPIO_NOPULL;

  532.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

  533.   HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  534. 

  535. }

  536. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/