b2256's profile - activity

Relative noob having enough knowledge to get into trouble.... Attempting to compile robot_localization package (along with a couple of drivers- ublox gps and christa imu). Goes along fine at first:

#### Running command: "make cmake_check_build_system" in "/media/sdcard/catkin_ws/build"
####
####
#### Running command: "make -j1 -l1" in "/media/sdcard/catkin_ws/build"
####
[  1%] Built target filter_utilities
[  1%] Built target _robot_localization_generate_messages_check_deps_SetDatum
[  1%] Built target geometry_msgs_generate_messages_cpp
[  1%] Built target std_msgs_generate_messages_cpp
[  1%] Built target _robot_localization_generate_messages_check_deps_SetPose
[  1%] Built target geographic_msgs_generate_messages_cpp
[  2%] Built target robot_localization_generate_messages_cpp
[  2%] Built target robot_localization_gencpp
[  3%] Built target filter_base
[  3%] Built target ekf
[  4%] Built target ros_filter_utilities
[  5%] Built target ukf
[  5%] Building CXX object robot_localization/CMakeFiles/ros_filter.dir/src/ros_filter.cpp.o
In file included from /opt/ros/indigo/include/ros/ros.h:40:0,
                 from /opt/ros/indigo/include/tf2_ros/buffer.h:38,
#################################################################
Then fails at the very end of the compilation:
                                  ^
/opt/ros/indigo/include/rosconsole/macros_generated.h:60:36: note: in expansion of macro ‘ROS_LOG’
 #define ROS_DEBUG_NAMED(name, ...) ROS_LOG(::ros::console::levels::Debug, std::string(ROSCONSOLE_NAME_PREFIX) + "." + name, __VA_ARGS__)
                                    ^
/opt/ros/indigo/include/tf2_ros/message_filter.h:53:3: note: in expansion of macro ‘ROS_DEBUG_NAMED’
   ROS_DEBUG_NAMED("message_filter", "MessageFilter [target=%s]: ", fmt, getTargetFramesString().c_str(), __VA_ARGS__)
   ^
/opt/ros/indigo/include/tf2_ros/message_filter.h:282:5: note: in expansion of macro ‘TF2_ROS_MESSAGEFILTER_DEBUG’
     TF2_ROS_MESSAGEFILTER_DEBUG("%s", "Cleared");
     ^
virtual memory exhausted: Cannot allocate memory
make[2]: *** [robot_localization/CMakeFiles/ros_filter.dir/src/ros_filter.cpp.o] Error 1
make[1]: *** [robot_localization/CMakeFiles/ros_filter.dir/all] Error 2
make: *** [all] Error 2
Invoking "make -j1 -l1" failed
ubuntu@arm:/media/sdcard/catkin_ws$
#############################

This is being performed on a Beaglebone Black with: Linux arm 4.1.1-ti-r2 #1 SMP PREEMPT Wed Jul 8 18:40:57 UTC 2015 armv7l armv7l armv7l GNU/Linux

I am out of ideas now. There should be plenty of memory:

ubuntu@arm:/media/sdcard/catkin_ws$ free
             total       used       free     shared    buffers     cached
Mem:        502088      43824     458264        380       3104       9768
-/+ buffers/cache:      30952     471136
Swap:            0          0          0

Any ideas are gratefully accepted! Perhaps this is too much for this board/sd card mix? (sd card is vfat FAT32) Thanks in advance, B2256

Thank you allenh1.

It seems that I was also able to find an answer based upon the swap file solution while waiting for answers. Other BBB users may also try this for a similar solution. It turns out that allenh1's point of the BBB only having 512MB is well founded and that "anything non-trivial will fail to compile with an out-of-memory error" according to the second source. Compiling was slow as noted, but appears to work aside from a clock skew warning. Thank you all again.

Wrote a custom message and am attempting to publish (via bagfile playback) for use in another node . The python roll/pitch/yaw is based upon this previous answer(link text ), although poorly executed on my part. (License omitted for brevity) The remaining dependent code is at this Dropbox link: https://www.dropbox.com/sh/u3kznp4oiy...

   #!/usr/bin/python
# -*- coding: utf-8 -*-
#subscribes to quaternions, converts quaternions to Euler angles, and then publish the Euler angles. The Euler angles are in a custom message
# Start up ROS pieces.
PKG = 'loc2orbgt'
import roslib; roslib.load_manifest(PKG)
import rospy
import math
import tf

# ROS messages.
from nav_msgs.msg import Odometry
from sensor_msgs.msg import Imu
from loc2orbgt.msg import Eulers

class QuatToEuler():
    def __init__(self):
        self.got_new_msg = False
        self.euler_msg = Eulers()

        # Create subscribers and publishers.
        #sub_imu   = rospy.Subscriber("imu/data", Imu, self.imu_callback)
        sub_rlocl  = rospy.Subscriber("odometry/filtered", Odometry, self.rlocl_callback)
        pub_euler = rospy.Publisher("euler", Eulers,queue_size=1)

        # Main while loop.
        while not rospy.is_shutdown():
            # Publish new data if we got a new message.
            if self.got_new_msg:
                pub_euler.publish(self.euler_msg)
                rate = rospy.Rate(15) # 15hz
                self.got_new_msg = False

    # Odometry callback function.
    def rlocl_callback(self, msg):
       # Convert quaternions to Euler angles.
       (r, p, y) = tf.transformations.euler_from_quaternion([msg.pose.pose.orientation.x, -msg.pose.pose.orientation.y, -msg.pose.pose.orientation.z, -msg.pose.pose.orientation.w]) 

       #(r, p, y) = [r*180/math.pi, p*180/math.pi, y*180/math.pi]
       (r, p, y) = [r*180/math.pi, p*180/math.pi, (y*180/math.pi)+(11.8599971761+90)]
       self.fill_euler_msg(msg, r, p, y)

    # Fill in Euler angle message.
    def fill_euler_msg(self, msg, r, p, y):
        self.got_new_msg = True
        self.euler_msg.header.stamp = msg.header.stamp
        self.euler_msg.roll  = r
        self.euler_msg.pitch = p
        self.euler_msg.yaw   = y

# Main function.    
if __name__ == '__main__':
    # Initialize the node and name it.
    rospy.init_node('quat_to_euler')
    # Go to class functions that do all the heavy lifting. Do error checking.
    try:
        quat_to_euler = QuatToEuler()
    except rospy.ROSInterruptException: pass

The code (q2_rpy.py) seems to work fine, but I found that the second node ( a time syncro node) would not initiate after being called by the launch file. Upon further investigation, it turns out that the former rpy code was using waaaay too much cpu. (See Screenshot).

Could it be that is the reason for second node not subscribing? Is there a better way regarding loop efficiency? Not sure where to go from here as the second node has a dependency on this one. As always, any insight will be greatly appreciated.

B2256

Old question but I thought it might help someone else with an answer. Turns out that the filter buffer was being overra

I'm currently attempting to fine-tune an instance of (ekf) robot_localization using gps and single imu devices. In doing so, the diagnostic topic lists:

- 
    level: 1
    name: ekf_localization: Filter diagnostic updater
    message: Potentially erroneous data or settings detected for a robot_localization state estimation node.
    hardware_id: none
    values: 
      - 
        key: imu0_pose_covariance
        value: The covariance at position (35), which corresponds to YAW variance, was zero. This will be replaced with a small value to maintain filter stability, but should be corrected at the message origin node.
  -

The location of “position (35)” YAW covariance eludes me in attempting to revise the value. I've searched all the code for robot_localization and the code for the Phidgets 1044 imu to no avail. The ekf_localization launch file initial covariance is set (currently at a non-zero value of 0.035). The "message origin node" is the elusive part.

Aside from the ekf_localization initial_estimate_covariance, is there anywhere left to look for modification?

Thanks in advance for any insight.

B2256

Just made a run with my assembly of gps/imu/BeagleBone Black on a vehicle platform. While running the ekf filter, I performed a topic speed check on the /gps/filtered topic while recording a bagfile. It turns out that doing so, greatly reduces the output from about 26 Hz to 5 Hz! Must be out of bandwidth?

Can I pull the input data from the bagfile and rerun the filter through post-processing later? Or is the sim time issue going to play into it?

Thanks as always,

B2256

Although not an answer, my solution was to post-process raw bagfiles. Not clean, but seems to overcome this problem.

Thank you Tom. That verifies my assumptions. Still tuning Q matrix and hoped that effort would apply to both ekf and ukf. Regards.

Attempting to compare results from both ekf and ukf (ubuntu, indigo). Would one expect to use the same process noise covariance matrix for both? Thanks

Still cannot get returned sync messages. Queue length or slop- neither seems to matter, yet the loginfo prints?? What else can affect this?

Hi All:

I am using message_filters (python) ApproximateTimeSynchronizer to sync two topics in a class; one custom rpy msg (tat_bry) and output from robot_localization's navsat_transform (/gps/filtered). Both nodes appear in the default (/) namespace. The callback (see code snippet below) seems to be working as my roslog text message comes through "syncing'. When echoes for both topics, are initiated, there appears a difference in sequence numbers of around 5 and a disparity between topics of a maximum of slightly more than .06s using a 'slop' of 0.033s. After reading the documentation for both the C++ and Python version, I chose this value as 1/2 of the 16Hz frequency of 0.0625/s or about 0.033s.

After many forms of experimenting with queue sizes, and 'slop' parameters, changing input frequencies and namespaces to no avail; I cannot produce a synchronized set between the two topics. I wonder after looking at the affected portion of the node diagram, it appears that echoing the topics may be taking place prior to the synchronization?

Is there a way to echo the resultant output stream of the callback (after sync)? Are the topics spread too far to sync using this filter? I've used this filter before and did not seem to have this issue.

Using Ubuntu 14.04LTs, Indigo

Any insight is greatly appreciated.

B2256

class AflSync():
def __init__(self):
    self.got_new_msg = False
    self.tat_bry_msg = TatBry()
    self.sync_msg = Sync_orb()

# Create subscribers and publishers
# subscriber to message_filters module and assigning to local class variable
    self.sub_gps = Subscriber("gps/filtered", NavSatFix)
    self.sub_rpy = Subscriber("tat_bry", TatBry)
# Synchronize topics
    ts = ApproximateTimeSynchronizer([self.sub_gps, self.sub_rpy], 2, 0.033)
    ts.registerCallback(self.cb_aflsync)

def cb_aflsync(self, sync_msg, tat_bry_msg):

    r = rospy.Rate(16) # 16hz
    rospy.loginfo('syncing')


    # Main while loop.
    while not rospy.is_shutdown():

        r.sleep()

afl_sync_node2.jpg

I've run into a seemingly simple issue that I cannot solve. I have a working model that takes sensor outpput and synchronizes messages using the python version of ApproximateTimeSynchronization. The issue likely is remapping related, but I cannot seem to produce output topics from the synchronization node to verify syncro topics. My launch file is:

launch>

        <node pkg="bag2orb" type="ned_rpy_imu.py" name="afl_tatbry_node"> 
        <remap from="tat_bry" to="tat_bry"/> 
        </node>


         <node pkg="bag2orb" type="afl_apprxtimesync_node.py" name="aflsync_node"> 
                <remap from="tat_bry" to="tatbryout"/>  
                <remap from="gps/filtered" to="gpsout"/>   
         </node>         

  </launch>

And a partial node map:

I've read the documentation on remapping and have been unsucessful remapping both topics to another relative topic. From the log files, the syncro seems to be working. What syntax am I missing for either ApprTimeSynchro or general remapping? My desire is to republish the synchronized topics under the remapped names.

Any insight would be greatly appreciated.

Thank you,

B2256

In reference to this question , the desired conversion is the opposite direction. That is using tf.transformations.euler_from_quaternion function, taking the result from robot_localization of /odometry/filtered topic, my attempt is to unravel the quaternion from the ENU convention to NED convention. The end result should be pitch, yaw, and roll using the aviation (NED) convention.

My interpretation is that one must first change back (from ROS ENU) the signs of y and z, followed by “unwinding” the quaternion to euler from 'rzyx' to 'rxyz' per the documentation for euler_from_quaternion definition and the question response: “q = tf.transformations.quaternion_from_euler(yaw, pitch, roll, 'rzyx')”

My question: Is my interpretation correct? Any insight is greatly appreciated.

B2256

Since this post is somewhat dated, can I ask if it applies REP-103 using ENU? If so what needs to be changed to convert rpy back to NED coordinate frame convention?