.Net Micro Framework研究—串口操作

试验平台:Digi MF开发板

Digi提供的示例中包含了串口的示例程序,主要代码如下:


 

  1. public bool EchoByte()  
  2.  
  3.         {  
  4.  
  5.             SerialPort serial;  
  6.  
  7.             bool exceptionRaised = false;  
  8.  
  9.             bool testResult = true;  
  10.  
  11.             string message = " This is an echo test.  Enter the character to echo, or ESC to exit. ";  
  12.  
  13.             byte[] encodedMessage = c_encoding.GetBytes(message);  
  14.  
  15.             byte[] buffer = new byte[1];  
  16.  
  17.             try 
  18.  
  19.             {  
  20.  
  21.                 serial = new SerialPort(new SerialPort.Configuration(Cpu.Serial.COM1, Cpu.BaudRate.Baud115200, false));  
  22.  
  23.    
  24.  
  25.                 serial.Write(encodedMessage, 0, message.Length);  
  26.  
  27.    
  28.  
  29.                 while (buffer[0] != 0x1b)  
  30.  
  31.                 {  
  32.  
  33.                     serial.Read(buffer, 0, buffer.Length, Timeout.Infinite);  
  34.  
  35.                     serial.Write(buffer, 0, buffer.Length);  
  36.  
  37.                 }  
  38.  
  39.    
  40.  
  41.                 serial.Dispose();  
  42.  
  43.             }  
  44.  
  45.             catch 
  46.  
  47.             {  
  48.  
  49.                 exceptionRaised = true;  
  50.  
  51.             }  
  52.  
  53.             if (exceptionRaised == true)  
  54.  
  55.                 testResult = false;  
  56.  
  57.             return testResult;  
  58.  
  59.         }  
  60.  
  61.  
  62.  

 

部署运行后,你可以用超级终端进行测试,测试图如下:

 

 .Net Micro Framework研究—串口操作_串口


(图MF10280001.JPG)

注意:如果串口程序非正常退出,有可能导致开发板无法发送数据(接收倒是正常),重启开发板即可。

 

用测试程序还是体现不出.Net Micro Framework的优势,我决定用MF实现Modbus Rtu Slave服务端(支持Modbus Rtu 3号命令),并且地址为0的数据存放了GPIO入的信息,这样在上位机就很方面的检测IO信号了。

 

用了大约15分钟,就把我以前用C++开发的Modbus Rtu Slave程序移植到MF平台上来的,我想如果用单片来开发,虽然也有可能借用以前的代码,但很方便的把IO信号也非常快捷的集成进来,恐怕不容易。

 

值得一提的是VS2005 的调试功能非常强大,很容易添加断点及监控当前变量的值,同时用debug.print()命令也非常好使,这样调试程序绝对比调试单片舒服。

 

下面贴出我写的Modbus RtuSlave代码

 

  1. using System;  
  2. using Microsoft.SPOT;  
  3. using System.Threading;  
  4. using Microsoft.SPOT.Hardware;  
  5.  
  6. namespace MFModbus  
  7. {  
  8.     public class ModbusRtu  
  9.     {  
  10.         private Thread m_worker;  
  11.         private bool m_RunFlag;  
  12.  
  13.         private byte bytRtuDataFlag=0;  
  14.         private byte bytRtuDataIdx;  
  15.         private byte[] bytRtuData = new byte[8];  
  16.  
  17.         //设备地址,默认为1      
  18.         private byte ModbusAddr = 1;  
  19.         //数据区(注意,Modbus读写是以字(双字节)为单位的)  
  20.         private byte[] DataBuff = new byte[128];  
  21.  
  22.         SerialPort serial = null;  
  23.  
  24.         InputPort[] input = new InputPort[5];  
  25.         Cpu.Pin[] pin = new Cpu.Pin[5] { (Cpu.Pin)0, (Cpu.Pin)1, (Cpu.Pin)2, (Cpu.Pin)5, (Cpu.Pin)6 };  
  26.  
  27.         public ModbusRtu(byte mModbusAddr)  
  28.         {  
  29.             ModbusAddr=mModbusAddr;  
  30.             for (int i = 0; i < 5; i++)  
  31.             {  
  32.                 input[i] = new InputPort(pin[i], false, Port.ResistorMode.PullUp);  
  33.             }  
  34.         }  
  35.  
  36.         ~ModbusRtu()  
  37.         {  
  38.             Stop();  
  39.         }  
  40.  
  41.         //CRC16校验  
  42.         private UInt16 GetCheckCode(byte[] buf, int nEnd)  
  43.         {  
  44.             UInt16 crc = (UInt16)0xffff;  
  45.             int i, j;  
  46.             for (i = 0; i < nEnd; i++)  
  47.             {  
  48.                 crc ^= (UInt16)buf[i];  
  49.                 for (j = 0; j < 8; j++)  
  50.                 {  
  51.                     if ((crc & 1) != 0)  
  52.                     {  
  53.                         crc >>= 1;  
  54.                         crc ^= 0xA001;  
  55.                     }  
  56.                     else 
  57.                         crc >>= 1;  
  58.                 }  
  59.             }  
  60.             return crc;  
  61.         }  
  62.  
  63.         //启动Modbus服务  
  64.         public void Run()  
  65.         {  
  66.             try 
  67.             {  
  68.                 //仅有波特率选项,竟然没有奇偶校验控制  
  69.                 serial = new SerialPort(new SerialPort.Configuration(Serial.COM1, BaudRate.Baud9600, false));  
  70.                 Debug.Print("Open Serial OK");  
  71.                 m_worker = new Thread(new ThreadStart(this.ModbusThreadProc));  
  72.                 m_RunFlag = true;  
  73.                 m_worker.Start();  
  74.             }  
  75.             catch 
  76.             {  
  77.                 Debug.Print("Serial Error");  
  78.             }             
  79.         }  
  80.  
  81.         //停止Modbus服务  
  82.         public void Stop()  
  83.         {  
  84.             m_RunFlag = false;  
  85.             if (serial != null)  
  86.                 serial.Dispose();  
  87.         }  
  88.  
  89.         //Modbus Slave服务  
  90.         private void ModbusThreadProc()  
  91.         {  
  92.             Debug.Print("Start Modbus Slave");  
  93.             byte[] bytData=new byte[1];  
  94.             while (m_RunFlag)  
  95.             {  
  96.                 serial.Read(bytData, 0, bytData.Length, Timeout.Infinite);  
  97.                 RtuSlave(bytData[0]);  
  98.             }  
  99.         }  
  100.         //串口数据处理  
  101.         private void RtuSlave(byte bytData)  
  102.         {  
  103.             //Debug.Print(bytRtuDataIdx.ToString() + " - " + bytData.ToString());  
  104.             if (bytRtuDataFlag == 0)  
  105.             {  
  106.                 //如果数据为首地址  
  107.                 if (bytData == ModbusAddr)  
  108.                 {  
  109.                     bytRtuDataFlag = 1;  
  110.                     bytRtuDataIdx = 0;  
  111.                     bytRtuData[bytRtuDataIdx++] = bytData;  
  112.                 }  
  113.             }  
  114.             else 
  115.             {  
  116.                 bytRtuData[bytRtuDataIdx++] = bytData;  
  117.                 if (bytRtuDataIdx >= 8)  
  118.                 {  
  119.                     //信息处理  
  120.                     UInt16 intCRC16 = GetCheckCode(bytRtuData, 8 - 2);  
  121.  
  122.                     //Debug.Print("CRC:" + bytRtuData[8 - 2].ToString() + " " + ((byte)(intCRC16 & 0xFF)).ToString() +"|" + bytRtuData[8 - 1].ToString() + " " + ((byte)((intCRC16 >> 8) & 0xff)).ToString());  
  123.                     //CRC16校验检验  
  124.                     if (bytRtuData[8 - 2] == (intCRC16 & 0xFF) && bytRtuData[8 - 1] == ((intCRC16 >> 8) & 0xff))  
  125.                     {  
  126.                         byte[] bytSendData = new byte[255];  
  127.                         byte bytErrorFlag = 0;  
  128.                         byte bytErrorNo = 1;  
  129.  
  130.                         //Debug.Print("CRC OK");  
  131.                         //读数据  
  132.                         if (bytRtuData[1] == 3)  
  133.                         {  
  134.                             UInt16 lngDataAddr = bytRtuData[2];  
  135.                             lngDataAddr = (UInt16)((lngDataAddr << 8) + bytRtuData[3]);  //地址  
  136.                             UInt16 lngDataNum = bytRtuData[4];  
  137.                             lngDataNum = (UInt16)((lngDataNum << 8) + bytRtuData[5]);    //数量  
  138.  
  139.                             if (lngDataAddr * 2 + lngDataNum * 2 > 1024 || lngDataNum > 120)  
  140.                             {  
  141.                                 bytErrorNo = 2;  
  142.                                 bytErrorFlag = 0;  
  143.                             }  
  144.                             else 
  145.                             {  
  146.                                 bytSendData[0] = bytRtuData[0];  
  147.                                 bytSendData[1] = bytRtuData[1];  
  148.                                 bytSendData[2] = (byte)(lngDataNum * 2);  
  149.  
  150.                                 //读GPIO信号  
  151.                                 DataBuff[0] = 0;  
  152.                                 DataBuff[1] = (byte)((input[0].Read() ? 1 : 0) | (input[1].Read() ? 2 : 0) | (input[2].Read() ? 4 : 0) | (input[3].Read() ? 8 : 0) | (input[4].Read() ? 16 : 0));  
  153.                                   
  154.                                 for (int i = 0; i < bytSendData[2]; i++)  
  155.                                 {  
  156.                                     bytSendData[3 + i] = DataBuff[lngDataAddr * 2 + i];  
  157.                                 }  
  158.                                 intCRC16 = GetCheckCode(bytSendData, 3 + lngDataNum * 2);  
  159.                                 bytSendData[3 + lngDataNum * 2] = (byte)(intCRC16 & 0xFF);                    //CRC校验低位  
  160.                                 bytSendData[4 + lngDataNum * 2] = (byte)((intCRC16 >> 8) & 0xff);             //CRC校验高位                    
  161.  
  162.                                 //发送数据  
  163.                                 int intRet=serial.Write(bytSendData, 0, 5 + lngDataNum * 2);  
  164.  
  165.                                 //Debug.Print("SendData OK " + intRet.ToString() );  
  166.                                 bytErrorFlag = 1;  
  167.                             }  
  168.                         }  
  169.  
  170.                         if (bytErrorFlag == 0)  
  171.                         {  
  172.                             //协议不支持  
  173.                             bytSendData[0] = bytRtuData[0];  
  174.                             bytSendData[1] = (byte)(bytRtuData[1] | 0x80);  
  175.                             bytSendData[2] = bytErrorNo;  
  176.  
  177.                             intCRC16 = GetCheckCode(bytSendData, 3);  
  178.                             bytSendData[3] = (byte)(intCRC16 & 0xFF);                       //CRC校验低位  
  179.                             bytSendData[4] = (byte)((intCRC16 >> 8) & 0xff);                //CRC校验高位  
  180.  
  181.                             //发送数据  
  182.                             serial.Write(bytSendData, 0, 5);  
  183.                         }  
  184.                     }  
  185.                     bytRtuDataFlag = 0;  
  186.                 }  
  187.             }  
  188.             return;  
  189.         }  
  190.  
  191.         //串口号  
  192.         public static class Serial  
  193.         {  
  194.             public const SerialPort.Serial COM1 = (SerialPort.Serial)0;  
  195.             public const SerialPort.Serial COM2 = (SerialPort.Serial)1;  
  196.         }  
  197.  
  198.         //串口波特率  
  199.         public static class BaudRate  
  200.         {  
  201.             public const SerialPort.BaudRate Baud4800 = (SerialPort.BaudRate)4800;  
  202.             public const SerialPort.BaudRate Baud9600 = (SerialPort.BaudRate)9600;  
  203.             public const SerialPort.BaudRate Baud19200 = (SerialPort.BaudRate)19200;  
  204.             public const SerialPort.BaudRate Baud38400 = (SerialPort.BaudRate)38400;  
  205.             public const SerialPort.BaudRate Baud57600 = (SerialPort.BaudRate)57600;  
  206.             public const SerialPort.BaudRate Baud115200 = (SerialPort.BaudRate)115200;  
  207.             public const SerialPort.BaudRate Baud230400 = (SerialPort.BaudRate)230400;  
  208.         }  
  209.     }  
  210. }  
  211.  

 

程序部署运行后,直接用标准的Modbus Rtu客户端程序测试即可,我用的是我以前编写的Modbus Rtu Client程序,测试如下:

 

 .Net Micro Framework研究—串口操作_Net_02

 (图MF10280002.JPG)


这时候,你直接操作SW2的拨码,该数字就会发生变化(前提SW1的拨码都拨到右边)。

 

缺点:很奇怪的是串口的参数仅能配置波特率,奇偶校验,数据位却无法配置。

 

总的印象:用MF开发嵌入式系统还是非常有前景的,至少使产品的开发周期大大缩短,并且代码升级维护方便。