Here is a blog post that synthesizes your project proposal with the t265_json project.

The Perfect Foundation: Using t265_json for a Cellular Signal Heatmap

This is a fantastic example of “engineering re-use.” You’ve laid out a detailed proposal for an Automated Cellular Signal Strength Monitoring System, and in the process, you’ve identified that the core data pipeline is a problem you’ve already solved with your t265_json project.

Your new proposal is simple and clear: to create a heatmap of cellular signal strength, you need to log two key pieces of data simultaneously:

  1. The Signal Strength: An Android phone can easily poll this from its own cellular radio.
  2. The Precise Location: This is the hard part. How does the phone know its exact (X, Y) position inside a building where GPS is unreliable?

Your solution is to use an Intel RealSense T265 (likely held by the person walking) to get a high-quality, V-SLAM-based 2D pose (X, Y, Yaw). The entire challenge then boils down to one simple question: “How do I get the T265’s real-time pose data from its host (like a Raspberry Pi) to the Android phone that’s logging the signal?”

As you’ve correctly pointed out, this is the exact problem the t265_json project was built to solve. It’s the perfect foundation.

The Architectural Blueprint (Using t265_json)

By adapting the t265_json project, the architecture for your new cellular logger is already 90% complete. Here is how the data pipeline works:

  1. The Sensor (T265 + RPi): The T265 is connected to the Raspberry Pi. The realsense-ros driver publishes the full 6-DOF odometry data (as a geometry_msgs/Pose) to a ROS topic.

  2. The “Translator” (The t265_json Python Script): A Python script (which is the core of t265_json) runs on the RPi.
    • It subscribes to the /ros/odometry topic.
    • It simplifies the data, just as you specified in your proposal: it extracts the X, Y, and Yaw (from the Quaternion) to create a simple 2D pose.
    • It packages this 2D pose into a lightweight, universal JSON object.

  3. The “Bridge” (SocketIO Server): This same Python script uses python-socketio to create a simple web server. It “broadcasts” the JSON pose data over the local Wi-Fi network hundreds of times per second.

  4. The “Logger” (The Android App): This is the only piece that needs a minor modification.
    • Original Function: The Android app connects to the SocketIO server and receives the real-time stream of JSON pose data.
    • New Function: While it’s receiving this pose data, the app will also poll the phone’s internal API for the current cellular signal strength (e.g., in dBm).
    • The Log: Every time it gets a new pose, it will write a single line to a log file: (timestamp, x_position, y_position, signal_strength_dbm).

The Result

After walking the entire floor, you will have a complete .csv or .txt file. This data is now trivial to plot using a script (Python, MATLAB, etc.) to generate a 2D “heatmap,” just like the Wi-Fi mapping projects you referenced.

This is a brilliant and efficient design. You’ve turned a complex new project into a simple “bolt-on” for an existing, proven tool. The t265_json project isn’t just a “robot odometry visualizer”; it’s a general-purpose “pose-over-IP” bridge, and it’s the perfect solution here.

<
Previous Post
“Go Here, Then Here, Then Here”: Automating Robot Patrols with follow_waypoints
>
Next Post
Giving Robots Sight and a Sense of Place: Autonomous Navigation with Intel RealSense