C#和C 的CAN通信实验

原创 已于 2022-06-23 11:34:08 修改 · 3.1k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c# #开发语言

于 2022-06-23 01:15:52 首次发布
本文探讨了C#中MESSAGESTRUCT结构与单片机CAN通信的异同，涉及消息格式、数据发送与接收函数，以及使用Kvaser.Kvadblib库解析DBC文件的示例。展示了C#中的字典用于信号映射和报文句柄管理，与单片机CAN的帧结构进行对比。

C# 的message与单片机的对比：

    public struct MESSAGESTRUCT
    {
        public string name;            //名称
        public int id;                 //ID
        public string comment;         //说明
        public int dlc;                //字节数
        public string type;            //J1939, 唤醒，标准

        public Dictionary<string, SIGNALSTRUCT> dicsignal;//根据信号名称定位信号
        public Kvadblib.MessageHnd mh; //当前报文的句柄
    }

    u8 Can_Send_Msg(u8* msg, u8 len)
    {
        u8 mbox;
        u16 i = 0;
        CanTxMsg TxMessage;
        TxMessage.StdId = 0x12;         // 标准标识符 
        TxMessage.ExtId = 0x12;         // 设置扩展标示符 
        TxMessage.IDE = CAN_Id_Standard;    // 标准帧
        TxMessage.RTR = CAN_RTR_Data;       // 数据帧
        TxMessage.DLC = len;                // 要发送的数据长度
        for (i = 0; i < len; i++)
            TxMessage.Data[i] = msg[i];
        mbox = CAN_Transmit(CAN1, &TxMessage);
        i = 0;
        while ((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed) && (i < 0XFFF)) i++; //等待发送结束
        if (i >= 0XFFF) return 1;
        return 0;
    }

    typedef struct
    {
      uint32_t StdId;  /*!< Specifies the standard identifier. 标准标识符
                            This parameter can be a value between 0 to 0x7FF. */

    uint32_t ExtId;  /*!< Specifies the extended identifier. 设置扩展标识符
                            This parameter can be a value between 0 to 0x1FFFFFFF. */

    uint8_t IDE;     /*!< Specifies the type of identifier for the message that 
                            will be transmitted. This parameter can be a value 
                            of @ref CAN_identifier_type */

    uint8_t RTR;     /*!< Specifies the type of frame for the message that will 
                            be transmitted. This parameter can be a value of 
                            @ref CAN_remote_transmission_request */

    uint8_t DLC;     /*!< Specifies the length of the frame that will be 
                            transmitted. This parameter can be a value between 
                            0 to 8 */

    uint8_t Data[8]; /*!< Contains the data to be transmitted. It ranges from 0 
                            to 0xFF. */
}
CanTxMsg;

using canlibCLSNET;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static canlibCLSNET.Canlib;

namespace CanDemon
{
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();

            //Canlib.canInitializeLibrary();//读取信息，初始化
            this.btnRefresh_Click(null, null);  //刷新
            this.cmb_Baud.DataSource = new List<string>() { "125000", "250000", "500000", "1000000" };
            this.cmb_Baud.SelectedIndex = 0;
        }

        private int handle = 0;
        private canStatus canStatus;
        private int chanelCount = 0; //通道数
        CancellationTokenSource cts = new CancellationTokenSource();

        private void btnRefresh_Click(object sender, EventArgs e)
        {
            
            canStatus = Canlib.canGetNumberOfChannels(out chanelCount);//获取can所有通道
            if (canStatus!= canStatus.canOK)
            {
                HandleError("canGetNumberOfChannels", canStatus);
            }

            cmb_Channel.Items.Clear();
            for (int i = 0; i < chanelCount; i++)
            {
                object obj;

                //获取通道名称：canCHANNELDATA_CHANNEL_NAME
                canStatus status = canGetChannelData(i, canCHANNELDATA_CHANNEL_NAME,out obj);//channel号，item号，buffer数据
                string strout = obj.ToString(); //转换成obj类型 获取通道名称

                //产品序列号 canCHANNELDATA_CARD_SERIAL_NO
                status = canGetChannelData(i, canCHANNELDATA_CARD_SERIAL_NO, out obj);
                string strtmp = string.Format(",{0:D6}", obj); //数据长度为6，不够的话前面补0

                strout += strtmp;
                cmb_Channel.Items.Add(strout);

            }
        }

        private void btnOpen_Click(object sender, EventArgs e)
        {
            if (this.btnOpen.Text == "打开")
            {
                //打开
                handle = canOpenChannel(this.cmb_Channel.SelectedIndex, canOPEN_OVERRIDE_EXCLUSIVE + canOPEN_ACCEPT_VIRTUAL);

                //设置波特率
                canStatus = canSetBitrate(handle, Convert.ToInt32(this.cmb_Baud.Text));

                HandleError("canSetBitrate", canStatus);

                //Bus On
                canStatus = canBusOn(handle);
                if (canStatus != canStatus.canOK)
                {
                    HandleError("canBusOn", canStatus);
                    return;
                }
                else
                {
                    //开启线程读取
                    this.btnOpen.Text = "Close";

                    Task.Run(async () =>
                    {
                        while (!cts.IsCancellationRequested)
                        {
                            byte[] buffer = new byte[100];

                            //out 不用在外面定义
                            //dlc长度，flag标志位
                            await Task.Delay(500);
                            canStatus = canRead(handle, out int id, buffer, out int dlc, out int flag, out long time);
                            if (canStatus != canStatus.canOK)
                            {
                                string error = string.Empty;

                                canGetErrorText(canStatus, out error);

                                AddInfo("Receive Error:" + error);
                            }
                            else
                            {
                                //成功读取
                                byte[] result = new byte[dlc];
                                //buffer复制给reslut
                                Array.Copy(buffer, 0, result, 0, dlc);

                                AddInfo("Receive Data:" + time.ToString() + " " + id.ToString() + GetHexStringFromByteArray(result));
                            }
                        }
                    });
                }
            }

            else
            {
                canClose(handle);
                this.btnOpen.Text = "Open";
            }

        }

        private void HandleError(string cmd, canStatus status)
        {
            if (status != canStatus.canOK) //错误状态
            {
                string error = string.Empty;
                canGetErrorText(status, out error);
                AddInfo($"{cmd} Error: {error}");
            }
        }

        private void AddInfo(string info)
        {
            if (this.listInfo.InvokeRequired)
            {
                this.Invoke(new Action(() =>
                {
                    this.listInfo.Items.Add(info);
                }));
                //this.listInfo.Invoke
            }
            else
            {
                this.listInfo.Items.Add(info);
            }
        }

        private string GetHexStringFromByteArray(byte[] b)
        {
            StringBuilder sb = new StringBuilder();
            foreach (var item in b)
            {
                sb.Append(item.ToString("X") + " ");
            }

            return sb.ToString().Trim();
        }


    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Kvaser.Kvadblib;

namespace CanDemon
{
    public enum canMSGFlag
    {
        canMsg_Mask = 0x00FF,
        canMsg_RTR = 0x0001,
        canMsg_STD = 0x0002,
        canMsg_EXT = 0x0004,
        canMsg_WAKEUP = 0x0008,
        canMsg_NERR = 0x0010,
        canMsg_ERROR_FRAME = 0x0020,
        canMsg_TXACK = 0x0040,
        canMsg_TXRQ = 0x0080F,
    }


    public struct SIGNALSTRUCT
    {
        public string name;            //名称
        public string comment;         //注释
        public string unit;            //单位
        public string encooding;       //编码
        public string type;            //类型
        public double minvaluelimit;   //最小值
        public double maxvaluelimit;   //最大值
        public double factor;          //系数
        public double offset;          //偏移量
        public int startbit;           //起始位
        public int bitlength;          //位长度
        public Kvadblib.SignalHnd sh;  //当前信号的句柄
    }
    public struct MESSAGESTRUCT
    {
        public string name;            //名称
        public int id;                 //ID
        public string comment;         //说明
        public int dlc;                //字节数
        public string type;            //J1939, 唤醒，标准

        public Dictionary<string, SIGNALSTRUCT> dicsignal;//根据信号名称定位信号 一对多，有多个signnal
        public Kvadblib.MessageHnd mh; //当前报文的句柄
    }
    public class canDbcReader
    {
        Kvadblib.Hnd dh = new Kvadblib.Hnd();
        Kvadblib.MessageHnd mh = new Kvadblib.MessageHnd();
        Kvadblib.SignalHnd sh = new Kvadblib.SignalHnd();
        Kvadblib.Status status;

        //08
        public Dictionary<int, MESSAGESTRUCT> dicMessage = new Dictionary<int, MESSAGESTRUCT>(); //canDbcReader中有多个Message

        public Dictionary<string, int> dicSigNameID = new Dictionary<string, int>();

        public canDbcReader()
        {
            dh = new Kvadblib.Hnd();
            status = Kvadblib.Open(out dh);
        }

        #region 导入dbc文件,相关的数据保存在字典的结构体中
        public bool ImportDbc(string strDbc)
        {
            #region 清除原有的数据

            foreach (MESSAGESTRUCT item in dicMessage.Values)
            {
                item.dicsignal.Clear();
            }
            dicMessage.Clear();

            dicSigNameID.Clear();

            #endregion

            try
            {
                //打开dbc文件
                status = Kvadblib.ReadFile(dh, strDbc);

                if (status != Kvadblib.Status.OK)
                    return false;


                status = Kvadblib.GetFirstMsg(dh, out mh);
                while (status == Kvadblib.Status.OK)//循环遍历报文，以及报文下面的信号
                {
                    MESSAGESTRUCT message = new MESSAGESTRUCT();
                    message.dicsignal = new Dictionary<string, SIGNALSTRUCT>();

                    if (!GetMessageInfo(mh, out message))

                        return false;

                    dicMessage.Add(message.id, message);

                    status = Kvadblib.GetNextMsg(dh, out mh);
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
        #endregion

        #region 根据信号句柄sh获取信号信息
        private void GetSignalInfo(Kvadblib.SignalHnd sh, out SIGNALSTRUCT sig)
        {
            SIGNALSTRUCT signal = new SIGNALSTRUCT();
            signal.sh = sh;                                             //信号句柄
            status = Kvadblib.GetSignalName(sh, out signal.name);       //信号名称
            status = Kvadblib.GetSignalComment(sh, out signal.comment); //信号说明
            status = Kvadblib.GetSignalUnit(sh, out signal.unit);       //信号单位
            Kvadblib.SignalEncoding se;                                 //编码方式，inter或 motorola
            status = Kvadblib.GetSignalEncoding(sh, out se);
            if (se == Kvadblib.SignalEncoding.Intel)
                signal.encooding = "Inter";
            else if (se == Kvadblib.SignalEncoding.Motorola)
                signal.encooding = "Motorola";
            Kvadblib.SignalType st;                                     //信号数据类型            
            status = Kvadblib.GetSignalRepresentationType(sh, out st);
            switch (st)
            {
                case Kvadblib.SignalType.Signed:
                    signal.type = "Signed";
                    break;
                case Kvadblib.SignalType.Unsigned:
                    signal.type = "Unsigned";
                    break;
                case Kvadblib.SignalType.Double:
                    signal.type = "Double";
                    break;
                case Kvadblib.SignalType.Float:
                    signal.type = "Float";
                    break;
                case Kvadblib.SignalType.Invalid:
                    signal.type = "Invalid";
                    break;
            }
            status = Kvadblib.GetSignalValueLimits(sh, out signal.minvaluelimit, out signal.maxvaluelimit);//最大最小信号值范围
            status = Kvadblib.GetSignalValueScaling(sh, out signal.factor, out signal.offset);//因数和偏移量
            status = Kvadblib.GetSignalValueSize(sh, out signal.startbit, out signal.bitlength);//起始位，位长度
            sig = signal;
        }
        #endregion

        #region 根据报文句柄mh获取报文信息
        private bool GetMessageInfo(Kvadblib.MessageHnd mh, out MESSAGESTRUCT msg)
        {
            MESSAGESTRUCT message = new MESSAGESTRUCT();
            message.dicsignal = new Dictionary<string, SIGNALSTRUCT>();
            try
            {
                Kvadblib.MESSAGE km;
                status = Kvadblib.GetMsgId(mh, out message.id, out km);//ID和帧类型

                switch (km)
                {
                    case Kvadblib.MESSAGE.EXT:
                        message.type = "扩展";
                        message.id = message.id & 0x1FFFFFFF;
                        break;
                    case Kvadblib.MESSAGE.J1939:
                        message.type = "J1939";
                        break;
                    case Kvadblib.MESSAGE.WAKEUP:
                        message.type = "唤醒帧";
                        break;
                    default:
                        message.type = "标准";
                        message.id = message.id & 0x1FFFFFFF;
                        break;
                }
                status = Kvadblib.GetMsgName(mh, out message.name);//报文名称
                status = Kvadblib.GetMsgDlc(mh, out message.dlc);//报文长度
                status = Kvadblib.GetMsgComment(mh, out message.comment);//报文说明
                message.mh = mh;//当前的句柄

                SIGNALSTRUCT signal = new SIGNALSTRUCT();
                Kvadblib.SignalHnd sh = new Kvadblib.SignalHnd();
                status = Kvadblib.GetFirstSignal(message.mh, out sh);
                while (status == Kvadblib.Status.OK)
                {

                    GetSignalInfo(sh, out signal);
                    dicSigNameID.Add(signal.name, message.id);
                    message.dicsignal.Add(signal.name, signal);
                    status = Kvadblib.GetNextSignal(mh, out sh);
                }
                msg = message;
                return true;
            }
            catch
            {
                msg = message;
                return false;
            }
        }
        #endregion

        #region 物理量或原始值填充报文
        //将信号的原始值填充到报文中
        public bool StoreSignalValueRaw(SIGNALSTRUCT signal, byte[] candata, int length, int raw)
        {
            status = Kvadblib.StoreSignalValueRaw(signal.sh, candata, candata.Length, raw);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }
        //将信号的物理值填充到报文中

        public bool StoreSignalValuePhys(SIGNALSTRUCT signal, byte[] candata, int length, double phys)
        {
            status = Kvadblib.StoreSignalValuePhys(signal.sh, candata, candata.Length, phys);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        #endregion

        #region 根据信号和原始值获取物理量
        //转换CAN数据到浮点的物理值
        public bool GetSignalValueFloat(SIGNALSTRUCT signal, byte[] candata, int length, out double value)
        {
            status = Kvadblib.GetSignalValueFloat(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        //转换CAN数据到整型物理值
        public bool GetSignalValueInteger(SIGNALSTRUCT signal, byte[] candata, int length, out int value)
        {
            status = Kvadblib.GetSignalValueInteger(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        //2转换CAN数据到枚举的物理值
        public bool GetSignalValueEnum(SIGNALSTRUCT signal, byte[] candata, int length, out string value)
        {
            status = Kvadblib.GetSignalValueEnum(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }
        #endregion
    }
}


namespace AXEBMSPro
{
    public enum canMSGFlag
    {
        canMsg_Mask = 0x00FF,
        canMsg_RTR = 0x0001,
        canMsg_STD = 0x0002,
        canMsg_EXT = 0x0004,
        canMsg_WAKEUP = 0x0008,
        canMsg_NERR = 0x0010,
        canMsg_ERROR_FRAME = 0x0020,
        canMsg_TXACK = 0x0040,
        canMsg_TXRQ = 0x0080F,
    }


    public struct SIGNALSTRUCT
    {
        public string name;            //名称
        public string comment;         //注释
        public string unit;            //单位
        public string encooding;       //编码
        public string type;            //类型
        public double minvaluelimit;   //最小值
        public double maxvaluelimit;   //最大值
        public double factor;          //系数
        public double offset;          //偏移量
        public int startbit;           //起始位
        public int bitlength;          //位长度
        public Kvadblib.SignalHnd sh;  //当前信号的句柄
    }
    public struct MESSAGESTRUCT
    {
        public string name;            //名称
        public int id;                 //ID
        public string comment;         //说明
        public int dlc;                //字节数
        public string type;            //J1939, 唤醒，标准

        public Dictionary<string, SIGNALSTRUCT> dicsignal;//根据信号名称定位信号
        public Kvadblib.MessageHnd mh; //当前报文的句柄
    }
    public class canDbcReader
    {
        Kvadblib.Hnd dh = new Kvadblib.Hnd();
        Kvadblib.MessageHnd mh = new Kvadblib.MessageHnd();
        Kvadblib.SignalHnd sh = new Kvadblib.SignalHnd();
        Kvadblib.Status status;

        public Dictionary<int, MESSAGESTRUCT> dicMessage = new Dictionary<int, MESSAGESTRUCT>();

        public Dictionary<string, int> dicSigNameID = new Dictionary<string, int>();

        public canDbcReader()
        {
            dh = new Kvadblib.Hnd();
            status = Kvadblib.Open(out dh);
        }

        #region 导入dbc文件,相关的数据保存在字典的结构体中
        public bool ImportDbc(string strDbc)
        {
            #region 清除原有的数据

            foreach (MESSAGESTRUCT item in dicMessage.Values)
            {
                item.dicsignal.Clear();
            }
            dicMessage.Clear();

            dicSigNameID.Clear();

            #endregion

            try
            {
                //打开dbc文件
                status = Kvadblib.ReadFile(dh, strDbc);

                if (status != Kvadblib.Status.OK)
                    return false;


                status = Kvadblib.GetFirstMsg(dh, out mh);
                while (status == Kvadblib.Status.OK)//循环遍历报文，以及报文下面的信号
                {
                    MESSAGESTRUCT message = new MESSAGESTRUCT();
                    message.dicsignal = new Dictionary<string, SIGNALSTRUCT>();

                    if (!GetMessageInfo(mh, out message))

                        return false;

                    dicMessage.Add(message.id, message);

                    status = Kvadblib.GetNextMsg(dh, out mh);
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
        #endregion

        #region 根据信号句柄sh获取信号信息
        private void GetSignalInfo(Kvadblib.SignalHnd sh, out SIGNALSTRUCT sig)
        {
            SIGNALSTRUCT signal = new SIGNALSTRUCT();
            signal.sh = sh;                                             //信号句柄
            status = Kvadblib.GetSignalName(sh, out signal.name);       //信号名称
            status = Kvadblib.GetSignalComment(sh, out signal.comment); //信号说明
            status = Kvadblib.GetSignalUnit(sh, out signal.unit);       //信号单位
            Kvadblib.SignalEncoding se;                                 //编码方式，inter或 motorola
            status = Kvadblib.GetSignalEncoding(sh, out se);
            if (se == Kvadblib.SignalEncoding.Intel)
                signal.encooding = "Inter";
            else if (se == Kvadblib.SignalEncoding.Motorola)
                signal.encooding = "Motorola";
            Kvadblib.SignalType st;                                     //信号数据类型            
            status = Kvadblib.GetSignalRepresentationType(sh, out st);
            switch (st)
            {
                case Kvadblib.SignalType.Signed:
                    signal.type = "Signed";
                    break;
                case Kvadblib.SignalType.Unsigned:
                    signal.type = "Unsigned";
                    break;
                case Kvadblib.SignalType.Double:
                    signal.type = "Double";
                    break;
                case Kvadblib.SignalType.Float:
                    signal.type = "Float";
                    break;
                case Kvadblib.SignalType.Invalid:
                    signal.type = "Invalid";
                    break;
            }
            status = Kvadblib.GetSignalValueLimits(sh, out signal.minvaluelimit, out signal.maxvaluelimit);//最大最小信号值范围
            status = Kvadblib.GetSignalValueScaling(sh, out signal.factor, out signal.offset);//因数和偏移量
            status = Kvadblib.GetSignalValueSize(sh, out signal.startbit, out signal.bitlength);//起始位，位长度
            sig = signal;
        }
        #endregion

        #region 根据报文句柄mh获取报文信息
        private bool GetMessageInfo(Kvadblib.MessageHnd mh, out MESSAGESTRUCT msg)
        {
            MESSAGESTRUCT message = new MESSAGESTRUCT();
            message.dicsignal = new Dictionary<string, SIGNALSTRUCT>();
            try
            {
                Kvadblib.MESSAGE km;
                status = Kvadblib.GetMsgId(mh, out message.id, out km);//ID和帧类型

                switch (km)
                {
                    case Kvadblib.MESSAGE.EXT:
                        message.type = "扩展";
                        message.id = message.id & 0x1FFFFFFF;
                        break;
                    case Kvadblib.MESSAGE.J1939:
                        message.type = "J1939";
                        break;
                    case Kvadblib.MESSAGE.WAKEUP:
                        message.type = "唤醒帧";
                        break;
                    default:
                        message.type = "标准";
                        message.id = message.id & 0x1FFFFFFF;
                        break;
                }
                status = Kvadblib.GetMsgName(mh, out message.name);//报文名称
                status = Kvadblib.GetMsgDlc(mh, out message.dlc);//报文长度
                status = Kvadblib.GetMsgComment(mh, out message.comment);//报文说明
                message.mh = mh;//当前的句柄

                SIGNALSTRUCT signal = new SIGNALSTRUCT();
                Kvadblib.SignalHnd sh = new Kvadblib.SignalHnd();
                status = Kvadblib.GetFirstSignal(message.mh, out sh);
                while (status == Kvadblib.Status.OK)
                {
                  
                    GetSignalInfo(sh, out signal);
                    dicSigNameID.Add(signal.name, message.id);
                    message.dicsignal.Add(signal.name, signal);
                    status = Kvadblib.GetNextSignal(mh, out sh);
                }
                msg = message;
                return true;
            }
            catch
            {
                msg = message;
                return false;
            }
        }
        #endregion

        #region 物理量或原始值填充报文
        //将信号的原始值填充到报文中
        public bool StoreSignalValueRaw(SIGNALSTRUCT signal, byte[] candata, int length, int raw)
        {
            status = Kvadblib.StoreSignalValueRaw(signal.sh, candata, candata.Length, raw);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }
        //将信号的物理值填充到报文中

        public bool StoreSignalValuePhys(SIGNALSTRUCT signal, byte[] candata, int length, double phys)
        {
            status = Kvadblib.StoreSignalValuePhys(signal.sh, candata, candata.Length, phys);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        #endregion

        #region 根据信号和原始值获取物理量
        //转换CAN数据到浮点的物理值
        public bool GetSignalValueFloat(SIGNALSTRUCT signal, byte[] candata, int length, out double value)
        {
            status = Kvadblib.GetSignalValueFloat(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        //转换CAN数据到整型物理值
        public bool GetSignalValueInteger(SIGNALSTRUCT signal, byte[] candata, int length, out int value)
        {
            status = Kvadblib.GetSignalValueInteger(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }

        //2转换CAN数据到枚举的物理值
        public bool GetSignalValueEnum(SIGNALSTRUCT signal, byte[] candata, int length, out string value)
        {
            status = Kvadblib.GetSignalValueEnum(signal.sh, out value, candata, candata.Length);
            if (status != Kvadblib.Status.OK) return false;
            return true;
        }
        #endregion
    }
}

C：

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "lcd.h"
#include "usart.h"	 
#include "can.h" 
 
  


 int main(void)
 {	 
		u8 key;
	u8 i=0,t=0;
	u8 cnt=0;
	u8 canbuf[8];
	u8 res;
	u8 mode=CAN_Mode_LoopBack;//CAN工作模式;CAN_Mode_Normal(0)：普通模式，CAN_Mode_LoopBack(1)：环回模式

	delay_init();	    	 //延时函数初始化	  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
	uart_init(115200);	 	//串口初始化为115200
	LED_Init();		  		//初始化与LED连接的硬件接口
	LCD_Init();			   	//初始化LCD	
	KEY_Init();				//按键初始化		 	
   
	CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_Mode_LoopBack);//CAN初始化环回模式,波特率500Kbps    

 	POINT_COLOR=RED;//设置字体为红色 
	LCD_ShowString(60,50,200,16,16,"WarShip STM32");	
	LCD_ShowString(60,70,200,16,16,"CAN TEST");	
	LCD_ShowString(60,90,200,16,16,"ATOM@ALIENTEK");
	LCD_ShowString(60,110,200,16,16,"2015/1/15");
	LCD_ShowString(60,130,200,16,16,"LoopBack Mode");	 
	LCD_ShowString(60,150,200,16,16,"KEY0:Send WK_UP:Mode");//显示提示信息		
	POINT_COLOR=BLUE;//设置字体为蓝色	  
	LCD_ShowString(60,170,200,16,16,"Count:");			//显示当前计数值	
	LCD_ShowString(60,190,200,16,16,"Send Data:");		//提示发送的数据	
	LCD_ShowString(60,250,200,16,16,"Receive Data:");	//提示接收到的数据		
 	while(1)
	{
		key=KEY_Scan(0);
		if(key==KEY0_PRES)//KEY0按下,发送一次数据
		{
			for(i=0;i<8;i++)
			{
				canbuf[i]=cnt+i;//填充发送缓冲区
				if(i<4)LCD_ShowxNum(60+i*32,210,canbuf[i],3,16,0X80);	//显示数据
				else LCD_ShowxNum(60+(i-4)*32,230,canbuf[i],3,16,0X80);	//显示数据
 			}
			res=Can_Send_Msg(canbuf,8);//发送8个字节 
			if(res)LCD_ShowString(60+80,190,200,16,16,"Failed");		//提示发送失败
			else LCD_ShowString(60+80,190,200,16,16,"OK    ");	 		//提示发送成功								   
		}else if(key==WKUP_PRES)//WK_UP按下，改变CAN的工作模式
		{	   
			mode=!mode;
  			CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,mode);//CAN普通模式初始化, 波特率500Kbps 
			POINT_COLOR=RED;//设置字体为红色 
			if(mode==0)//普通模式，需要2个开发板
			{
				LCD_ShowString(60,130,200,16,16,"Nnormal Mode ");	    
			}else //回环模式,一个开发板就可以测试了.
			{
 				LCD_ShowString(60,130,200,16,16,"LoopBack Mode");
			}
 			POINT_COLOR=BLUE;//设置字体为蓝色 
		}		 
		key=Can_Receive_Msg(canbuf);
		if(key)//接收到有数据
		{			
			LCD_Fill(60,270,130,310,WHITE);//清除之前的显示
 			for(i=0;i<key;i++)
			{									    
				if(i<4)LCD_ShowxNum(60+i*32,270,canbuf[i],3,16,0X80);	//显示数据
				else LCD_ShowxNum(60+(i-4)*32,290,canbuf[i],3,16,0X80);	//显示数据
 			}
		}
		t++; 
		delay_ms(10);
		if(t==20)
		{
			LED0=!LED0;//提示系统正在运行	
			t=0;
			cnt++;
			LCD_ShowxNum(60+48,170,cnt,3,16,0X80);	//显示数据
		}		   
	}
}

=========C=

#ifndef __CAN_H
#define __CAN_H	 
#include "sys.h"	    

 
//CAN接收RX0中断使能
#define CAN_RX0_INT_ENABLE	0		//0,不使能;1,使能.								    
//tsjw:重新同步跳跃时间单元.范围:CAN_SJW_1tq~ CAN_SJW_4tq	
//tbs2:时间段 2 的时间单元. 范围:CAN_BS2_1tq~CAN_BS2_8tq;
//tbs1:时间段 1 的时间单元. 范围:CAN_BS1_1tq ~CAN_BS1_16tq
//brp :波特率分频器.范围:1~1024; tq=(brp)*tpclk1
//波特率=Fpclk1/((tbs1+1+tbs2+1+1)*brp);
//mode:CAN_Mode_Normal,普通模式;CAN_Mode_LoopBack,回环模式;

//Fpclk1 的时钟在初始化的时候设置为 36M,如果设置
//CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_Mode_LoopBack);
//则波特率为:36M/((8+9+1)*4)=500Kbps
//返回值:0,初始化 OK;
// 其他,初始化失败; u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode);//CAN初始化

u8 Can_Send_Msg(u8* msg,u8 len);						//发送数据

u8 Can_Receive_Msg(u8 *buf);							//接收数据
#endif

#include "can.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
 
 
//CAN初始化
//tsjw:重新同步跳跃时间单元.范围:CAN_SJW_1tq~ CAN_SJW_4tq
//tbs2:时间段2的时间单元.   范围:CAN_BS2_1tq~CAN_BS2_8tq;
//tbs1:时间段1的时间单元.   范围:CAN_BS1_1tq ~CAN_BS1_16tq
//brp :波特率分频器.范围:1~1024;  tq=(brp)*tpclk1
//波特率=Fpclk1/((tbs1+1+tbs2+1+1)*brp);
//mode:CAN_Mode_Normal,普通模式;CAN_Mode_LoopBack,回环模式;
//Fpclk1的时钟在初始化的时候设置为36M,如果设置CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_Mode_LoopBack);
//则波特率为:36M/((8+9+1)*4)=500Kbps
//返回值:0,初始化OK;
//    其他,初始化失败; 
u8 CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
{ 
	GPIO_InitTypeDef 		GPIO_InitStructure; 
	CAN_InitTypeDef        	CAN_InitStructure;
	CAN_FilterInitTypeDef  	CAN_FilterInitStructure;
#if CAN_RX0_INT_ENABLE 
	NVIC_InitTypeDef  		NVIC_InitStructure;
#endif

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能PORTA时钟	                   											 

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);//使能CAN1时钟	

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽
	GPIO_Init(GPIOA, &GPIO_InitStructure);			//初始化IO

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;	//上拉输入
	GPIO_Init(GPIOA, &GPIO_InitStructure);			//初始化IO

	//CAN单元设置
	CAN_InitStructure.CAN_TTCM=DISABLE;			//非时间触发通信模式  
	CAN_InitStructure.CAN_ABOM=DISABLE;			//软件自动离线管理	 
	CAN_InitStructure.CAN_AWUM=DISABLE;			//睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
	CAN_InitStructure.CAN_NART=ENABLE;			//禁止报文自动传送 
	CAN_InitStructure.CAN_RFLM=DISABLE;		 	//报文不锁定,新的覆盖旧的  
	CAN_InitStructure.CAN_TXFP=DISABLE;			//优先级由报文标识符决定 
	CAN_InitStructure.CAN_Mode= mode;	        //模式设置： mode:0,普通模式;1,回环模式; 
	//设置波特率
	CAN_InitStructure.CAN_SJW=tsjw;				//重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位  CAN_SJW_1tq	 CAN_SJW_2tq CAN_SJW_3tq CAN_SJW_4tq
	CAN_InitStructure.CAN_BS1=tbs1; 			//Tbs1=tbs1+1个时间单位CAN_BS1_1tq ~CAN_BS1_16tq
	CAN_InitStructure.CAN_BS2=tbs2;				//Tbs2=tbs2+1个时间单位CAN_BS2_1tq ~	CAN_BS2_8tq
	CAN_InitStructure.CAN_Prescaler=brp;        //分频系数(Fdiv)为brp+1	
	CAN_Init(CAN1, &CAN_InitStructure);        	//初始化CAN1 

	CAN_FilterInitStructure.CAN_FilterNumber=0;	//过滤器0
	CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; 	//屏蔽位模式
	CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; 	//32位宽 
	CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;	//32位ID
	CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
	CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
	CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
	CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
	CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;//激活过滤器0

	CAN_FilterInit(&CAN_FilterInitStructure);			//滤波器初始化
	
#if CAN_RX0_INT_ENABLE 
	CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);				//FIFO0消息挂号中断允许.		    

	NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;     // 主优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;            // 次优先级为0
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
#endif
	return 0;
}   
 
#if CAN_RX0_INT_ENABLE	//使能RX0中断
//中断服务函数			    
void USB_LP_CAN1_RX0_IRQHandler(void)
{
  	CanRxMsg RxMessage;
	int i=0;
    CAN_Receive(CAN1, 0, &RxMessage);
	for(i=0;i<8;i++)
	printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data[i]);
}
#endif

//can发送一组数据(固定格式:ID为0X12,标准帧,数据帧)	
//len:数据长度(最大为8)				     
//msg:数据指针,最大为8个字节.
//返回值:0,成功;
//		 其他,失败;
u8 Can_Send_Msg(u8* msg,u8 len)
{	
	u8 mbox;
	u16 i=0;
	CanTxMsg TxMessage;
	TxMessage.StdId=0x12;			// 标准标识符 
	TxMessage.ExtId=0x12;			// 设置扩展标示符 
	TxMessage.IDE=CAN_Id_Standard; 	// 标准帧
	TxMessage.RTR=CAN_RTR_Data;		// 数据帧
	TxMessage.DLC=len;				// 要发送的数据长度
	for(i=0;i<len;i++)
	TxMessage.Data[i]=msg[i];			          
	mbox= CAN_Transmit(CAN1, &TxMessage);   
	i=0; 
	while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;	//等待发送结束
	if(i>=0XFFF)return 1;
	return 0;	 
}
//can口接收数据查询
//buf:数据缓存区;	 
//返回值:0,无数据被收到;
//		 其他,接收的数据长度;
u8 Can_Receive_Msg(u8 *buf)
{		   		   
 	u32 i;
	CanRxMsg RxMessage;
    if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;		//没有接收到数据,直接退出 
    CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);//读取数据	
    for(i=0;i<8;i++)
    buf[i]=RxMessage.Data[i];  
	return RxMessage.DLC;	
}

typedef struct
{
  uint32_t StdId;  /*!< Specifies the standard identifier.
                        This parameter can be a value between 0 to 0x7FF. */

  uint32_t ExtId;  /*!< Specifies the extended identifier.
                        This parameter can be a value between 0 to 0x1FFFFFFF. */

  uint8_t IDE;     /*!< Specifies the type of identifier for the message that 
                        will be transmitted. This parameter can be a value 
                        of @ref CAN_identifier_type */

  uint8_t RTR;     /*!< Specifies the type of frame for the message that will 
                        be transmitted. This parameter can be a value of 
                        @ref CAN_remote_transmission_request */

  uint8_t DLC;     /*!< Specifies the length of the frame that will be 
                        transmitted. This parameter can be a value between 
                        0 to 8 */

  uint8_t Data[8]; /*!< Contains the data to be transmitted. It ranges from 0 
                        to 0xFF. */
} CanTxMsg;

/** 
  * @brief  CAN Rx message structure definition  
  */

typedef struct
{
  uint32_t StdId;  /*!< Specifies the standard identifier.
                        This parameter can be a value between 0 to 0x7FF. */

  uint32_t ExtId;  /*!< Specifies the extended identifier.
                        This parameter can be a value between 0 to 0x1FFFFFFF. */

  uint8_t IDE;     /*!< Specifies the type of identifier for the message that 
                        will be received. This parameter can be a value of 
                        @ref CAN_identifier_type */

  uint8_t RTR;     /*!< Specifies the type of frame for the received message.
                        This parameter can be a value of 
                        @ref CAN_remote_transmission_request */

  uint8_t DLC;     /*!< Specifies the length of the frame that will be received.
                        This parameter can be a value between 0 to 8 */

  uint8_t Data[8]; /*!< Contains the data to be received. It ranges from 0 to 
                        0xFF. */

  uint8_t FMI;     /*!< Specifies the index of the filter the message stored in 
                        the mailbox passes through. This parameter can be a 
                        value between 0 to 0xFF */
} CanRxMsg;
canopen协议详解【C#二次开发】
cfqq1989的博客
01-16 1万+
NMT-上传：从站状态帧 700h+EMCY：从站故障帧 80h+EMCY：从站故障帧 80h+NMT：总线命令 00h。SYNC：同步命令 80h。SYNC：同步帧 80h。先看从站回帧 700h+SDO：参数寄存器设置。SDO：参数寄存器设置。
CANopen协议，上位机开发（C#）
cfqq1989的博客
12-13 8547
CAN 控制局域网CiA CAN自动化组织 (标准机构)COB-ID 通讯对象标识符EDS 电子数据表NMT 网络管理OD 对象字典PDS 电源驱动系统PDO 过程数据对象RPDO 接收过程数据对象SDO 服务数据对象TPDO 发送过程数据对象COS TPDO检测状态改变FSA 有限自动状态机4bit全局网络0x80（1005h）同步对象 //同步对象 COB-ID 的次高位决定是否激活同步发生器。（1006h）同步循环周期急停报文高速慢。
基于C#的CAN通讯示例
01-29
基于C#的CAN通讯示例，实现CAN通讯的写入读出，测试通过。
C#进行CAN【控制器局域网】通讯
最新发布
ylq1045的专栏
11-20 531
CAN总线通信系统设计与实现 摘要： 本文介绍了一个基于C#的CAN总线通信系统设计方案，采用Peak公司的PCANBasic.NET接口实现硬件通信功能。系统具备以下主要功能：1) 支持多种波特率配置，实现CAN设备连接与管理；2) 提供消息收发功能，支持标准帧格式；3) 内置信号解析引擎，可自定义信号解析规则；4) 实时数据显示功能，包括网格视图和动态图表；5) 数据记录功能，支持CSV格式导出。系统采用多线程架构处理实时数据，通过MVC模式实现界面与逻辑分离，适用于汽车电子、工业控制等领域的CAN总线
【C#】CAN通信的使用
wangnaisheng的专栏
04-13 2480
在C#中实现CAN通信通常需要借助第三方库或硬件设备的驱动程序，因为C#本身并没有直接内置支持CAN通信的功能。以下是一个关于如何使用C#实现CAN通信的基本指南，包括所需的步骤和常用工具。这些硬件设备通常会提供对应的驱动程序和开发库，用于与主机进行通信。大多数CAN硬件供应商都会提供相应的驱动程序和软件开发工具包（SDK）。安装驱动后，确保可以正常使用硬件，并下载对应的SDK文档和示例代码。在Visual Studio中创建一个C#项目，并将PCAN SDK中的DLL文件添加为引用。
通信协议_C#实现CAN通信
weixin_63243357的博客
07-19 3768
当某个节点检测到错误时，它会发送错误帧来中断当前传输。远程帧用于请求发送具有特定ID的数据帧。数据帧用于传输实际的数据。
cSharp_can_examp.rar_C# CAN_C# CAN通讯_CAN c#_Can 总线 Csharp_c# 开发c
09-24
C# CAN通信是嵌入式系统和物联网应用中不可或缺的一部分，尤其在汽车电子、工业自动化等领域，CAN（Controller Area Network）总线作为一种高效、可靠的通信协议，被广泛使用。本资源"北航CAN总线实验代码"是针对C#...
[c#]wince平台can通信测试程序
10-28
周立功是一家知名的嵌入式硬件供应商，EPSC8980是一款基于ARM架构的微控制器，通常集成了CAN接口，使得开发者可以直接进行CAN通信实验。 在Wince平台上开发CAN通信程序，首先需要了解CAN驱动程序的集成。Wince支持...
周立功USBCAN通信测试C#与VC++源码
周立功USBCAN-I是广州周立功单片机科技有限公司推出的一款高性能USB转CAN接口设备，广泛应用于工业自动化、...综上所述，该资源不仅提供了一套可用的测试代码，更是学习CAN通信技术和嵌入式接口开发的宝贵实践材料。
C#操作周立功CANBus PCI接口卡完整源代码分享
标题中提到的知识点主要涉及两个方面：CANBus技术和C#编程语言。CANBus（Controller Area Network Bus）是一种被广泛应用的通信总线标准，它允许微控制器和设备在没有主机计算机的情况下进行通信。这种技术主要在...
C#【通讯篇】CAN总线数据读和写（调用canlibCLSNET.dll）+Kvaser驱动
05-18
IDE：VS2019，平台：x86 硬件：Kvaser Leaf Light v2 嵌入式：PCB板
汽车总线Can通信源码C#
09-10
调用Vector的Can通信设备的库函数实现简单的Can通信, 给汽车通信相关行业的人参考
c#接收发送can数据
04-04
c#接收发送can数据，
C#读取CAN数据
03-21
C#读取CAN数据，很好的资料，周立功盒子！！！！！！！
C#_CAN实例源代码
04-28
C#_CAN实例源代码 周立功CAN源码
STM32云台控制系统：小车运行初始化与CAN通信实现
资源摘要信息:"GimbalControl.zip_CAN小车_STM32小车_STM32云台_c#can通信_stm32-" 1. STM32微控制器基础 STM32是STMicroelectronics（意法半导体）生产的基于ARM Cortex-M内核的32位微控制器系列。STM32微控制器...
c#通过串口及CAN模块实现上位及下位机通讯
热门推荐
weixin_43292039的博客
08-25 1万+
目录 前言 一、串口、CAN总线 二、使用步骤 1.RS232串口通讯（指令下发与接收） 2.CAN总线通讯 总结 前言 学习及工作中我们经常会遇到上位机与下位机通讯等工作，结合场景使用不同的通讯方式实时通讯，以下为工作中遇到的上位机与下位机进行实时通讯，采用RS232串口和CAN总线形式进行网络通讯。 一、串口、CAN总线 串行接口简称串口，也称串行通讯接口或串行通讯接口（通常指设备的COM接口），是采用串行通信方式的扩展接口。串行接口 （Serial Interface）是指..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值