这说明问题不是代码本身，而是 运行环境差异，尤其是 当前工作目录（Current Working Directory, CWD） 和 路径配置。

在 VSCode 中运行 ROS 节点时，它默认使用你打开的 工作区根目录 或 launch.json 中指定的 cwd。

而在外部终端中运行节点时，当前工作目录 可能是你当前所在的目录（比如 ~、/home/user、/tmp 等），而不是你的 ROS 工作空间目录（如 ~/catkin_ws）。

如果你的代码中使用了相对路径（如 "output.txt"），那么生成的文件会出现在当前工作目录下。

在虚拟机中（如 VirtualBox + 共享文件夹 / VMware 共享文件夹），某些路径可能因为权限限制导致无法写入文件。

如果你的代码是通过 ROS 参数服务器获取路径（如 ~output_dir），那么：

在你的 ROS 节点中加入以下代码（C++ 示例）：

Python 示例：

这样你就可以看到在不同环境中运行时的工作目录是否一致。

如果你的代码中写文件使用的是相对路径：

那文件会写入到当前工作目录中。

建议改成绝对路径或根据 ROS 参数配置路径：

或者使用 ros::package::getPath() 获取包路径：

在终端中运行：

或在虚拟机中搜索整个系统：

确认文件是否真的没有生成，还是只是不在你预期的位置。

如果你的路径是共享文件夹（如 VirtualBox 共享文件夹），尝试在终端中运行：

确保当前用户有写权限。你也可以尝试手动创建一个测试文件：

如果失败，说明权限有问题。

修改代码，使用参数服务器配置输出路径：

启动时加载参数：

你可以手动指定工作目录运行节点：

或者使用 --cwd（仅限 rosrun 支持）：

如果你用 roslaunch，可以在 .launch 文件中指定工作目录：

你可以写一个最小可复现问题的测试程序，例如：

然后分别在 VSCode 和外部终端运行，看是否能生成文件，这样可以快速定位是否是路径问题。

如果你愿意贴出部分代码片段，我可以帮你具体分析路径写入逻辑。

在使用sophus库的时候可能会遇到如上的错误。这可能是由于系统中安装了ros自带的sohups库的原因。 运行

sudo apt-get remove ros-kinetic-sophus

卸载系统自带的sophus库，再次编译即可。

1.1 禁用原有的驱动

如果你之前安装了Nvidia的开源驱动，即通过apt-get 安装的驱动。则需要先把开源驱动禁用掉。

lsmod | grep nouveau #检测Nouveau是否开启，有输出则开启，无输出则为开启
#若Nouveau开启，执行以下命令
sudo gedit /etc/modprobe.d/blacklist-nouveau.conf #创建blacklist文件
# 在创建的文件中输入以下内容关闭掉Nouveau
blacklist nouveau
options nouveau modeset=0
# 更新list，使得更改生效
sudo update-initramfs -u

然后再官网下载CUDA安装文件，推荐下载.run的文件

1.2 进入文本模式，禁用图像显示

下载完成后同时按下 Ctrl + Alt + F1进入文本模式，按照提示登入用户名密码。
然后执行下面指令关闭图形界面

sudo service lightdm stop

1.3 安装CUDA

执行

sudo sh cuda_9.2.148_396.37_linux.run

根据安装过程的提示进行安装，一般默认就可以了。推荐安装上自带的驱动，防止自己安装驱动版本对不上。

1.4 设置环境变量

安装完成之后会提示设置环境变量，根据提示设置就可以了
在.bashrc文件中添加下面的内容

export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64

1.5 测试一下

bash
nvcc -V

正常应该会显示出CUDA的版本信息。

2. 下载安装SDK

从官方下载SDK

执行

chmod +x zed_sdk_file
./zed_sdk_file

按照提示安装就可以了

3. 运行测试程序

cd /usr/local/zed/tools
./ZED\ Depth\ Viewer

一切正常应该可以看到下图所示的画面。

4. 安装ROS驱动

cd [to your workspace]/src
git clone https://github.com/stereolabs/zed-ros-wrapper
cd ..
catkin_make -DCATKIN_WHITELIST_PACKAGES="zed_wrapper"

5. 测试ROS驱动

等待编译完成

roslaunch zed_display_rviz display.launch

正常即可看到下面的显示了

[git-bloom-patch trim]: You are trying to set the trim sub directory to xiaoqiang_navigation/xiaoqiang_navigation, but it is already set to xiaoqiang_navigation.
 [git-bloom-patch trim]: Changing the sud directory is not advised. If you are sure you want to do this, use '--force'

这是由于软件包的路径发生了改变，但是release软件源内仍然存储着以前的包结构。
比如原来xioqiang_navigation是一个软件包，我把多个包放到了这个包内，结果包的路径就成了xiaoqiang_navigation/xiaoqiang_navigation。

解决方法就是直接修改release 软件源内的记录。比如发布到kinetic版本
找到patchs/release/kinetic/xiaoqiang_navigation分支，打开patches.conf文件
将trim中包的路径改成当前的路径。
比如我的情况就是

[patches]
	trim = xiaoqiang_freenect/xiaoqiang_freenect
	base = 4ecb3b9
	trimbase = a145a72
	parent = upstream
	previous = 38bc215

改动完成后提交就可以了。
再次执行发布指令就不会有错误了。

系统下载地址

首先保证机器能够正常运行Android,基础固件没有问题。下载完成后解压文件

设置机器开关

刷系统前需要让板子开机后进入fastboot模式，这个可以通过设置板子上的开关完成。把开关状态设置成On Off On Off。然后上电启动。

刷入Debian 系统

在Linux下刷入Debian系统

如果你是Linux系统则按照此处的指令刷入Debian系统

#进入解压后的文件夹
fastboot flash xloader sec_xloader.img
fastboot flash ptable prm_ptable.img
fastboot flash fastboot l-loader.bin
fastboot flash fip fip.bin
fastboot flash boot boot2grub.uefi.img
fastboot flash system rootfs.sparse.img
# 注意刷入系统文件的过程需要很多时间，需要耐心等待
# 刷入分区表
wget http://www.bwbot.org/s/uhzKfx -O '64gtoendprm_ptable.img'
fastboot flash ptable 64gtoendprm_ptable.img

在Windows 下刷人Debian系统

如果你是在Windows环境下刷入Debian系统则执行下面的指令

#进入解压后的文件夹
.\update_Hikey970.bat

整个刷入时间要很久，需要耐心等待
刷入完成后再次刷入分区表
分区表下载地址
下载完成后放入当前文件夹执行下面的指令

fastboot.exe flash ptable 64gtoendprm_ptable.img

启动系统

拔掉板子的电源，将开关拨至 On Off Off Off 状态，然后上电。等待板子启动完成。给板子插上网线，这时候可以看到网口的灯在闪烁。说明板子已经正常启动了。

在路由器上查找板子的ip

正常情况下应该能够看到如图所示的设备。然后通过ssh 连接就可以了。用户名和密码都是hoperun

ssh hoperun@xxx.xxx.xxx.xxx

安装常用工具

sudo apt-get install bash-completion #增加自动补全功能
sudo apt-get install htop #查看系统资源使用情况工具
/bin/bash -c "$(curl -sL https://git.io/vokNn)" #安装apt-fast，安装软件更快

安装ROS

ROS的安装过程和一般的ROS版本安装是一样的，但是奇怪的是我的源里面没有找到kinetic版本。下面安装的是melodic版本。可能是这个版本的Debian只支持melodic。

添加ROS软件源

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

添加key

sudo apt-fast update
sudo apt-fast install dirmngr
sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116

开始安装

sudo apt-fast update
sudo apt-fast install ros-melodic-desktop-full -y

配置环境

sudo rosdep init
rosdep update
echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
source ~/.bashrc

安装编译软件包依赖

sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential

测试一下

成功了！

ImportError: No module named srv under tf2_msgs

机器已经安装了ros jade完整版，在/opt/ros/jade/lib/python2.7/dist-packages/tf2_msgs目录下也有srv目录，应该没问题的。
google一番，发现有人反应是python包名字问题(http://www.aichengxu.com/view/75748)，但tf2_msgs是官方包，自然不存在这个问题。
回想一下今天对系统的改动，白天升级了一下jade版本的tf2包，但因为bullet依赖问题，升级到一半就放弃了（这个依赖问题可以参考http://answers.ros.org/question/220676/how-to-install-bullet-on-indigo-in-ubuntu/）。
重新catkin_make 了下ros工作目录，然后仔细翻看了一下ros工作目录的devel目录，发现/home/xiaoqiang/Documents/ros/devel/lib/python2.7/dist-packages目录下竟然还有tf2_msgs文件夹，但里面没有srv目录。
所以找到问题根源了

一个ROS python包即使从工作目录删除了，catkin_make命令也不会删除之前残留在devel目录下的文件夹
rosrun 和 roslaunch 运行节点程序时，优先查找用户工作目录，导致尝试从一个残留文件夹加载运行文件，这就导致了开头的问题

左侧是程序的log输出右侧是画出的角度图。

程序的整体结构也是比较简单的。由手机端发送舵机控制指令到装有ros系统的电脑。电脑收到数据后，从数据中取出各个舵机的角度，同时创建一个叫做monitor的topic。然后把角度信息通过这个topic发送出去。rqt_plot监听这个topic就可以画出各个舵机的实时的角度图了。

ok，开始写这个ros的package吧。

首先，创建一个ros workspace

cd ~/Documents
mkdir -p ros/workspace/src
cd ros/workspace/src
catkin_init_workspace
cd ..
catkin_make
source devel/setup.sh

这时会发现目录结构如下图

接着创建一个ros package

catkin_create_pkg statusmonitor std_msgs rospy roscpp
roscd statusmonitor

现在的目录结构应该如上图所示

src文件夹内创建monitor.py内容如下

#!/usr/bin/env python
# license removed for brevity
import rospy
import socket
from statusmonitor.msg import *
import cmds as Commands
import threading

PACKAGE_HEADER = [205, 235, 215]
dataCache = []

def getDataFromReq(req):
    pass

def unpackReq(req):
    global dataCache
    res = []
    packageList = splitReq(req)
    # process the first package
    completeData = dataCache + packageList[0]
    packageList.remove(packageList[0])
    packageList =  splitReq(completeData) + packageList

    for count in range(0, len(packageList)):
        if len(packageList[count]) != 0 and len(packageList[count]) == packageList[count][0] + 1:
            res.append(packageList[count][1:])
    lastOne = packageList[-1:][0] # the last one
    if len(lastOne) == 0 or len(lastOne) != lastOne[0] + 1:
        dataCache = lastOne
    return res


def findPackageHeader(req):
    if len(req) < 3:
        return -1
    for count in range(0, len(req) - 2):
        if req[count] == PACKAGE_HEADER[0] and req[count + 1] == PACKAGE_HEADER[1] and req[count + 2] == PACKAGE_HEADER[2]:
            return count
    return -1

def splitReq(req):
    res = []
    startIndex = 0
    newIndex = 0
    while True:
        newIndex = findPackageHeader(req[startIndex:])
        if newIndex == -1:
            break
        res.append(req[startIndex: startIndex + newIndex])
        startIndex = newIndex + 3 + startIndex
    res.append(req[startIndex:])
    return res

def parseData(cmds):
    res = None
    for count in range(0, len(cmds)):
        if chr(cmds[count][0]) == Commands.CMD_STEER_SET:
            if cmds[count][1] == 1:
                res = Steer1()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub1.publish(res)
            if cmds[count][1] == 2:
                res = steer2()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub2.publish(res)
            if cmds[count][1] == 3:
                res = steer3()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub3.publish(res)
            if cmds[count][1] == 4:
                res = steer4()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub4.publish(res)
            if cmds[count][1] == 5:
                res = steer5()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub5.publish(res)
            if cmds[count][1] == 6:
                res = steer6()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub6.publish(res)
            if cmds[count][1] == 7:
                res = steer7()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub7.publish(res)
            if cmds[count][1] == 8:
                res = steer8()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub8.publish(res)
            if cmds[count][1] == 9:
                res = steer9()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub9.publish(res)
            if cmds[count][1] == 10:
                res = steer10()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub10.publish(res)
            if cmds[count][1] == 11:
                res = steer11()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub11.publish(res)
            if cmds[count][1] == 12:
                res = steer12()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub12.publish(res)
            if cmds[count][1] == 13:
                res = steer13()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub13.publish(res)
            if cmds[count][1] == 14:
                res = steer14()
                res.angle = cmds[count][2] * 0xff + cmds[count][3]
                pub14.publish(res)
    return res

class handleSocket(threading.Thread):

    def __init__(self, conn, addr):
        threading.Thread.__init__(self)
        self.conn = conn
        self.addr = addr

    def run(self):
        print 'Connection address:', addr
        while 1:
            data = conn.recv(BUFFER_SIZE)
            if not data: break
            conn.send(data)  # echo
            rospy.loginfo(data)
            dataList = []
            for c in data:
                dataList.append(ord(c))
            parseData(unpackReq(dataList))

        conn.close()




if __name__ == '__main__':

    pub1 = rospy.Publisher('monitor_steer1', Steer1, queue_size=10)
    pub2 = rospy.Publisher('monitor_steer2', steer2, queue_size=10)
    pub3 = rospy.Publisher('monitor_steer3', steer3, queue_size=10)
    pub4 = rospy.Publisher('monitor_steer4', steer4, queue_size=10)
    pub5 = rospy.Publisher('monitor_steer5', steer5, queue_size=10)
    pub6 = rospy.Publisher('monitor_steer6', steer6, queue_size=10)
    pub7 = rospy.Publisher('monitor_steer7', steer7, queue_size=10)
    pub8 = rospy.Publisher('monitor_steer8', steer8, queue_size=10)
    pub9 = rospy.Publisher('monitor_steer9', steer9, queue_size=10)
    pub10 = rospy.Publisher('monitor_steer10', steer10, queue_size=10)
    pub11 = rospy.Publisher('monitor_steer11', steer11, queue_size=10)
    pub12 = rospy.Publisher('monitor_steer12', steer12, queue_size=10)
    pub13 = rospy.Publisher('monitor_steer13', steer13, queue_size=10)
    pub14 = rospy.Publisher('monitor_steer14', steer14, queue_size=10)

    rospy.init_node('talker', anonymous=True)


    TCP_IP = '0.0.0.0'
    TCP_PORT = 50000
    BUFFER_SIZE = 1024  # Normally 1024, but we want fast response


    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((TCP_IP, TCP_PORT))
    s.listen(1)
    while 1:
        conn, addr = s.accept()
        handleSocket(conn, addr).start()

从程序入口开始说明。首先创建了一系列的ros的publisher，这个可以用来向topic发送信息。然后初始化ros节点。
接着创建一个socket，监听发送由机器人控制端发送来的指令数据。收到数据后就把数据包解开，提取处各个舵机的角度，通过最开始创建的publisher发送出去。

主程序就是这样，下面开始创建ros message。在src文件夹内创建msg文件夹，并在其中创建Steer1.msg到Steer14.msg，这些文件的内容都是一样的

float32 angle

float32 res

msg文件就是表明msg的格式的文件。之后编译包的时候这些文件会被编译成c++文件和python文件。
接着就是修改makefile，因为msg是需要编译的嘛。

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)

第一步就是在find_package中添加message_generation
然后添加msg文件

add_message_files(
   FILES
   Steer1.msg
   Steer2.msg
   Steer3.msg
   Steer4.msg
   Steer5.msg
   Steer6.msg
   Steer7.msg
   Steer8.msg
   Steer9.msg
   Steer10.msg
   Steer11.msg
   Steer12.msg
   Steer13.msg
  )

在generate msg 添加 std_msg

generate_messages(
   DEPENDENCIES
  std_msgs
)

在依赖中加入message_runtime

catkin_package(
# INCLUDE_DIRS include
LIBRARIES statusmonitor
CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
#  DEPENDS system_lib
)

到这里就应该差不多了。

开始编译

cd ~/Documents
cd ros/workspace/src
catkin_make

如果输出如下图就说明编译正确

下一步就是开始运行了

source devel/setup.sh
rosrun statusmonitor monitor.py

这样当收到控制端发送来的数据时就会如下显示

在一个新终端中启动rqt_plot,然后选择想要观察的topic就行了