canfestival从站测试NMT节点切换状态功能时遇到问题

发布于 2025-01-15 16:27:29 浏览：277 订阅该版

[tocm]

在用canfestival做从节点NMT状态切换时遇到了问题，请教各位大佬。
# 大致背景说明：
1、参考canfestival包里的例程master402源码，修改成从站TestSlave。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/9a2f867604383a9c052598ff16f25b00.png)

2、测试板卡芯片STM32F407作为从站，NodeID = 2。为了最大程度简化功能目前从站只配置了心跳报文，5秒一次心跳（0x1388 = 5000 ms）。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/37651d6107553e86ecfeea1a733dc136.png)

3、PC作为主站，使用CANPro软件收发报文，并且板卡上电运行后可以正常收到每隔5秒的心跳报文。
**（顺便请教，下图中打印信息中间夹杂了一些不完整的字符是什么原因？）**

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/7f07ce4a4370bd019deda2cd402ebd79.png)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/aab9078ecf9e1be434b2f9a6792bc2ed.png.webp)

4、部分切换功能可以成功（如下图从Pre-Operational切至Stop）：

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/879eae0838da619303c62558561d9119.png.webp)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/fad72424b3573e4043ba7e43d99a8e22.png)

5、rt-thread版本：4.1.0

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/597b2279b32c8d8718726c5d15923ffe.png)

6、之前开启了硬件滤波器HDR测试遇到了其他问题，目前暂时关闭了HDR。

# 问题：
**其他大部分的状态切换都会报不一样的错误，最常见的错误为以下两种。**
1、从Stop状态切到preOperational状态时，报错：(obj != object) assertion failed at function:rt_object_init, line number:358

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/f730b1a3267164dcc3039cee1e4ca908.png.webp)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/59b6fd62e9944628b46343f9325d8139.png)

2、从preOperational状态切到Operational状态时，报错：thread: stack overflow

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/793ba4d587243d6557a6cf3ad48649e7.png.webp)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250115/a2a1bd7aa8fdbc87bfa6b18b5af7da95.png)

2 个回答

NoneKnowsMe 2025-01-15

这家伙很懒，什么也没写！

# 补充：
打印信息都是在canopen_callback.c里实现的，根据打印信息可以看到从节点已经收到报文并调用了canDispatch，跳转到了指定的callback函数成功执行了打印代码。callback函数已经执行成功了为什么还会出现其他报错？

```c
/*
This file is part of CanFestival, a library implementing CanOpen Stack.

Copyright (C): Edouard TISSERANT and Francis DUPIN

See COPYING file for copyrights details.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <rtthread.h>
#include "canfestival.h"
#include "TestSlave_od.h"
#include "canopen_callback.h"
#include "TestSlave_canopen.h"

/*****************************************************************************/
void TestSlave_heartbeatError(CO_Data* d, UNS8 heartbeatID)
{
	rt_kprintf("heartbeatError %d\n", heartbeatID);
}

void TestSlave_initialisation(CO_Data* d)
{
	rt_kprintf("canfestival enter initialisation state\n");
}

void TestSlave_preOperational(CO_Data* d)
{
	rt_thread_t tid;
	rt_kprintf("canfestival enter preOperational state\n");
	tid = rt_thread_create("co_cfg", canopen_start_thread_entry, RT_NULL, 1024, 12, 2);
	if(tid == RT_NULL)
	{
		rt_kprintf("canfestival config thread start failed!\n");
	}
	else
	{
		rt_thread_startup(tid);
	}
}

void TestSlave_operational(CO_Data* d)
{
	rt_kprintf("canfestival enter operational state\n");
}

void TestSlave_stopped(CO_Data* d)
{
	rt_kprintf("canfestival enter stop state\n");
}

void TestSlave_post_sync(CO_Data* d)
{
	
}

void TestSlave_post_TPDO(CO_Data* d)
{

}

void TestSlave_storeODSubIndex(CO_Data* d, UNS16 wIndex, UNS8 bSubindex)
{
	/*TODO : 
	 * - call getODEntry for index and subindex, 
	 * - save content to file, database, flash, nvram, ...
	 * 
	 * To ease flash organisation, index of variable to store
	 * can be established by scanning d->objdict[d->ObjdictSize]
	 * for variables to store.
	 * 
	 * */
	rt_kprintf("storeODSubIndex : %4.4x %2.2x\n", wIndex,  bSubindex);
}

void TestSlave_post_emcy(CO_Data* d, UNS8 nodeID, UNS16 errCode, UNS8 errReg, const UNS8 errSpec[5])
{
	rt_kprintf("received EMCY message. Node: %2.2x  ErrorCode: %4.4x  ErrorRegister: %2.2x\n", nodeID, errCode, errReg);
}

```

# 补充2
通过进一步简化程序，目前已将所有回调函数简化为只执行一条打印语句：

```c
void TestSlave_heartbeatError(CO_Data* d, UNS8 heartbeatID)
{
	rt_kprintf("heartbeatError %d\n", heartbeatID);
}

void TestSlave_initialisation(CO_Data* d)
{
	rt_kprintf("canfestival enter initialisation state\n");
}

void TestSlave_preOperational(CO_Data* d)
{
//	rt_thread_t tid;
	rt_kprintf("canfestival enter preOperational state\n");
//	tid = rt_thread_create("co_cfg", canopen_start_thread_entry, RT_NULL, 1024, 12, 2);
//	if (tid == RT_NULL)
//	{
//		rt_kprintf("canfestival config thread start failed! \n");
//	}
//	else
//	{
//		rt_thread_startup(tid);
//	}
}

void TestSlave_operational(CO_Data* d)
{
	rt_kprintf("canfestival enter operational state\n");
}

void TestSlave_stopped(CO_Data* d)
{
	rt_kprintf("canfestival enter stop state\n");
//	if(rt_thread_delete(tid) != RT_EOK)
//	{
//	    rt_kprintf("canfestival config thread stop failed!\n");
//	}
}

void TestSlave_post_sync(CO_Data* d)
{

}

void TestSlave_post_TPDO(CO_Data* d)
{

}

void TestSlave_storeODSubIndex(CO_Data* d, UNS16 wIndex, UNS8 bSubindex)
{
	/*TODO : 
	 * - call getODEntry for index and subindex, 
	 * - save content to file, database, flash, nvram, ...
	 * 
	 * To ease flash organisation, index of variable to store
	 * can be established by scanning d->objdict[d->ObjdictSize]
	 * for variables to store.
	 * 
	 * */
	rt_kprintf("storeODSubIndex : %4.4x %2.2x\n", wIndex, bSubindex);
}

void TestSlave_post_emcy(CO_Data* d, UNS8 nodeID, UNS16 errCode, UNS8 errReg, const UNS8 errSpec[5])
{
	rt_kprintf("received EMCY message. Node: %2.2x  ErrorCode: %4.4x  ErrorRegister: %2.2x\n", nodeID, errCode, errReg);
}

```
这样改了之后暂时不会出现上面提到的问题1：从Stop状态切到preOperational状态时，报错：(obj != object) assertion failed at function:rt_object_init, line number:358
问题2仍然存在：从preOperational状态切到Operational状态时，报错：thread: stack overflow
通过debug排查目前定位到是在can_rtthread.c里的canopen_recv_thread_entry()函数，这个线程函数里用了一个while(1)循环专门接收报文：

```c
void canopen_recv_thread_entry(void* parameter)
{
    struct can_app_struct *canpara = (struct can_app_struct *) parameter;
	struct rt_can_msg msg;
	Message co_msg;

candev = rt_device_find(canpara->name);
    RT_ASSERT(candev);
    rt_sem_init(&can_data.sem, "co-rx", 0, RT_IPC_FLAG_PRIO);
    rt_err_t err = rt_device_open(candev, (RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX));
    if( err != RT_EOK) {
		LOG_E("canfestival open device %s failed, err = %d", canpara->name, err);
        return;
    }

err = rt_device_set_rx_indicate(candev, can1ind);
    if( err != RT_EOK) {
		LOG_E("canfestival set rx indicate failed, err = %d", err);
        return;
    }

rt_size_t read_size = 0;
    while (1)
    {
        err = rt_sem_take(&can_data.sem, MAX_SEM_WAIT_TIME);
        if ( err != RT_EOK)
        {
            if(getState(OD_Data) == Operational) {
                LOG_W("canfestival wait receive timeout, err = %d", err);
            }
		} else {
		    read_size = rt_device_read(candev, 0, &msg, sizeof(msg));
			if( read_size == sizeof(msg))
			{
				co_msg.cob_id = msg.id;
				co_msg.len = msg.len;
				co_msg.rtr = msg.rtr;
				memcpy(co_msg.data, msg.data, msg.len);
				EnterMutex();
				canDispatch(OD_Data, &co_msg);
				LeaveMutex();
			} else if (read_size == 0){
                LOG_W("canfestival receive faild, err = %d", rt_get_errno());
			} else {
                LOG_W("canfestival receive size wrong, size = %u", read_size);
			}
		}
    }
}
```
当测试板卡（Slave）接收到PC测试软件（Master）发送的Start切换报文时，已确实被canopen_recv_thread_entry线程函数捕捉到并成功通过canDispatch函数调用了回调函数TestSlave_operational()，打印出了信息：canfestival enter operational state。

问题出在之后，while(1)开始下一轮循环后执行err = rt_sem_take(&can_data.sem, MAX_SEM_WAIT_TIME)，然后执行到rt_sem_take()函数里的rt_schedule()，之后就发生了栈溢出现象。

尝试了将线程的栈大小改大（由原本的1024提高到4096），或者将rt_sem_take()的等待时间由原本的5000改为RT_WAITING_FOREVER，没有用。

思路卡在了这里，为什么设备上电初始化时执行while(1)里的rt_sem_take()没有问题，但是在收到一次报文执行过一次while(1)里的操作后，进入下一轮循环时却会出现问题呢？

NoneKnowsMe 2025-02-20

这家伙很懒，什么也没写！

问题2原因查到了。用canfestival-de1fc3261f21源文件和头文件替换了RT-Thread Studio内集成的canfestival文件。原来的文件是通过RT-Thread Settings里的CanFestival软件包添加的。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250220/b2c0cf9760e163fc9dce1bce05448218.png.webp)

比较了一下确实有些文件的代码不完全一样，网上很多教学文章采用的版本都是另一个版本，源码和objdictedit.py配置工具生成的.c字典文件关于回调函数ODCallback_t和子索引结构体subindex这一块的定义方式不同。导致如果用的源码包和objdictedit.py配置工具的版本不一致的话就会出现问题。

问题1原因查到了。以下是自己解读源码的一些理解，和大家分享一下，不确定都对。
样板程序是以DS402协议的主站为前提编写的。程序中节点切换到preOperational状态时会启动canopen_start_thread_entry()线程函数。

```c
tid = rt_thread_create("co_cfg", canopen_start_thread_entry, RT_NULL, 1024, 12, 2);
```
该线程函数会执行config_servo()函数，config_servo函数会创建一个finish_sem信号量，然后执行config_servo_param()函数。在config_servo_param()函数里由于传参值的原因会执行swtich里的分支case（从0开始）。
在config_servo_param()函数里调用writeNetworkDictCallBack()函数，进而调用 _writeNetworkDict()函数，这个函数里有一句

```c
d->transfers[line].Callback = Callback;
```
会把config_servo_param_cb关联为回调函数。之后sendSDO()。
如果一切顺利，sendSDO后会有对应的从节点发出SDO应答报文，线程函数canopen_recv_thread_entry()收到应答报文后调用canDispatch()函数，接着再调用proseedSDO()函数。该函数对应答报文解析处理后会调用Callback函数，即config_servo_param_cb()函数

```c
if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
```
在config_servo_param_cb()函数里通过如下代码重新调用config_servo_param()函数并执行下一条case分支：

```c
conf->state++;
conf->try_cnt = 0;
config_servo_param(nodeId, conf);
```
等config_servo_param()函数一直执行到最后一个case时，释放信号量

```c
case 28:
	rt_sem_release(&(conf->finish_sem));
	break;
default:
	break;
```
之后这个信号量会被config_servo()获取到，然后将其释放。

```c
static void config_servo(uint8_t nodeId)
{
	servo_conf[nodeId - 2].state = 0;
	servo_conf[nodeId - 2].try_cnt = 0;
	rt_sem_init(&(servo_conf[nodeId - 2].finish_sem), "servocnf", 0, RT_IPC_FLAG_FIFO);

EnterMutex();
	config_servo_param(nodeId, &servo_conf[nodeId - 2]);
	LeaveMutex();
	//获取并释放信号量
	rt_sem_take(&(servo_conf[nodeId - 2].finish_sem), RT_WAITING_FOREVER);
	rt_sem_detach(&(servo_conf[nodeId - 2].finish_sem));
}
```
至此config_servo()函数才真正完成使命，代码返回至最初说的线程函数canopen_start_thread_entry()。由于这个线程函数没有while(1)循环，是单次执行的，等它执行完后才会由空闲线程释放资源。
以上是我个人分析的程序执行过程，现在的问题出在我的测试环境里缺少可以有效应答SDO报文的从节点，而config_servo()函数里take信号量是设置成永久等待的：

```c
rt_sem_take(&(servo_conf[nodeId - 2].finish_sem), RT_WAITING_FOREVER);
```
于是程序卡在了config_servo()，导致canopen_start_thread_entry()之后的代码无法执行完成，资源始终得不到释放。
这时如果我用这套代码仿真从节点，当它接收到主节点的SDO报文切换模式时，第二次切换到preOperational模式的时候，之前未必释放的线程现在要再次creat，就产生了错误。
简单总结就是代码移植的时候改的不够彻底。