C#制作STM32上位机升级工具（基于Modbus协议）

思路很简单，C#制作一个上位机工具，将读取的bin文件通过串口下发至单片机，一帧数据包含：7字节的Modbus协议帧头+200字节数据更新包（最后一帧少于等于200字节）+2字节的CRC校验码。单片机在boot中解析协议，协议解析无误后，将数据更新包写入Flash中，然后返回特定的数据。上位机根据返回的数据判断本次数据是否写入成功，如果写入成功继续下发新的更新包，如果写入失败重复发送本次更新包。通讯间隔100ms。

开发环境：Visio Studio 2015

一.新建windows窗体应用程序：

​

二.绘制基本界面：

​

在工具箱中的公共控件下找到以下三个控件Label、ComboBox、Button，拖拽到Form中。鼠标点击控件后可以在属性栏中修改控件的相应属性。

​  

选中修改串口波特率对应的CommboBox控件，点击Items属性，输入相应的波特率值，保存。其他控件的属性就是改改名字，外形大小、颜色等。

​

然后再放两个TextBox控件显示加载信息等，以及几个按钮。最后界面如下：

​

三.添加串口控件以及文件对话框：

在工具箱中找打组件下的SerialPort控件，也就是串口控件；对话框下的OpenFileDialog控件，拖拽到Form下的空区域中

​ ​

现在所用到的控件都已经加到窗体中了，基本工作已经完成了。接下来开始撸代码了。

四.代码撸起来

1.搜索可用串口，并显示在CommboBox中显示串口名称。双击搜索端口按钮，会自动跳转到代码编辑处，在button_Clik事件函数下添加更新端口的函数。

1.         private void button2_Click(object sender, EventArgs e)
   
2.         {
   
3.             string[] ArryPort = System.IO.Ports.SerialPort.GetPortNames();
   
4. 
   
5.             comboBox2.Items.Clear();
   
6. 
   
7.             for (int i = 0; i < ArryPort.Length; i++)
   
8.             {
   
9.                 comboBox2.Items.Add(ArryPort[i]);
   
10.             }
    
11.         }

复制代码

2.打开/关闭串口。双击启用端口按钮，加入以下代码。

1.         private void button1_Click(object sender, EventArgs e)
   
2.         {
   
3.             if (button1.Text == "启用端口")
   
4.             {
   
5.                 try
   
6.                 {
   
7.                     serialPort1.PortName = comboBox2.Text;
   
8.                     serialPort1.Open();
   
9.                     comboBox2.Enabled = false;
   
10.                     button2.Enabled = false;
    
11.                     button1.Text = "关闭端口";
    
12.                 }
    
13.                 catch
    
14.                 {
    
15.                     System.Media.SystemSounds.Beep.Play();
    
16.                     MessageBox.Show("端口打开失败", "错误");
    
17.                 }
    
18.             }
    
19.             else
    
20.             {
    
21.                 try
    
22.                 {
    
23.                     serialPort1.Close();
    
24.                     button2.Enabled = true;
    
25.                     comboBox2.Enabled = true;
    
26.                     button1.Text = "启用端口";
    
27.                 }
    
28.                 catch
    
29.                 {
    
30.                     System.Media.SystemSounds.Beep.Play();
    
31.                     MessageBox.Show("关闭串口失败", "错误");
    
32.                 }
    
33.             }
    
34.         }

复制代码

3.修改串口波特率。双击串口波特率对应的CommboBox，加入以下代码。

1.         private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
   
2.         {
   
3.             serialPort1.BaudRate = Convert.ToInt32(comboBox1.Text);
   
4.         }

复制代码

4.在Form1_Load中创建串口接收线程，并且初始化串口波特率，串口的其他参数配置使用默认即可。串口接收也可以使用数据接收事假，类似于STM32的串口接收中断。下面的代码是创建串口接收线程，以线程的方式接收串口数据。

1.         private void Form1_Load(object sender, EventArgs e)
   
2.         {
   
3.             serialPort1.BaudRate = 115200;
   
4.             comboBox1.Text = "115200";
   
5. 
   
6.             Thread ReadSerialPort = new Thread(new                     
   
7.             ParameterizedThreadStart(SerialPortReadThread));
   
8.             ReadSerialPort.IsBackground = true;
   
9.             ReadSerialPort.Start();
   
10.         }

复制代码

如果使用事件的方式接收数据，按一下步骤操作即可：

​

5.打开.bin文件。双击文件按钮，加入以下代码：

1.         string BinText;
   
2.         OpenFileDialog MyFileDialog;
   
3.         private void button7_Click(object sender, EventArgs e)
   
4.         {
   
5.             BinText = "";
   
6. 
   
7.             MyFileDialog = new OpenFileDialog();
   
8.             MyFileDialog.InitialDirectory =              
   
9.             Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
   
10.             MyFileDialog.Filter = @"|*.bin";
    
11.             if (MyFileDialog.ShowDialog() == DialogResult.OK)
    
12.             {
    
13.                 string filePath = MyFileDialog.FileName;
    
14.                 FileStream Myfile = new FileStream(filePath,FileMode.Open,FileAccess.Read);
    
15.                 BinaryReader binreader = new BinaryReader(Myfile);
    
16.                 MyPublicPara.FileLength = (int)Myfile.Length;//获取bin文件长度
    
17.                 MyPublicPara.Binchar = binreader.ReadBytes((int)Myfile.Length);
    
18.                 textBox4.Text = MyFileDialog.SafeFileName;
    
19.                 textBox4.Text += "  "+Myfile.Length+"Byte\r\n\r\n";
    
20.             }
    
21.         }

复制代码

到这一步，我们已经可以打开串口、打开指定的bin文件了，接下来就是通过串口把bin文件发出去。

6.发送bin文件。

点击开始更新按钮，加入以下代码：

1.         public delegate void ClearProgressValue();
   
2.         Progress progressForm;
   
3.         List<Progress> ListForm = new List<Progress>();     //创建窗体集合
   
4.         private void button8_Click(object sender, EventArgs e)
   
5.         {
   
6.             byte[] SysRestar_CMD = { 0x01, 0x10, 0x36, 0x51, 0x00, 0x02, 0x04, 0x13, 0x52, 0x00, 0x62, 0x00, 0x00 };
   
7. 
   
8.             ushort crc_value = ModbusCRC16(SysRestar_CMD, 13);
   
9.             SysRestar_CMD[11] = (byte)((crc_value >> 8) & 0xff);
   
10.             SysRestar_CMD[12] = (byte)(crc_value & 0xff);
    
11.             if (serialPort1.IsOpen)
    
12.                 serialPort1.Write(SysRestar_CMD, 0, 13);
    
13. 
    
14.             textBox5.Text = "";
    
15.             BinText = "";
    
16.             MyPublicPara.UpdataCount = 0;
    
17.             progressForm = new Progress();
    
18.             progressForm.StartPosition = FormStartPosition.CenterScreen;
    
19. 
    
20.             if (ListForm.Count != 0)
    
21.             {
    
22.                 ListForm[0].Close();
    
23.                 ListForm.Clear();
    
24.             }   
    
25.             progressForm.Show();
    
26.             ListForm.Add(progressForm);                 //将更新进度窗体加入集合中
    
27. 
    
28.             button8.Enabled = false;
    
29.             Delay(2000);
    
30.             if ((MyPublicPara.FileLength > 10000) && (MyPublicPara.FileLength < 100000) && (serialPort1.IsOpen))
    
31.             {
    
32.                 Thread SendReadFile = new Thread(new ParameterizedThreadStart(SendBinFileThread));//创建下发更新文件线程
    
33.                 SendReadFile.IsBackground = true;
    
34.                 SendReadFile.Start();//启动线程
    
35.             }
    
36.         }

复制代码

开始更新后，先下发一个复位指令，让单片机复位进入boot程序，延迟2s后创建下发bin文件的线程，开始更新。指令格式按照modbus协议，不清楚modbus协议的百度之。这里提供一个modbus的16位CRC校验计算公式，可以用来计算或者校验一帧数据的CRC，如下：

1.         public static ushort ModbusCRC16(byte[] data,int length)
   
2.         {
   
3.             int len = length - 2;
   
4.             ushort crc_value = 0xFFFF;
   
5. 
   
6.             for (int i = 0; i < len; i++)
   
7.             {
   
8.                 crc_value ^= (ushort)data[i];
   
9.                 for (int j = 8; j != 0; j--)
   
10.                 {
    
11.                     if ((crc_value & 0x0001) != 0)
    
12.                     {
    
13.                         crc_value >>= 1;
    
14.                         crc_value ^= 0xA001;
    
15.                     }
    
16.                     else
    
17.                     {
    
18.                         crc_value >>= 1;
    
19.                     }
    
20.                 }
    
21.             }
    
22. 
    
23.             return crc_value = (ushort)(((crc_value & 0x00ff) << 8) | ((crc_value & 0xff00) >> 8));
    
24.         }

复制代码

7.开始下发bin文件。

1.   /*------------------------------------------------------------------------------------------
   
2.          *  函数名称：Updata(object length)
   
3.          *  描    述：下发.BIN文件
   
4.          *  输    入：无
   
5.          *  输    出：无
   
6.          * ----------------------------------------------------------------------------------------*/  
   
7.         public delegate void SendBin();
   
8.         public void Updata()
   
9.         {
   
10.             int TxCount = 0;
    
11.             int i = 0;
    
12.             byte[] Updata_CMD = new byte[256];
    
13.             Updata_CMD[TxCount++] = 0x01;
    
14.             Updata_CMD[TxCount++] = 0x10;
    
15.             Updata_CMD[TxCount++] = 0x26;
    
16.             Updata_CMD[TxCount++] = 0X54;
    
17.             Updata_CMD[TxCount++] = 0x00;
    
18. 
    
19.             if(MyPublicPara.UpdataCount < (MyPublicPara.FileLength / 200))
    
20.             {
    
21.                 Updata_CMD[TxCount++] = 0X64;
    
22.                 Updata_CMD[TxCount++] = 0xC8;
    
23. 
    
24.                 for (i = 0; i < 200; i++)
    
25.                 {
    
26.                     Updata_CMD[TxCount++] = MyPublicPara.Binchar[MyPublicPara.UpdataCount * 200+i];
    
27.                 }
    
28.             }
    
29.             else if (MyPublicPara.UpdataCount == (MyPublicPara.FileLength / 200))
    
30.             {
    
31.                 Updata_CMD[TxCount++] = (byte)((MyPublicPara.FileLength - 200 * MyPublicPara.UpdataCount) / 2);
    
32.                 Updata_CMD[TxCount++] = (byte)(Updata_CMD[5] * 2);
    
33. 
    
34.                 for (i = 0; i < (MyPublicPara.FileLength-(MyPublicPara.FileLength / 200)*200); i++)
    
35.                 {
    
36.                     Updata_CMD[TxCount++] = MyPublicPara.Binchar[MyPublicPara.UpdataCount * 200 + i];
    
37.                 }
    
38. 
    
39.                 MyPublicPara.UpdataCount = (MyPublicPara.FileLength / 200) + 1;        //已经更新到最后一帧
    
40.             }
    
41. 
    
42.             ushort crc_value = ModbusCRC16(Updata_CMD, TxCount);
    
43.             Updata_CMD[TxCount++] = (byte)((crc_value >> 8) & 0xff);
    
44.             Updata_CMD[TxCount++] = (byte)(crc_value & 0xff);
    
45. 
    
46.             if (serialPort1.IsOpen)
    
47.                 serialPort1.Write(Updata_CMD, 0, TxCount);
    
48. 
    
49.             CMD_TO_SEND = (ushort)command.UPDATA_CMD;
    
50. 
    
51.             for (i = 0; i < TxCount; i++)
    
52.             {
    
53.                 BinText += Updata_CMD[i].ToString("X2") + " ";
    
54.             }
    
55.             UpdataMessageToShow(BinText + "\r\n");
    
56.             BinText = "";
    
57.         }
    
58. 
    
59.         /*------------------------------------------------------------------------------------------
    
60.          *  函数名称：SendBinFileThread(object length)
    
61.          *  描    述：下发更新固件线程
    
62.          *  输    入：无
    
63.          *  输    出：无
    
64.          * ----------------------------------------------------------------------------------------*/
    
65.         public delegate void Button8Click();
    
66.         private void Button8Enable()
    
67.         {
    
68.             button8.Enabled = true;
    
69.         }
    
70.         public void SendBinFileThread(object length)
    
71.         {
    
72.             while (MyPublicPara.UpdataCount <= ((MyPublicPara.FileLength / 200)))
    
73.             {
    
74.                 this.Invoke(new SendBin(Updata));
    
75. 
    
76.                 Thread.Sleep(100);
    
77.             }
    
78.             this.Invoke(new Button8Click(Button8Enable));
    
79.             MyPublicPara.UpdataCount = 0;
    
80.         }

复制代码

前面说了，下发bin文件时在线程中完成的，点击开始更新按钮时创建了一个下发bin文件的线程。为了在下发更新文件时不影响界面的流程度，我们使用了线程委托的方式 public delegate void SendBin()。

8.有发有回。

STM32更新固件一定要小心，有一个字节写入错误就可能导致更新失败，更新完毕后死机等等。所以必须上位机必须校验单片机的返回数据，只有返回数据校验正确后，才继续下发新的更新内容，否则一直下发本次更新内容，直至校验正取。加入串口读取并解析的线程：

1. /*------------------------------------------------------------------------------------------
   
2.          *  函数名称：SerialPortRead()
   
3.          *  描    述：读取串口函数
   
4.          *  输    入：无
   
5.          *  输    出：无
   
6.          * ----------------------------------------------------------------------------------------*/
   
7.         public delegate void SerialPortReDelegate();
   
8.         public delegate void addProgress();
   
9.         public void SerialPortRead()
   
10.         {
    
11.             if (serialPort1.IsOpen)
    
12.             {
    
13.                 int RxLength = serialPort1.BytesToRead;
    
14.                 byte[] ReceiveData = new byte[RxLength];
    
15.                 serialPort1.Read(ReceiveData, 0, RxLength);
    
16.                 ushort crc_value = ModbusCRC16(ReceiveData, RxLength);
    
17. 
    
18. 
    
19.                 if ((RxLength >= 8) && (crc_value == ((ushort)(ReceiveData[RxLength - 2] << 8) | ReceiveData[RxLength - 1])))
    
20.                 {
    
21.                     if (CMD_TO_SEND == (UInt16)command.UPDATA_CMD)
    
22.                     {
    
23.                         MyPublicPara.UpdataCount++;
    
24.                         CMD_TO_SEND = (UInt16)command.OK;
    
25.                         this.Invoke(new addProgress(progressForm.AddProgress));
    
26. 
    
27.                     }
    
28.                 }
    
29.                
    
30.                 RxLength = 0;
    
31.             }
    
32.         }
    
33. 
    
34.         /*------------------------------------------------------------------------------------------
    
35.          *  函数名称：SerialPortReadThred()
    
36.          *  描    述：串口读取线程
    
37.          *  输    入：无
    
38.          *  输    出：无
    
39.          * ----------------------------------------------------------------------------------------*/
    
40.         public void SerialPortReadThread(object length)
    
41.         {
    
42.             while (true)
    
43.             {
    
44.                 this.Invoke(new SerialPortReDelegate(SerialPortRead));
    
45.                 Thread.Sleep(1);
    
46.             }
    
47.         }

复制代码

C#中使用指针不是很方便，所以程序中用MyPublicPara.UpDataCount这个变量代替指针指向bin文件中的元素，只有在本次更新成功后，MyPublicPara.UpDataCount才指向下一待更新的数据包，每次更新更新的数据包大小为200字节，如果最后一包数据不够200字节就把剩下的数据作为1包发送出去，选用200字节的大小，因为stm32在写入flash时是以字或半字写入的，所以数据包大小必须为4的整数倍。

到这儿这个小工具基本完成了，最后还可以再添加一个ProgressBar控件用来指示当前的更新进度。

9.指示当前更新进度。

右键>>添加>>新建项，选择window窗体。

​

在这个窗体中加入一个ProgressBar控件，和一个Label控件，用于显示更新进度，如下：

​

双击窗体，在load时间中加入以下代码，就是设置ProgressBar的最大值=bin文件长度/200，因为我们是以200字节大小下发一次更新数据的，所以ProgressBar最大值就是更大的更新次数。

1.         private void Progress_Load(object sender, EventArgs e)
   
2.         {
   
3.             label1.Text = "0%";
   
4.             progressBar1.Maximum = Form1.MyPublicPara.FileLength/200;
   
5.             Form1.MyPublicPara.ProgressOpened = 1;
   
6.         }

复制代码

在Progress命名空间下加入以下代码：

1. private delegate void Label1SetText(string text);
   
2.         private void labelSetText(string text)
   
3.         {
   
4.             if (this.label1.InvokeRequired)
   
5.             {
   
6.                 Label1SetText d = new Label1SetText(labelSetText);
   
7.                 this.Invoke(d, new object[] { text });
   
8.             }
   
9.             else
   
10.             {
    
11.                 this.label1.Text = text;
    
12.             }
    
13.         }
    
14. 
    
15.         public void AddProgress()
    
16.         {
    
17.             if (progressBar1.Value < progressBar1.Maximum)
    
18.             {
    
19.                 progressBar1.Value++;
    
20.             }
    
21.             labelSetText(((progressBar1.Value * 100) / progressBar1.Maximum).ToString() + "%");
    
22.         }

复制代码

为了避免ProgressBar控件再载入的过程中影响界面的流畅度，同样使用了委托来更新Label的值和ProgressBar的进度。

到这儿，基本完成了小工具的制作，下面就可以愉快的更新啦。

​

感谢楼主分享

厉害，谢谢分享，请问可以发一下完整项目学习学习？

嗯，楼主步骤很详细，堪称经典教程

这个写的太牛了。     

串口写入的吗      

读写二进制的文件不容易  

C#这么给力吗？         

串口是自己写的吗   

以前都是使用的别人的弄的。  

读取的bin文件通过串口下发至单片机，怎么校验呢   

给力，谢谢楼主的资料。      

Modbus协议？   

根据返回的数据怎么判断是否正确呢   

楼主很牛啊。        

            

使用串口软件了吗      

怎么自动对波特率呢 ?     

没想到还能自己写代码呢

楼主步骤很详细