【STM32乙太網線上培訓】手把手搭建TCP伺服器及TFTP伺服器

非常感謝STM32乙太網線上培訓，真的讓我學到非常多，沒培訓前很想搞乙太網但有種無從下手的感覺，經過這次培訓讓我從這個架構上有個從上到下的瞭解，再借助官方神器STM32CubeMX，開發和學習起來還是非常快的！我一直是STM32的粉絲，一直想去現場培訓，但無奈沒有機會，不過好希望能申請一個板子

  看培訓直播的照片我就不發了，當時看這個直播喝水都是跑著去的。
  我手上沒有官方的板子，帶乙太網的只有原子的F407的板子，所以也是在這個平臺上做的，板子上的PHY為LAN8720A，沒有用到顯示屏全為串列埠輸出除錯資訊。
實現功能：通過STM32CubeMX在原子F407板子上搭建TCP Server 及 TFTP Server ，實現這些功能非常簡單。
一、功能介紹
  1、TCP Server 實現顯示連線上的客戶端IP及對客戶端發來的資料回傳
  2、TFTP Server 實現IAP功能及讀取MCU內部FLASH資料。這裡用到的是檔案傳輸協議，主要是參考官方文件UM1709，及官方STM324xG_EVAL的LWIP IAP例子。
二、工程搭建
1、外設配置開啟STM32CubeMX，點NEW PROJECT，在左側的輸入框中輸入407ZG，在右側會顯示STM32F407ZGT6的MCU列表，選擇此列表，雙擊。
設定時鐘源為外部時鐘

開啟SWD除錯介面，開啟ETH外設，選擇RMII介面（LAN8720A為RMII介面），中介軟體裡時能LWIP。使用RMII介面的時候軟體會自動配置對應的引腳，但是一定要仔細對比軟體配置的引腳是否為板子上硬體所連線的。

原子F407板子上的LAN8720A的RMII介面引腳如下圖，

而軟體配置的引腳如下：

顯然與實際板子上的硬體連線不同，這裡需要手動調整3個引腳，分別為:
  ETH_TX_EN -> PG11
  ETH_TXD0  ->  PG13
  ETH_TXD1  ->  PG14
  PD3配置成GPIO輸出（LAN8720A的硬體復位引腳）
時能串列埠1，用於除錯

2、配置時鐘
外部高速晶振選擇為8M，PLL SORCE MUX 選擇為HSE，在HCLK處輸入168點回車，軟體會自動配置好。

3、中介軟體配置
這裡我們主要配置，ETH、LWIP、串列埠1、GPIO

因為PD3為PHY的輸入引腳，所有我們這裡直接配置它為輸出高，這樣就為正常工作狀態

串列埠1我們設定它的波特率為115200，添加發送DMA，注意！如果添加了傳送或者接收DMA則必須開啟串列埠中斷。

ETH設定，這裡主要是注意PHY的地址，原子407的PHY地址引腳為懸空，地址為0。

ETH設定的 Advanced Parameters 選項裡面，我們選擇PHY為USER PHY，名字我們取 LAN7820A，其它的設定全用預設即可。要改的暫存器基本就只有ExternalPHY Configuration，但是我看了下官方的例子，基本沒有用到這暫存器裡面的值，只有在使用作業系統並且時能了連線狀態變更回撥或者其它檢測的時候才用到，所有這裡我們也不管，都用預設值。

LWIP設定，我們關閉DHCP，採用靜態IP，因為我所在的閘道器為192.168.0.XXX，所以IP必須為192.168.0.XXX。這裡我設定IP為192.168.0.120。因為要用到TCP 和 UDP（TFTP就是用的UDP），所以這兩個都是時能的.其它設定選項我們先不管，直接點OK。

4、生成工程程式碼
點左上角的Project，選擇Settings ...(不建議直接點黃色的齒輪)

取個非中文的工程名，選擇IDE為KEIL MDK V5

點選OK。再點右上方的黃色齒輪即可生成工程程式碼。
三、工程程式碼
生成的程式碼的試圖如下：

1、TCP Server 的實現
在math.h中加入
#include "stm32f4xx_hal.h"
#include "stdio.h"

用於支援printf 及一些 HAL 定義的資料結構

在uart.c 檔案中加入如下程式碼，用於把printf輸出到串列埠1

/* USER CODE BEGIN 0 */
int fputc(int c,FILE * f)
{
HAL_UART_Transmit(&huart1,(uint8_t *)&c,1,20);
return c;
}
/* USER CODE END 0 */

複製程式碼注意一定要在 /* USER CODE BEGIN X */ 與 /* USER CODE END X */ 中間新增程式碼，不然重新用STM32CubeMX生成程式碼後就會被覆蓋。
在LWIP.C 中新增如下程式碼：

void User_notification(void)
{
if (netif_is_up(&gnetif))
{
uint8_t iptxt[20];
sprintf((char *)iptxt, "%s", ip4addr_ntoa((const ip4_addr_t *)&gnetif.ip_addr));
printf ("Static IP address: %s\r\n", iptxt);
}
}

複製程式碼這個程式碼的功能是把網絡卡的IP地址通過串列埠輸出，這個是從官方例子裡面COPY出來的，例子裡面是輸出到LCD上，這個是通過串列埠輸出
接下來重點：
新建 tcp_echoserver.c 檔案，並在檔案中新增如下程式碼：

/**
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of and a contribution to the lwIP TCP/IP stack.
*
* Credits go to Adam Dunkels (and the current maintainers) of this software.
*
* Christiaan Simons rewrote this file to get a more stable echo application.
*
**/
/* This file was modified by ST */
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include "usart.h"
#if LWIP_TCP
static struct tcp_pcb *tcp_echoserver_pcb;
/* ECHO protocol states */
enum tcp_echoserver_states
{
ES_NONE = 0,
ES_ACCEPTED,
ES_RECEIVED,
ES_CLOSING
};
/* structure for maintaing connection infos to be passed as argument
to LwIP callbacks*/
struct tcp_echoserver_struct
{
u8_t state; /* current connection state */
u8_t retries;
struct tcp_pcb *pcb; /* pointer on the current tcp_pcb */
struct pbuf *p; /* pointer on the received/to be transmitted pbuf */
};
static err_t tcp_echoserver_accept(void *arg, struct tcp_pcb *newpcb, err_t err);
static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err);
static void tcp_echoserver_error(void *arg, err_t err);
static err_t tcp_echoserver_poll(void *arg, struct tcp_pcb *tpcb);
static err_t tcp_echoserver_sent(void *arg, struct tcp_pcb *tpcb, u16_t len);
static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es);
static void tcp_echoserver_connection_close(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es);
/**
* @brief Initializes the tcp echo server
* @param None
* @retval None
*/
void tcp_echoserver_init(void)
{
/* create new tcp pcb */
tcp_echoserver_pcb = tcp_new();
if (tcp_echoserver_pcb != NULL)
{
err_t err;
/* bind echo_pcb to port 7 (ECHO protocol) */
err = tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, 7);
if (err == ERR_OK)
{
/* start tcp listening for echo_pcb */
tcp_echoserver_pcb = tcp_listen(tcp_echoserver_pcb);
printf("開始監聽 \r\n");
/* initialize LwIP tcp_accept callback function */
tcp_accept(tcp_echoserver_pcb, tcp_echoserver_accept);
printf("掛載客戶端連接回調函式 \r\n");
}
else
{
/* deallocate the pcb */
memp_free(MEMP_TCP_PCB, tcp_echoserver_pcb);
printf("TCP PCB 記憶體申請失敗 \r\n");
}
}
}
/**
* @brief This function is the implementation of tcp_accept LwIP callback
* @param arg: not used
* @param newpcb: pointer on tcp_pcb struct for the newly created tcp connection
* @param err: not used
* @retval err_t: error status
*/
static err_t tcp_echoserver_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
{
err_t ret_err;
struct tcp_echoserver_struct *es;
LWIP_UNUSED_ARG(arg);
LWIP_UNUSED_ARG(err);
/* set priority for the newly accepted tcp connection newpcb */
tcp_setprio(newpcb, TCP_PRIO_MIN);
printf("收到客戶端連線請求，設定剛連線的客戶端為最低優先順序 \r\n");
uint8_t iptxt[20];
sprintf((char *)iptxt, "%s", ip4addr_ntoa((const ip4_addr_t *)&newpcb->remote_ip));
printf ("客戶端 IP address: %s\r\n", iptxt);
/* allocate structure es to maintain tcp connection informations */
es = (struct tcp_echoserver_struct *)mem_malloc(sizeof(struct tcp_echoserver_struct));
if (es != NULL)
{
es->state = ES_ACCEPTED;
es->pcb = newpcb;
es->retries = 0;
es->p = NULL;
printf("為新連線的客戶端掛載需要的回撥函式及呼叫引數 \r\n");
/* pass newly allocated es structure as argument to newpcb */
tcp_arg(newpcb, es);
/* initialize lwip tcp_recv callback function for newpcb */
tcp_recv(newpcb, tcp_echoserver_recv);
/* initialize lwip tcp_err callback function for newpcb */
tcp_err(newpcb, tcp_echoserver_error);
/* initialize lwip tcp_poll callback function for newpcb */
tcp_poll(newpcb, tcp_echoserver_poll, 0);
ret_err = ERR_OK;
}
else
{
/* close tcp connection */
tcp_echoserver_connection_close(newpcb, es);
printf("tcp_echoserver_struct 記憶體申請失敗關閉連線 \r\n");
/* return memory error */
ret_err = ERR_MEM;
}
return ret_err;
}
/**
* @brief This function is the implementation for tcp_recv LwIP callback
* @param arg: pointer on a argument for the tcp_pcb connection
* @param tpcb: pointer on the tcp_pcb connection
* @param pbuf: pointer on the received pbuf
* @param err: error information regarding the reveived pbuf
* @retval err_t: error code
*/
static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{
struct tcp_echoserver_struct *es;
err_t ret_err;
LWIP_ASSERT("arg != NULL",arg != NULL);
printf("收到客戶端資料\r\n");
es = (struct tcp_echoserver_struct *)arg;
/* if we receive an empty tcp frame from client => close connection */
if (p == NULL)
{
printf("收到斷開連線請求 \r\n");
/* remote host closed connection */
es->state = ES_CLOSING;
if(es->p == NULL)
{
/* we're done sending, close connection */
tcp_echoserver_connection_close(tpcb, es);
}
else
{
printf("傳送的資料還未傳送完成 \r\n");
/* we're not done yet */
/* acknowledge received packet */
tcp_sent(tpcb, tcp_echoserver_sent);
printf("裝載傳送完成回撥函式 \r\n");
/* send remaining data*/
tcp_echoserver_send(tpcb, es);
}
ret_err = ERR_OK;
}
/* else : a non empty frame was received from client but for some reason err != ERR_OK */
else if(err != ERR_OK)
{
/* free received pbuf*/
if (p != NULL)
{
es->p = NULL;
pbuf_free(p);
}
ret_err = err;
}
else if(es->state == ES_ACCEPTED)
{
/* first data chunk in p->payload */
es->state = ES_RECEIVED;
/* store reference to incoming pbuf (chain) */
es->p = p;
/* initialize LwIP tcp_sent callback function */
tcp_sent(tpcb, tcp_echoserver_sent);
printf("裝置剛連線，掛載剛才接收到的資料，設定傳送完成回撥 \r\n");
/* send back the received data (echo) */
tcp_echoserver_send(tpcb, es);
ret_err = ERR_OK;
}
else if (es->state == ES_RECEIVED)
{
/* more data received from client and previous data has been already sent*/
if(es->p == NULL)
{
es->p = p;
printf("接收到的資料直接回傳 \r\n");
/* send back received data */
tcp_echoserver_send(tpcb, es);
}
else
{
struct pbuf *ptr;
printf("上次的資料還未傳送完成，把新資料拼接在後面 \r\n");
/* chain pbufs to the end of what we recv'ed previously */
ptr = es->p;
pbuf_chain(ptr,p);
}
ret_err = ERR_OK;
}
else if(es->state == ES_CLOSING)
{
printf("當前已經是關閉連線了，但還是受到資料 \r\n");
/* odd case, remote side closing twice, trash data */
tcp_recved(tpcb, p->tot_len);
es->p = NULL;
pbuf_free(p);
ret_err = ERR_OK;
}
else
{
/* unkown es->state, trash data */
tcp_recved(tpcb, p->tot_len);
es->p = NULL;
pbuf_free(p);
ret_err = ERR_OK;
}
return ret_err;
}
/**
* @brief This function implements the tcp_err callback function (called
* when a fatal tcp_connection error occurs.
* @param arg: pointer on argument parameter
* @param err: not used
* @retval None
*/
static void tcp_echoserver_error(void *arg, err_t err)
{
struct tcp_echoserver_struct *es;
LWIP_UNUSED_ARG(err);
printf("錯誤： %d \r\n",err);
es = (struct tcp_echoserver_struct *)arg;
if (es != NULL)
{
/* free es structure */
mem_free(es);
}
}
/**
* @brief This function implements the tcp_poll LwIP callback function
* @param arg: pointer on argument passed to callback
* @param tpcb: pointer on the tcp_pcb for the current tcp connection
* @retval err_t: error code
*/
static err_t tcp_echoserver_poll(void *arg, struct tcp_pcb *tpcb)
{
err_t ret_err;
struct tcp_echoserver_struct *es;
es = (struct tcp_echoserver_struct *)arg;
if (es != NULL)
{
if (es->p != NULL)
{
tcp_sent(tpcb, tcp_echoserver_sent);
/* there is a remaining pbuf (chain) , try to send data */
tcp_echoserver_send(tpcb, es);
}
else
{
/* no remaining pbuf (chain) */
if(es->state == ES_CLOSING)
{
/* close tcp connection */
tcp_echoserver_connection_close(tpcb, es);
}
}
ret_err = ERR_OK;
}
else
{
/* nothing to be done */
tcp_abort(tpcb);
ret_err = ERR_ABRT;
}
return ret_err;
}
/**
* @brief This function implements the tcp_sent LwIP callback (called when ACK
* is received from remote host for sent data)
* @param None
* @retval None
*/
static err_t tcp_echoserver_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
{
struct tcp_echoserver_struct *es;
LWIP_UNUSED_ARG(len);
es = (struct tcp_echoserver_struct *)arg;
es->retries = 0;
if(es->p != NULL)
{
/* still got pbufs to send */
tcp_sent(tpcb, tcp_echoserver_sent);
tcp_echoserver_send(tpcb, es);
}
else
{
/* if no more data to send and client closed connection*/
if(es->state == ES_CLOSING)
tcp_echoserver_connection_close(tpcb, es);
}
return ERR_OK;
}
/**
* @brief This function is used to send data for tcp connection
* @param tpcb: pointer on the tcp_pcb connection
* @param es: pointer on echo_state structure
* @retval None
*/
static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es)
{
struct pbuf *ptr;
err_t wr_err = ERR_OK;
uint16_t Count ;
printf("傳送資料的總長度 : %ld \r\n",es->p->tot_len);
printf("傳送資料： \r\n");
while ((wr_err == ERR_OK) &&
(es->p != NULL) &&
(es->p->len <= tcp_sndbuf(tpcb)))
{
/* get pointer on pbuf from es structure */
ptr = es->p; //得到當前需要傳送的資料快取 pbuf
for( Count =0 ; Count < ptr->len; Count++ )
{
printf("0X%02X ",((uint8_t *)ptr->payload)[Count]);
}
/* enqueue data for transmission */
wr_err = tcp_write(tpcb, ptr->payload, ptr->len, TCP_WRITE_FLAG_COPY); //傳送
if (wr_err == ERR_OK)
{
u16_t plen;
u8_t freed;
plen = ptr->len; //得到當前節點的資料長度
/* continue with next pbuf in chain (if any) */
es->p = ptr->next; //得到連結串列的下一個節點
if(es->p != NULL) //如果節點不為空
{
/* increment reference count for es->p */
pbuf_ref(es->p); //成員 ref 的值加1 當收到資料時，pbuf成員ref的值為1 ，在pbuf_free（）函式中是對成員ref減一如果結果為0則釋放此節點記憶體並進入下一個節點否則只是把成員ref的值減一
}
/* chop first pbuf from chain */
do
{
/* try hard to free pbuf */
freed = pbuf_free(ptr); //每執行一個 pbuf中的成員ref的值減一當它這個節點沒有釋放時，返回一直為0
}
while(freed == 0); //執行直到釋放這個節點記憶體為止 pbuf_free（）函式的返回值表示釋放的記憶體的節點數
/* we can read more data now */
tcp_recved(tpcb, plen); //增加可以接收資料的大小
}
else if(wr_err == ERR_MEM)
{
/* we are low on memory, try later / harder, defer to poll */
es->p = ptr; //重發
}
else
{
/* other problem ?? */
}
}
printf("\r\n");
}
/**
* @brief This functions closes the tcp connection
* @param tcp_pcb: pointer on the tcp connection
* @param es: pointer on echo_state structure
* @retval None
*/
static void tcp_echoserver_connection_close(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es)
{
/* remove all callbacks */
tcp_arg(tpcb, NULL);
tcp_sent(tpcb, NULL);
tcp_recv(tpcb, NULL);
tcp_err(tpcb, NULL);
tcp_poll(tpcb, NULL, 0);
/* delete es structure */
if (es != NULL)
{
mem_free(es);
}
/* close tcp connection */
tcp_close(tpcb);
printf("已關閉連線 \r\n");
}
#endif /* LWIP_TCP */

複製程式碼這個程式碼也是從官方的 TCP echoserver 例子COPY出來的，不過裡面加入了串列埠輸出資訊，及一些註釋，感覺寫的很好的，就沒怎麼改了

。
看起來程式碼很多，起始真的不復雜，聽了之前的乙太網配置，這個理解起來還是很簡單的。大致流程如下，先新建一個TCB_PCB、開始監聽、掛載客戶端連線請求回撥函式、掛載接收資料回撥函式、掛載傳送完成回撥函式、掛載出錯回撥函式、掛載心跳包回撥函式、關閉連線等，最重要的是釋放記憶體！每收到一個數據鏈，它已經被申請了記憶體，所有在處理完這個資料後一定要釋放。
在mian.c檔案中加入如下程式碼：

編譯，下載到開發板中。
串列埠輸出如下資料，表示伺服器已經開始監聽
Start
開始監聽
掛載客戶端連接回調函式
Static IP address: 192.168.0.120

點選電腦開始選單，輸入CMD點回車，出現命令列，在命令列中輸入 :"ping 192.168.0.120"
能ping通，顯示如下：

命令列使用技巧：直接輸入 “help” 可以返回支援的命令，在命令後面輸入 "/?" 可以返回命令的使用說明，比如輸入 “ping /?”
2、TCP伺服器測試
用網路除錯助手連線TCP伺服器（兩者必須在一個閘道器裡面，192.168.000.XXX），網路除錯助手裡選擇TCP客戶端，遠端主機IP為 192.168.0.120 ，埠號為 7，

點選連線，串列埠除錯助手顯示如下資訊：
Start
開始監聽
掛載客戶端連接回調函式
Static IP address: 192.168.0.120
收到客戶端連線請求，設定剛連線的客戶端為最低優先順序
客戶端 IP address: 192.168.0.101
為新連線的客戶端掛載需要的回撥函式及呼叫引數
則表示連線正常，這時網路除錯助手輸出什麼資料就會收到什麼資料，同時串列埠也會輸出相關資訊
網路除錯助手輸出： http://www.cmsoft.cn QQ:10865600
網路除錯助手顯示：【Receive from 192.168.0.120 :7】：http://www.cmsoft.cnQQ:10865600

串列埠除錯助手顯示如下：
Start
開始監聽
掛載客戶端連接回調函式
Static IP address: 192.168.0.120
收到客戶端連線請求，設定剛連線的客戶端為最低優先順序
客戶端 IP address: 192.168.0.101
為新連線的客戶端掛載需要的回撥函式及呼叫引數
收到客戶端資料
裝置剛連線，掛載剛才接收到的資料，設定傳送完成回撥
傳送資料的總長度 : 32
傳送資料：
0X68 0X74 0X74 0X70 0X3A 0X2F 0X2F 0X77 0X77 0X77 0X2E 0X63 0X6D 0X73 0X6F 0X66 0X74 0X2E 0X63 0X6E 0X20 0X51 0X51 0X3A 0X31 0X30 0X38 0X36 0X35 0X36 0X30 0X30

網路除錯助手點選“斷開”按鍵，串列埠除錯助手輸出如下資訊：
Start
開始監聽
掛載客戶端連接回調函式
Static IP address: 192.168.0.120
收到客戶端連線請求，設定剛連線的客戶端為最低優先順序
客戶端 IP address: 192.168.0.101
為新連線的客戶端掛載需要的回撥函式及呼叫引數
收到客戶端資料
裝置剛連線，掛載剛才接收到的資料，設定傳送完成回撥
傳送資料的總長度 : 32
傳送資料：
0X68 0X74 0X74 0X70 0X3A 0X2F 0X2F 0X77 0X77 0X77 0X2E 0X63 0X6D 0X73 0X6F 0X66 0X74 0X2E 0X63 0X6E 0X20 0X51 0X51 0X3A 0X31 0X30 0X38 0X36 0X35 0X36 0X30 0X30
收到客戶端資料
收到斷開連線請求
已關閉連線

通過上面的測試，則表示我們的TCP伺服器已經完成。您也可以通過手機連線這個路由器的WIFI，通過網路除錯助手APP 來連線這個開發板的伺服器，電腦可以通過 TCP客戶端與開發板的TCP伺服器連線同時也可以用手機做TCP客戶端連線開發板的TCP伺服器。

3、TFTP Server 的實現
還是在上面的程式碼上來實現此功能，即在TCP 伺服器的程式碼上實現 TFTP 伺服器。
開啟剛才STM32CubeMX工程，在原來的基礎上來配置 LWIP，配置如下，時能TFTP

點選OK，然後點黃色的齒輪，重新生成程式碼。因為我們之前寫的程式碼要麼是在 /* USER CODE BEGIN X */ 與 /* USER CODE END X */ 中間新增程式碼要麼是在新建的檔案中新增程式碼，所以不會覆蓋之前的程式碼。

生成的程式碼檢視如下：

注意到了嗎？LWIP資料夾下多了一個新的.c，tftp_server.c，既然是在LWIP資料夾下，言外之意就是別人幫我們寫好了，不要動這裡面的檔案內容，相當於庫，但是我們還是要知道去怎麼用。這裡我們之間偷懶，直接開啟tptp_server.h，因為如果要給別的檔案提供功能函式，那麼必須會在.h檔案中存在宣告。開啟tptp_server.h檔案，內容如下：

/** @ingroup tftp
* TFTP context containing callback functions for TFTP transfers
*/
struct tftp_context {
/**
* Open file for read/write.
* @param fname Filename
* @param mode Mode string from TFTP RFC 1350 (netascii, octet, mail)
* @param write Flag indicating read (0) or write (!= 0) access
* @returns File handle supplied to other functions
*/
void* (*open)(const char* fname, const char* mode, u8_t write);
/**
* Close file handle
* @param handle File handle returned by open()
*/
void (*close)(void* handle);
/**
* Read from file
* @param handle File handle returned by open()
* @param buf Target buffer to copy read data to
* @param bytes Number of bytes to copy to buf
* @returns >= 0: Success; < 0: Error
*/
int (*read)(void* handle, void* buf, int bytes);
/**
* Write to file
* @param handle File handle returned by open()
* @param pbuf PBUF adjusted such that payload pointer points
* to the beginning of write data. In other words,
* TFTP headers are stripped off.
* @returns >= 0: Success; < 0: Error
*/
int (*write)(void* handle, struct pbuf* p);
};
err_t tftp_init(const struct tftp_context* ctx);

複製程式碼

裡面就一個 err_t tftp_init(const struct tftp_context* ctx); 從函式名的意思就是初始化，形參是一個結構體指標，而這個結構體裡面定義的全是函式指標，那麼很明確了，這個檔案就是要我們填寫輪子。
我們新建一個檔案 mytftpserverif.c ，這個檔案裡面的內容就是用來寫那些輪子的實現函式，內容如下：

#include "mytftpserverif.h"
#include <string.h>
#include <stdio.h>
#include "main.h"
#include "flash_if.h"
#include "stdlib.h"
#include "string.h"
__packed typedef struct
{
uint8_t InitFlat;
uint8_t W_R_Mode; //讀寫模式 1寫 0讀
uint32_t Flash_Addr ;
}Iap_FlashCont;
static Iap_FlashCont Iapflashcont ;
static void * OpenFile(const char* fname, const char* mode, u8_t write);
static void Close_File(void* handle);
static int Read_File(void* handle, void* buf, int bytes);
static int Write_File(void* handle, struct pbuf* p);
const struct tftp_context tftpContext={ //TFTP SERVER 對接介面
OpenFile,
Close_File,
Read_File,
Write_File,
};
/**
* 開啟檔案返回檔案控制代碼
* @param const char* fname 檔名
* @param const char* mode
* @param u8_t write 模式 1寫 0讀
* @returns 檔案控制代碼
*/
static void * OpenFile(const char* fname, const char* mode, u8_t write)
{
printf("開啟檔案 %s \r\n",fname);
printf("開啟模式 %s \r\n",mode);
Iapflashcont.W_R_Mode = write ;
Iapflashcont.W_R_Mode ? printf("寫檔案\r\n") : printf("讀檔案\r\n");
if(Iapflashcont.W_R_Mode == 1)
{
FLASH_If_Init(); //解鎖
Iapflashcont.Flash_Addr = USER_FLASH_FIRST_PAGE_ADDRESS ; //FLASH起始地址
printf("開始擦除Flash 時間較長 \r\n");
if( FLASH_If_Erase(USER_FLASH_FIRST_PAGE_ADDRESS) == 0 ) //擦除使用者區FLASH資料
{
Iapflashcont.InitFlat =1 ; //標記初始化完成
printf("Write File Init Succes \r\n");
}
} //如果為讀檔案模式
else if(memcmp(fname,"flash.bin",strlen("flash.bin"))==0) //可以讀內部FLASH
{
Iapflashcont.InitFlat =1 ; //標記初始化完成
printf("Read File Init Succes \r\n");
Iapflashcont.Flash_Addr = FLASH_BASE ; //FLASH起始地址
}
return (Iapflashcont.InitFlat) ? (&Iapflashcont) : NULL ; //如果初始化成功返回有效控制代碼
}
/**
* 關閉檔案控制代碼
* @param None
* @param None
* @param None
* @returns None
*/
static void Close_File(void* handle)
{
Iap_FlashCont * Filehandle = (Iap_FlashCont *) handle ;
FLASH_If_UnInit(); //FLASH上鎖
Filehandle->InitFlat = 0 ;
printf("關閉檔案\r\n");
if(Filehandle->W_R_Mode) //如果之前是寫檔案
{
typedef void (*pFunction)(void);
pFunction Jump_To_Application;
uint32_t JumpAddress;
/* Check if valid stack address (RAM address) then jump to user application */
if (((*(__IO uint32_t*)USER_FLASH_FIRST_PAGE_ADDRESS) & 0x2FFE0000 ) == 0x20000000)
{
/* Jump to user application */
JumpAddress = *(__IO uint32_t*) (USER_FLASH_FIRST_PAGE_ADDRESS + 4);
Jump_To_Application = (pFunction)JumpAddress;
/* Initialize user application's Stack Pointer */
__set_MSP(*(__IO uint32_t*) USER_FLASH_FIRST_PAGE_ADDRESS);
Jump_To_Application();
/* do nothing */
while(1);
}
}
}
/**
* 讀取檔案資料
* @param handle 檔案控制代碼
* @param *buf 儲存資料的快取
* @param bytes 讀取的資料長度
* @returns 返回讀取資料長度小於0則錯誤
*/
static int Read_File(void* handle, void* buf, int bytes)
{
Iap_FlashCont * Filehandle = (Iap_FlashCont *) handle ;
printf("讀取檔案資料讀取長度： %ld \r\n",bytes);
if(!Filehandle->InitFlat) //未初始化
{
return ERR_MEM ;
}
uint16_t Count ;
for( Count = 0 ; (Count < bytes)&&(Filehandle->Flash_Addr<=FLASH_END) ; Count++ ,Filehandle->Flash_Addr++ )
{
((uint8_t *)buf)[Count] = *((__IO uint8_t *) Filehandle->Flash_Addr);
}
return Count;
}
/**
* 寫檔案資料
* @param handle 檔案控制代碼
* @param struct pbuf* p 資料快取結構體裡面的資料快取全為實際需要寫入的資料
* @returns 小於0為錯誤
*/
static int Write_File(void* handle, struct pbuf* p)
{
uint16_t Count ;
Iap_FlashCont * Filehandle = (Iap_FlashCont *) handle ;
printf("寫檔案資料資料長度 %ld \r\n",p->len);
if(!Filehandle->InitFlat)
{
printf("寫檔案沒有初始化 \r\n");
return ERR_MEM ;
}
Count = p->len/4 +((p->len%4)>0); //得到要寫入的資料
printf("開始寫FLASH 地址：0X%08X \r\n",Filehandle->Flash_Addr);
if( FLASH_If_Write((__IO uint32_t*)&Filehandle->Flash_Addr,(uint32_t *)p->payload,Count) == 0 )
{
printf("寫FLASH成功下一次地址：0X%08X \r\n",Filehandle->Flash_Addr);
return ERR_OK;
}
else
{
printf("寫FLASH 失敗出錯地址： 0X%08X \r\n",Filehandle->Flash_Addr);
}
return ERR_MEM;
}

複製程式碼這上面的程式碼我都寫了註釋，理解應該難度不大，就是根據tptp_server.h中的結構體實現對應的輪子函式，分別為：
static void * OpenFile(const char* fname, const char* mode, u8_t write);
static void Close_File(void* handle);
static int Read_File(void* handle, void* buf, int bytes);
static int Write_File(void* handle, struct pbuf* p);

mytftpserverif.h檔案內容如下：

#ifndef    _MYTFTPSERVERIF_H_
#define    _MYTFTPSERVERIF_H_
#include "lwip/mem.h"
#include "lwip/udp.h"
#include "lwip/apps/tftp_server.h"
extern const struct tftp_context  tftpContext;
#endif

因為我們是要通過TFTP 來實現 IAP 功能，所有一定有FLASH 的操作，這裡我們之間COPY官方例子的裡面的flash_if.c和flash_if.h，flash_if.c檔案內容如下：

#include "flash_if.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/**
* @brief Unlocks Flash for write access
* @param None
* @retval None
*/
void FLASH_If_Init(void)
{
HAL_FLASH_Unlock();
}
/**
* @brief This function does an erase of all user flash area
* @param StartSector: start of user flash area
* @retval 0: user flash area successfully erased
* 1: error occurred
*/
int8_t FLASH_If_Erase(uint32_t StartSector)
{
uint32_t FlashAddress;
FlashAddress = StartSector;
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
if (FlashAddress <= (uint32_t) USER_FLASH_LAST_PAGE_ADDRESS)

相關推薦

【STM32乙太網線上培訓】手把手搭建TCP伺服器及TFTP伺服器

非常感謝STM32乙太網線上培訓，真的讓我學到非常多，沒培訓前很想搞乙太網但有種無從下手的感覺，經過這次培訓讓我從這個架構上有個從上到下的瞭解，再借助官方神器STM32CubeMX，開發和學習起來還是非常快的！我一直是STM32的粉絲，一直想去現場培訓，但無奈沒有機會，不過好

【碼上微服務】- 環境搭建 - Docker

學習更新 ssl conf 準備 style bash 系統工具 false 一、前言　　本系列針對有一定微服務架構基礎的同僚，寫博主要是為了溝通學習。二、環境準備操作系統：CentOS 7.2 三、Docker安裝使用官方安裝腳本自動安裝（這裏使用了阿裏

【網絡工程師培訓】IPv6：IPv4犯的錯，為什麽讓我來彌補

工程師培訓隨著時也 nat 它的數量技術分享計算器 int 在過去的十年間，IPv6 本來應該得到很大的發展，但事實上這種好事並沒有降臨。　　　　由此導致了一個結果，那就是大部分人都不了解 IPv6 的一些知識：它是什麽，怎麽使用，以及，為什麽它會存在？　　　　

【Mac系統 + Python + Django】之搭建第一個Demo

versions 打開配置 onf demo -s 進入 127.0.0.1 seq 一、首先，用pip安裝Django # 安裝命令 pip install django==1.10.3 安裝路徑為： /Users/zhan/.pyenv/versi

【Inline Hook基礎篇】框架搭建

Windows程式設計師對於HOOK技術應該都很熟悉，HOOK俗稱：鉤子。即將自己想實現的功能，掛鉤到系統的函式上，達到呼叫系統的函式時能自動執行我們實現的功能。對於HOOK，也分為：訊息鉤子，API鉤子，核心鉤子。訊息鉤子和API鉤子都是在應用層（Ring3

【中睿IT培訓】PMP專案管理

PMP專案管理培訓在10月14日完美落幕啦！（授課現場）現代專案管理已發展成為集理念、技術與方法論為一體的專門管理學科。專案管理協會(PMI®)推出的基於專案管理知識體系指南的PMP®(ProjectManagement Professional，專案管理專業人士)考試認證已成為全球公認最權威的專案管

【移動開發與培訓】Linux管理_Linux開發

1024超級勳章授予原創文章總數達

【Spring原始碼解析(一)】Idea搭建Spring原始碼閱讀環境

準備階段 Idea Gradle Git jdk 詳細步驟以上工具安裝好，這裡主要記錄一下Git和Gradle，工作一直都是用的svn和Maven，所以對於Git和Gradle瞭解的不算多。 (1) Gradle安裝 Gradle的安裝很簡單，和

【HTML5學習筆記一】環境搭建和需要掌握的技能

初學HTML5，特此寫一些學習筆記，記錄自己的成長。一、開發環境 1.安裝JDK（現在暫時還沒用到，估計以後會用到）。 2.配置環境變數 2.1.新建JAVA_H

【華為線上筆試】字串解壓縮

題目描述將一段壓縮後的字串解壓縮，並且排序輸出。解壓規則：每個字串後面跟著一個數字，表示這個字串的重複次數。例如，”a5”解壓後的結果為”aaaaa”；’abc3’解壓後的結果為”abcabcabc”。排序規則： 1、根據每個字串的重複次數升序

【STM32小案例 07 】STM32完美可用的延時程式，自用延時程式庫，直接呼叫

前面的案例中有很多的小夥伴都私信我關於delay_other.c和delay_other.h標頭檔案的原始碼。在這裡就直接分享出來。 ---------------------------------------------------------------------

【騰訊雲】自己搭建的騰訊雲伺服器JavaEE環境

轉載地址：https://www.cnblogs.com/qlqwjy/p/8727487.html 感覺很專業的樣子，還沒有看完，更沒有實踐，找個機會實踐一下。 0.安裝SSH登入 1.生成公鑰對 ssh-keygen -t rsa -P '' -P表示密

【django介面自動化1】環境搭建

目錄一、下載python 二、下載pycharm 三、sudo pip install django 四、django-project目錄詳解 cs/__init__.py:一個空的檔案，用它標識一個目錄為 P

【STM32小案例 03 】實現DHT11,BH1750,GP2Y與0.96寸OLED的動態顯示

現在可以用DHT11採集溫溼度,BH1750採集光照,GP2Y採集PM2.5,再把資訊傳送至OLED螢幕和串列埠. 開發流程與思路： 1. 配置DHT11的TLL引腳通訊，因為DHT11的韌體庫都封

【stm32+uC/OS-II】ucosii移植簡單詳細步驟

μC/OS-II由Micrium公司提供，是一個可移植、可固化的、可裁剪的、佔先式多工實時核心，它適用於多種微處理器，微控制器和數字處理晶片（已經移植到超過100種以上的微處理器應用中）。同時，該系統原始碼開放、整潔、一致，註釋詳盡，適合系統開發。 μC/OS-II

【STM32 IIC詳解】stm32 IIC從機模式(中斷方式收發資料)

1、IIC簡介第二節程式碼會用到該部分內容，對於IIC來說，從機是不能主動傳送資料的，開始條件都是由主機生成。 1.1、主機發送資料流程 1) 主機在檢測到匯流排為“空閒狀態”（即 SDA、SCL 線均為高電平）時，傳送一個啟動訊號

【程式設計師面試系列】手把手教你如何面試：面試過程（一）

作者：Dimple Solgan：當你的才華還無法撐起你的野心時候，那應該靜下心來好好學習公號：奔跑吧攻城獅在之前【程式設計師面試系列】中，我們通過簡歷、技術、工作專案三個維度來說明，我們需要如何做好充分的準備工作。良好的開端是成功的一半，只有做好了前面的準備，我們才有進一步的底氣去投遞簡歷

【小白學PyTorch】1 搭建一個超簡單的網路

文章目錄： [TOC] ## 1 任務首先說下我們要搭建的網路要完成的學習任務：讓我們的神經網路學會邏輯異或運算，異或運算也就是俗稱的“相同取0，不同取1” 。再把我們的需求說的簡單一點，也就是我們需要搭建這樣一個神經網路，讓我們在輸入（1,1）時輸出0，輸入（1,0）時輸出1（相同取0，不同取1），

Spring（三）--AOP【面向切面編程】、通知類型及使用、切入點表達式

1.3 一聲重復信息術語臃腫 lib pac fin 1.概念：Aspect Oriented Programming 面向切面編程在方法的前後添加方法 2.作用：本質上來說是一種簡化代碼的方式繼承機制封裝方法動態代理

【Cocos2d-HTML5 開發之一】新建HTML5項目及簡單闡述與cocos2d/x引擎關系

分公司文件名真的參數部分 cocos2d-x -c js代碼防止真的是有一段時間沒寫博了，這段時間呢，發生的事情真的挺多，另外自己呢也閑來做了一些自己的喜歡的東西，主要做的還是基於Mac系統的Cocoa框架的各種編輯器吧。（對了，今年初也出了自己第二本書《
搜尋

基礎教學

Mysql入門 Sql入門 Android入門 Docker入門 Go語言入門 Ruby程式入門 Python入門 Python進階 Django入門 Python爬蟲入門
最近訪問
首頁
前端設計
程式設計
免費資源
實用技巧
資料庫
資訊
字典

Copyright © 2002-2020 程式人生 796T.COM All rights reserved.

【STM32乙太網線上培訓】手把手搭建TCP伺服器及TFTP伺服器

相關推薦