3.canfestivel-proceedPDO

最新推荐文章于 2023-06-15 15:47:39 发布
最新推荐文章于 2023-06-15 15:47:39 发布
阅读量1.7k 收藏 15
点赞数 5
分类专栏： CANopen从站在stm32上的实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_38330669/article/details/102653085
版权
本文详细解析了CAN总线中设备如何通过canDispatch函数处理接收到的CAN帧。根据不同帧ID，调用相应处理函数如proceedSYNC、proceedEMCY等。针对过程数据对象(PDO)，介绍了proceedPDO函数如何解析映射参数，更新对象字典，并处理事件定时器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

设备收到can帧之后就调用解包函数canDispatch，在这个函数里，根据帧ID的不同进行分类处理。

void canDispatch(CO_Data* d, Message *m)
{
	UNS16 cob_id = UNS16_LE(m->cob_id);
	 switch(cob_id >> 7)
	{
		case SYNC:		/* can be a SYNC or a EMCY message */
			if(cob_id == 0x080)	/* SYNC */
			{
				if(d->CurrentCommunicationState.csSYNC)
					proceedSYNC(d);
			} else 		/* EMCY */
				if(d->CurrentCommunicationState.csEmergency)
					proceedEMCY(d,m);
			break;
		case TIME_STAMP:
		case PDO1tx:
		case PDO1rx:
		case PDO2tx:
		case PDO2rx:
		case PDO3tx:
		case PDO3rx:
		case PDO4tx:
		case PDO4rx:
			if (d->CurrentCommunicationState.csPDO)
				proceedPDO(d,m);
			break;
		case SDOtx:
		case SDOrx:
			if (d->CurrentCommunicationState.csSDO)
				proceedSDO(d,m);
			break;
		case NODE_GUARD:
			if (d->CurrentCommunicationState.csLifeGuard)
				proceedNODE_GUARD(d,m);
			break;
		case NMT:
			if (*(d->iam_a_slave))
			{
				proceedNMTstateChange(d,m);
			}
            break;
#ifdef CO_ENABLE_LSS
		case LSS:
			if (!d->CurrentCommunicationState.csLSS)break;
			if ((*(d->iam_a_slave)) && cob_id==MLSS_ADRESS)
			{
				proceedLSS_Slave(d,m);
			}
			else if(!(*(d->iam_a_slave)) && cob_id==SLSS_ADRESS)
			{
				proceedLSS_Master(d,m);
			}
			break;
#endif
	}
}
  • 对于PDO，调用proceedPDO。
/*!
**
**
** @param d
** @param m
**
** @return
**/
UNS8
proceedPDO (CO_Data * d, Message * m)
{
  UNS8 numPdo;
  UNS8 numMap;                  /* Number of the mapped varable */
  UNS8 *pMappingCount = NULL;   /* count of mapped objects... */
  /* pointer to the var which is mapped to a pdo... */
  /*  void *     pMappedAppObject = NULL;   */
  /* pointer fo the var which holds the mapping parameter of an
     mapping entry */
  UNS32 *pMappingParameter = NULL;
  UNS8 *pTransmissionType = NULL;       /* pointer to the transmission
                                           type */
  UNS32 *pwCobId = NULL;
  UNS8 Size;
  UNS8 offset;
  UNS8 status;
  UNS32 objDict;
  UNS16 offsetObjdict;
  UNS16 lastIndex;

  status = state2;

  MSG_WAR (0x3935, "proceedPDO, cobID : ", (UNS16_LE(m->cob_id) & 0x7ff));
  offset = 0x00;
  numPdo = 0;
  numMap = 0;
  if ((*m).rtr == NOT_A_REQUEST)
    { 
      offsetObjdict = d->firstIndex->PDO_RCV;
      lastIndex = d->lastIndex->PDO_RCV;

      if (offsetObjdict)
        while (offsetObjdict <= lastIndex)
          {
            switch (status)
              {

              case state2:
                pwCobId = d->objdict[offsetObjdict].pSubindex[1].pObject;
                if (*pwCobId == UNS16_LE(m->cob_id))
                  {
                    /* The cobId is recognized */
                    status = state4;
                    MSG_WAR (0x3936, "cobId found at index ",
                             0x1400 + numPdo);
                    break;
                  }
                else
                  {
                    /* received cobId does not match */
                    numPdo++;
                    offsetObjdict++;
                    status = state2;
                    break;
                  }

              case state4:     /* Get Mapped Objects Number */
                /* The cobId of the message received has been found in the
                   dictionnary. */
                offsetObjdict = d->firstIndex->PDO_RCV_MAP;
                lastIndex = d->lastIndex->PDO_RCV_MAP;
                pMappingCount =
                  (UNS8 *) (d->objdict + offsetObjdict +
                            numPdo)->pSubindex[0].pObject;
                numMap = 0;
                while (numMap < *pMappingCount)
                  {
                    UNS8 tmp[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
                    UNS32 ByteSize;
                    pMappingParameter =
                      (UNS32 *) (d->objdict + offsetObjdict +
                                 numPdo)->pSubindex[numMap + 1].pObject;
                    if (pMappingParameter == NULL)
                      {
                        MSG_ERR (0x1937, "Couldn't get mapping parameter : ",
                                 numMap + 1);
                        return 0xFF;
                      }
                    /* Get the addresse of the mapped variable. */
                    /* detail of *pMappingParameter : */
                    /* The 16 hight bits contains the index, the medium 8 bits
                       contains the subindex, */
                    /* and the lower 8 bits contains the size of the mapped
                       variable. */

                    Size = (UNS8) (*pMappingParameter & (UNS32) 0x000000FF);

                    /* set variable only if Size != 0 and 
                     * Size is lower than remaining bits in the PDO */
                    if (Size && ((offset + Size) <= (m->len << 3)))
                      {
                        /* copy bit per bit in little endian */
                        CopyBits (Size, (UNS8 *) & m->data[offset >> 3],
                                  offset % 8, 0, ((UNS8 *) tmp), 0, 0);
                        /*1->8 => 1 ; 9->16 =>2, ... */
                        ByteSize = (UNS32)(1 + ((Size - 1) >> 3));

                        objDict =
                          setODentry (d, (UNS16) ((*pMappingParameter) >> 16),
                                      (UNS8) (((*pMappingParameter) >> 8) &
                                              0xFF), tmp, &ByteSize, 0);

                        if (objDict != OD_SUCCESSFUL)
                          {
                            MSG_ERR (0x1938,
                                     "error accessing to the mapped var : ",
                                     numMap + 1);
                            MSG_WAR (0x2939, "         Mapped at index : ",
                                     (*pMappingParameter) >> 16);
                            MSG_WAR (0x2940, "                subindex : ",
                                     ((*pMappingParameter) >> 8) & 0xFF);
                            return 0xFF;
                          }

                        MSG_WAR (0x3942,
                                 "Variable updated by PDO cobid : ",
                                 UNS16_LE(m->cob_id));
                        MSG_WAR (0x3943, "         Mapped at index : ",
                                 (*pMappingParameter) >> 16);
                        MSG_WAR (0x3944, "                subindex : ",
                                 ((*pMappingParameter) >> 8) & 0xFF);
                        offset += Size;
                      }
                    numMap++;
                  }             /* end loop while on mapped variables */
                if (d->RxPDO_EventTimers)
                {
                    TIMEVAL EventTimerDuration = *(UNS16 *)d->objdict[offsetObjdict].pSubindex[5].pObject;
                    if(EventTimerDuration){
                        DelAlarm (d->RxPDO_EventTimers[numPdo]);
                        d->RxPDO_EventTimers[numPdo] = SetAlarm (d, numPdo, d->RxPDO_EventTimers_Handler,
                        MS_TO_TIMEVAL (EventTimerDuration), 0);
                    }
                }
                return 0;

              }                 /* end switch status */
          }                     /* end while */
    }                           /* end if Donnees */
  else if ((*m).rtr == REQUEST)
    {
      MSG_WAR (0x3946, "Receive a PDO request cobId : ", UNS16_LE(m->cob_id));
      status = state1;
      offsetObjdict = d->firstIndex->PDO_TRS;
      lastIndex = d->lastIndex->PDO_TRS;
      if (offsetObjdict)
        while (offsetObjdict <= lastIndex)
          {
            /* study of all PDO stored in the objects dictionary */

            switch (status)
              {

              case state1:     /* check the CobId */
                /* get CobId of the dictionary which match to the received PDO
                 */
                pwCobId =
                   (d->objdict +
                             offsetObjdict)->pSubindex[1].pObject;
                if (*pwCobId == UNS16_LE(m->cob_id))
                  {
                    status = state4;
                    break;
                  }
                else
                  {
                    numPdo++;
                    offsetObjdict++;
                  }
                status = state1;
                break;


              case state4:     /* check transmission type */
                pTransmissionType =
                  (UNS8 *) d->objdict[offsetObjdict].pSubindex[2].pObject;
                /* If PDO is to be sampled and send on RTR, do it */
                if ((*pTransmissionType == TRANS_RTR))
                  {
                    status = state5;
                    break;
                  }
                /* RTR_SYNC means data prepared at SYNC, transmitted on RTR */
                else if ((*pTransmissionType == TRANS_RTR_SYNC))
                  {
                    if (d->PDO_status[numPdo].
                        transmit_type_parameter & PDO_RTR_SYNC_READY)
                      {
                        /*Data ready, just send */
                        canSend (d->canHandle,
                                 &d->PDO_status[numPdo].last_message);
                        return 0;
                      }
                    else
                      {
                        /* if SYNC did never occur, transmit current data */
                        /* DS301 do not tell what to do in such a case... */
                        MSG_ERR (0x1947,
                                 "Not ready RTR_SYNC TPDO send current data : ",
                                 UNS16_LE(m->cob_id));
                        status = state5;
                      }
                    break;
                  }
                else if ((*pTransmissionType == TRANS_EVENT_PROFILE) ||
                         (*pTransmissionType == TRANS_EVENT_SPECIFIC))
                  {
                    /* Zap all timers and inhibit flag */
                    d->PDO_status[numPdo].event_timer =
                      DelAlarm (d->PDO_status[numPdo].event_timer);
                    d->PDO_status[numPdo].inhibit_timer =
                      DelAlarm (d->PDO_status[numPdo].inhibit_timer);
                    d->PDO_status[numPdo].transmit_type_parameter &=
                      ~PDO_INHIBITED;
                    /* Call  PDOEventTimerAlarm for this TPDO, 
                     * this will trigger emission et reset timers */
                    PDOEventTimerAlarm (d, numPdo);
                    return 0;
                  }
                else
                  {
                    /* The requested PDO is not to send on request. So, does
                       nothing. */
                    MSG_WAR (0x2947, "PDO is not to send on request : ",
                             UNS16_LE(m->cob_id));
                    return 0xFF;
                  }

              case state5:     /* build and send requested PDO */
                {
                  Message pdo;
                  if (buildPDO (d, numPdo, &pdo))
                    {
                      MSG_ERR (0x1948, " Couldn't build TPDO number : ", numPdo);
                      return 0xFF;
                    }
                  canSend (d->canHandle, &pdo);
                  return 0;
                }
              }                 /* end switch status */
          }                     /* end while */
    }                           /* end if Requete */

  return 0;
}

这个函数执行流程如下：

非远程帧（NOT_A_REQUEST），那么这是一个RPDO。遍历索引表中的RPDO，如果找到了对应的cob_id，就记录它相对于RPDO开始位置的偏移量（numPdo变量），进而找到映射参数map对象。解析map对象里子索引0参数，得到这个map里子索引的数量。遍历子索引，依次对子索引的map参数进行解析，找到数据存放区。调用setODentry对数据区进行写操作，写完之后调用用户自定义的回调函数。再之后，检查是否有事件定时器，如果有就根据子索引5中的设定一个定时事件，定时时间到会调用_RxPDO_EventTimers_Handler这个回调函数，在这个函数里可以实现一些需要延迟处理的动作。

远程帧（REQUEST），那么这是一个TPDO。根据TPDO传输类型的不同进行不同的处理：如果是远程异步（TRANS_RTR），就直接把这个TPDO的内容发送出去；如果是远程同步（TRANS_RTR_SYNC），还要检查transmit_type_parameter这个参数并做不同处理；如果是制造商特定事件（TRANS_EVENT_SPECIFIC）或者设备子协议特定事件（TRANS_EVENT_PROFILE），就调用PDOEventTimerAlarm函数，生成TPDO对象并和上一次的对象比较，如果不同就发送出去。

而根据DS301协议规定的另外两种传输类型非循环同步和循环同步，则是在处理同步帧的函数proceedSYNC处理的。

 

【读懂AUTOSAR】，之CAN Driver L-PDU发送和“重入问题”
weixin_46481662的博客
09-06 1678
L-PDU传输时，Can模块将L-PDU内容ID和数据长度转换为硬件特定格式（如果需要），并触发传输。[SWS_Can_00059] CAN到内存的数据映射定义为首先发送的CAN数据字节为数组元素0，最后发送的CAN数据字节为数组元素7或63（在CAN FD的情况下）。（SRS_SPAL_12063）[SWS_Can_00427] 如果CAN硬件缓冲区内部表示与AUTOSAR定义不同，则Can模块必须为上层提供适应的SDU缓冲区。⌋。
CANOpen协议详解（二）：协议具体内容
热门推荐
行者无疆的博客
02-28 1万+
根据CANOpen的官方文档，详解协议底层内容，并结合CANfestival源码进行分析，透彻了解CANOpen最底层的通信协议。
CanFestival 的buildPDO解析
shijie231的博客
06-26 2274
/*! **功能：从机把第numPdo个TPDO对应的数据封装到Message 包中 ** ** @param d ** @param numPdo TPDO_com TPDO communication parameters OD entry TPDO_map TPDO mapping parameters OD entry ** @param pdo can数据包 ** ** @return ...
canFestival移植（2）
agony_isolate的博客
06-13 4282
前序 前面一篇文章后，其实基本上就可以让canFestival运行起来了，但是移植过程中，你可能还有以下萌币： （1）“核心层”中的timer.c到底有什么作用？跟drivers下面的硬件定时器到底是怎么交互的？ （2）“核心层”怎么使用到drivers下面的can硬件接口？ （3）怎么生成对象字典啊？应用层应该怎么使用呀？ （4）用户业务逻辑咋设计啊？ 通过这篇文章，大家会进一步加强移植的信心。 “核心层”time.c分析 （1）TimeDispatch()函数分析。分析的大部分注释放在源码里面。 voi
CANopen原理--NMT状态机
ethercat_i7的博客
08-01 1万+
本文介绍CANopen中的NMT状态机，及在CanFestival中的实现过程。 一、NMT状态机 CANopen中状态机包含4个状态：Initialisation、Pre-operational、Operational和Stopped。 相互之间的关系和跳转条件如下： 其中，从Initialisation到Pre-operational的跳转一般是从节点自动完成的，其它跳转一...
CanFestival 源码剖析
weixin_44161807的博客
04-02 2932
CanFestival 源码剖析 ObjDict struct_CO_Data结构体： 大多数内容都在这个结构体里 （1）valueRangeTest函数主要是在设置对象字典时被调用，里面主要检查紧急报文的范围 （2）每个子索引都定义了一个数组 （3）ObjDict_objdict...
STM32H743+CubeIDE-CanFestival实现两个CANopen Master同时独立运行
wallace89的博客
12-14 3458
文章目录一. 前言1.1 两路CANopen Master解决的问题1.2CanFestival库移植1.3 STM32H743二. 两套对象字典三. CanFestival-接口函数canSend() 一. 前言 1.1 两路CANopen Master解决的问题 CAN的最大的缺点是通讯波特率最高只有1M，当某一路CAN总线上的从站数量多且通讯的数据量大的话，CAN总线负载率就会很高，从而导致一些通讯问题。如果控制器同时独立运行两个CANopen Master，同时带起两路CAN总线的话，总线负载率的问
canfestivel-回调函数
最新发布
09-22
canfestivel-回调函数是指通过调用RegisterSetODentryCallBack函数将自定义的回调函数注册到对应索引的对象中。具体的实现步骤是先定义回调函数_cb_RPDO1，然后调用RegisterSetODentryCallBack函数，将该回调函数...
CANFestival 源码及搭建全套资料
12-08
1. CANFestival 源码 2.Python 3.wxPython 4.Gnosis 参考文档链接: https://blog.csdn.net/mobei1983/article/details/110879850
CANOpen协议详解（一）：CANfestival源码分析
李肖遥的专栏
10-28 9079
CANFestival-3源码详解一：重要结构体 有几点需要说明： 1.使用的是官网下载的canfestival-3源代码，下载的压缩包文件名是：Mongo-canfestival-3-asc-1a25f5151a8d.zip，使用的是源码里面自带的对象字典编辑器来生成对象字典文件； 2.主要解析源码里面与DS 301协议有关的代码，DS 301协议参考文档为301_v04000201.pdf； 3.推荐一个文档叫《CANopen轻松入门》，介绍了CANopen的基础知识，广州致远电子出品，写的非常好。还推
canfestival_中的协议栈的状态机
zaichen321的博客
02-27 635
canfestival源码分析
canFestival移植（3）-----SDO快速收发函数应用分析
agony_isolate的博客
06-20 6555
前序 通过前2篇文章后，我相信大家对系统有了比较深入的理解，并且能够理解移植后，系统是怎么工作的，SDO报文是使用比较经常的一种报文，本篇文章分析一下怎么使用SDO收发报文，进一步理解canFestival。 发送SDO报文请求 （1）成功发送并且成功收到响应。 （2）发送之后响应超时。 ...
CanOpen学习笔记5-- CanFestival使用提示
choujize1282的博客
08-01 2287
1，PDO Parameter Callbacks设置调用：PDO初始化程序中，会设置其三个参数Transmission type、Inhibit time、Event timer对应的回调函数，当这三个值改变时会发送一个PDO帧（帧内容与上一次一致则不发送）。 2，PDO Mapping ...
基于HAL库的CAN通信三：移植canopen
sdhj21的博客
06-15 1151
主要学习资料：https://www.bilibili.com/read/readlist/rl452550?我的程序：链接：https://pan.baidu.com/s/1l4eilc0nTYkisgUeleiSww?由于我的定时器最大计数周期为5000，TIMEVAL_MAX不能超过最大计数周期，这里我设置为2000。根据定时器配置进行修改。例如，我的定时器时钟是72MHz，72分频，对应一次计数就是1us，协议栈：canfestival；
CANopen原理--PDO
ethercat_i7的博客
08-02 1万+
本文介绍CanFestival中的PDO发送过程。 一、PDO通信参数 数据字典0x1400~0x15FF定义了RPDO的通信参数，0x1800~0x19FF定义了TXPDO的通信参数，例如1801定义了TPDO1的通信参数： //TestSlave.c /* index 0x1800 : Transmit PDO 1 Parameter. */ ...
2.canfestivel-回调函数
gzggyg
10-19 4046
当从站收到主站发来的RPDO数据之后，怎么去执行特定的操作呢？ 只需要编写回调函数并注册到相应的索引对象就可以。 索引回调函数的原型在objdictdef.h定义，如下所示 typedef UNS32 (*ODCallback_t)(CO_Data* d, const indextable *, UNS8 bSubindex); typedef struct td_subindex { ...
CanOpen协议【CanFestival】移植到STM32
bood123的专栏
10-20 1万+
转自http://bbs.21ic.com/icview-878522-1-1.html 前段时间学习了CanOpen协议，到网上下载的CanFestival3-10源码，移植到VC、QT、STM32等平台，由于网上的资源较少，走了不少弯路，移植好使用过程中才逐渐暴露出各种问题，比如OD字符串传输、心跳时间不准确等等，现在已经解决了遇到的所有问题，移植出来的工程能够完好支持CanOpen协议
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值