C structure use

Upper computer （C#） It needs to transmit data with MCU through serial port , I also stepped on several pits before realizing this function , Time is in a hurry , Scribbled , There are unclear questions to ask .

The interface and data format have been defined on the single chip microcomputer （ structure ）

Processing method on upper computer ：

1、 Serial port received byte Array , Press the subscript to get

If the data structure is single, this method is not impossible , If there are many data structures , The structure is large Then we need to calculate the subscript carefully , Otherwise, it is easy to have problems , And it's not easy to maintain .

for example ：

private void sp_DataReceived(object sender, EventArgs e)
            {
            SerialPort sp1 = (SerialPort)sender;
            if (sp1.IsOpen)     // Judge whether to open the serial port 
            {
                try
                {
                    if (this.InvokeRequired) // Add thread to prevent fake death 
                    {
                        this.Invoke(new MethodInvoker(delegate
                        {
                            int int_len = sp1.BytesToRead;
                            byte[] b = new byte[sp1.BytesToRead];

                            sp1.Read(b, 0, b.Length); // byte 

                            myBuffer.AddRange(b);


                            while (myBuffer.Count >= 15)// At least equal to the header length 
                            {

                                if (myBuffer[0] == 0xf9 && Array.IndexOf(CMDS, myBuffer[1]) >= 0)
                                {
                                    int strLen = (myBuffer[2] << 8) + myBuffer[3]+6;

                                    if (strLen > myBuffer.Count)
                                    {
                                        break;
                                    }
                                    int cmpType = (myBuffer[5] << 8) + myBuffer[6];
                                    switch (cmpType)
                                    {
 
                                        case 0x0B11:
                                            sp.DiscardInBuffer();
                                            sp.DiscardOutBuffer();
                                            myBuffer.RemoveRange(0, myBuffer.Count);

                                            break;
                         
                                        default:
                                            break;
                                    }

                                    myBuffer.RemoveRange(0, myBuffer.Count);

                                }
                                else
                                {

                                    myBuffer.RemoveRange(0, 1);
                                }
                            }
                        }));
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }

Method 2 Define the data structure on the single chip microcomputer to On the upper computer

 

1、 Define the same structure for the single product machine For receiving data ( SCM has defined   #parama  pack(1))  All in all SCM and On the upper computer pack(x) Should agree

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
        public struct TEST
        {

            byte a;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 28)]
            byte[] b;/
            byte c;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 28)]
            char[] d;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 200)]
            string e;//  What is the length defined on the SCM   
          
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 50)]
            string login_data;// 
        }

matters needing attention :  1、[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]  Is the alignment of the structure ,pack=1 It means that the alignment of the structure is 1 byte . Otherwise, the default is 4 Bytes , Don't specify pack The way , You will find the same structure ,sizeof（ structure ） Different sizes , So much so that byte When converting an array to a structure , The data does not correspond to ,

If not used or         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 50)] in UnmanagedType.ByValTStr Does not correspond to elements in the structure , Use in use sizeof I will report  

Marshal.SizeOf newspaper “ Cannot Marshal as an unmanaged structure ; No meaningful size or offset can be calculated “ error .

2、 SCM string use char[200], Fixed length      

c# Middle structure can be used string, But also set the length （ Fixed length use UnmanagedType.ByValTStr）, How to fix the length

       //
        // Abstract :
        //     Used for arrays of inline fixed length characters that appear in structures .char Type is used for System.Runtime.InteropServices.UnmanagedType.ByValTStr
        //     Depending on System.Runtime.InteropServices.StructLayoutAttribute Attribute System.Runtime.InteropServices.CharSet
        //     Parameters apply to contained structures . Always use System.Runtime.InteropServices.MarshalAsAttribute.SizeConst
        //     Field to indicate the size of the array .

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 200)]
            string e;// What is the length defined on the SCM   

SCM string use unsigned char[28], Fixed length and UnmanagedType.ByValArray, Used to store Non string array

        //
        // Abstract :
        //     When System.Runtime.InteropServices.MarshalAsAttribute.Value Property is set to ByValArray when , You have to set
        //     System.Runtime.InteropServices.MarshalAsAttribute.SizeConst The field indicates the number of elements . Array of . When you need to distinguish between string types ,System.Runtime.InteropServices.MarshalAsAttribute.ArraySubType
        //     Field can select... Containing array elements System.Runtime.InteropServices.UnmanagedType. You can use this only System.Runtime.InteropServices.UnmanagedType
        //     The attributes of the fields in the structure in the form of elements in the array .

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 28)]
            char[] d;

 

The structure and the array are mutually transformed ：// Pseudo code

   public TESTtest= new TEST();

Array to structure ：

List<byte> myBuffer = new List<byte>();
        private void sp_DataReceived(object sender, EventArgs e)
            {
            SerialPort sp1 = (SerialPort)sender;
            if (sp1.IsOpen)     // Judge whether to open the serial port 
            {
                try
                {
                    if (this.InvokeRequired) // Add thread to prevent fake death 
                    {
                        this.Invoke(new MethodInvoker(delegate
                        {
                            //  Thread.Sleep(20);
                            int int_len = sp1.BytesToRead;
                            byte[] b = new byte[sp1.BytesToRead];

                            sp1.Read(b, 0, b.Length); // byte 

                            myBuffer.AddRange(b);
                            while (myBuffer.Count >= sizeof(TEST))// At least equal to the message length 
                            {

                               try

                               {

                                   test= (TEST)BytesToStruct(myBuffer.ToArray(), typeof(TEST));

                              }catch()

                              {

                                   myBuffer.RemoveRange(0, 1);

                                  }
                                          
                                          
                                    }

                                    myBuffer.RemoveRange(0, myBuffer.Count);

                                }
                            }
                        }));
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }

Structure to array ：

                byte[] s = StructToBytes(test);

 

Transformation method ：
       

/// <summary>
        ///  The structure is transformed into byte[]
        /// </summary>
        /// <param name="structure"></param>
        /// <returns></returns>
        public static Byte[] StructToBytes(Object structure)
        {
            Int32 size = Marshal.SizeOf(structure);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.StructureToPtr(structure, buffer, false);
                Byte[] bytes = new Byte[size];
                Marshal.Copy(buffer, bytes, 0, size);

                return bytes;
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }
        /// <summary>
        /// byte[] Into a structure 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="strcutType"></param>
        /// <returns></returns>
        public static Object BytesToStruct(Byte[] bytes, Type strcutType)
        {
            Int32 size = Marshal.SizeOf(strcutType);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.Copy(bytes, 0, buffer, size);

                return Marshal.PtrToStructure(buffer, strcutType);
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

 

Statement ： The conversion method is extracted from enthusiastic netizens , Investigation can be deleted