GanniPiece Blog

How to Use an iPad as a ROS2 Sensor and Receive Data on a Mac

Sat, 09 May 2026 12:00:00 +0000

(the post is automatically translated by AI)

Background

I’ve been learning ROS, but I don’t have a robot at hand. My idea: use the iPad I already have as a ROS node and receive data on my Mac — sensor data like IMU, Camera, Battery, etc. — to understand how ROS nodes collect and publish data.

In this article, we’ll:

Set up the MacBook as a ROS node (using Docker)
Turn the iPad into a ROS node (using Conduit)
Receive the iPad’s sensor data on the MacBook

Setting Up the MacBook as a ROS Node (Docker)

The ROS documentation mentions installing ROS2 natively on macOS, but in practice this runs into many deprecated packages and version dependency issues. After a few rounds of debugging with Claude Code, I decided to skip native installation — my goal at this stage was to see the data format ROS2 produces, not fight with the toolchain.

Startup Journey 0002 | Why Isn't Auto-Scaling Working? The System Just Crashes

Sat, 11 Apr 2026 06:32:00 +0000

Startup Journal 0002. Starting a health check on the old system.

Startup Journey 0001 | It's There, But Also Not There

Fri, 03 Apr 2026 15:27:00 +0000

Startup Journal 0001. Our environments need to be consistent!

Startup Journey 0000 | To Join or Not To Join

Sat, 21 Mar 2026 10:00:00 +0000

Startup Journal 0000. I left a big tech company and joined a startup!

How to Install Sushi DAW on macOS

Sat, 01 Jun 2024 10:11:44 +0000

Sushi is the plugin host and DAW for the Elk Audio OS. Since version 1.0, it also supports building on macOS. This article documents how to install Sushi DAW on macOS and verify the installation.

How to Deploy Hugo to GitLab Pages and Point It to a Gandi Domain

Sat, 28 Oct 2023 03:49:22 +0000

My personal website was previously hosted on GitHub, deployed via GitHub Actions. I decided to migrate the workflow to GitLab — here's how.

How to Map MediaPipe Skeleton to Unity Humanoid

Wed, 08 Mar 2023 00:00:00 +0000

Using MediaPipe for Motion Capture and mapping the result to a Unity humanoid skeleton

Why Coroutine? (Part 2) — Implementing a Coroutine in C

Mon, 10 Oct 2022 03:00:17 +0000

(the post is automatically translated by AI)

Introduction

In the previous article, Why Coroutine? (Part 1) — Is Multithreading Not Enough?, we covered the underlying principles of Coroutines and listed the interface we need to implement one in C. In this article, we’ll walk through the code line by line.

Source code: GanniPiece/SimpleCCoroutine: A simple coroutine example implemented using C (github.com)

Background Knowledge

Before we begin, if you’re not familiar with Coroutines, please read the previous article first. In it we mentioned that we can manipulate ucontext_t [1] using four operations defined in <ucontext.h>:

Code Expansion: Macro vs Inline Function

Sat, 08 Oct 2022 16:06:04 +0000

(the post is automatically translated by AI)

Introduction

Macros and inline functions are two techniques for code reuse and expansion. Unlike regular function calls, both avoid the overhead of subroutine push/pop operations at runtime, which can speed up execution.

The key difference between them is when the expansion happens: macros are substituted by the preprocessor before compilation, while inline functions are expanded by the compiler during compilation. However, both result in larger binary sizes compared to using regular functions, since the code is duplicated at every call site.

#: The Language of the Preprocessor

Wed, 05 Oct 2022 08:30:53 +0000

The preprocessor runs before the compilation phase. It can handle conditional compilation, file inclusion, macro definitions, and more. In this article, we introduce several types of preprocessor directives, such as Conditional inclusion and Replacing text macros.

How to Use an iPad as a Wireless MIDI Controller

Thu, 14 Jul 2022 02:57:32 +0000

In this article, we document how to turn an iPad into a MIDI keyboard and receive its signals on both macOS and Windows.

How to Edit a Specific Commit Message in Git

Sun, 29 May 2022 03:27:37 +0000

(the post is automatically translated by AI)

Introduction

When using Git [1] for version control, it’s easy to accidentally make a typo in a commit message — or simply realize later that it could be worded better. In those cases, you need to go back and fix the commit message.

The basic approach is git commit --amend [2], which corrects the most recent commit message. In this article, I’ll document how to go back to an older commit — not just the last one — and edit its message for future reference.

Why Coroutine? (Part 1) — Is Multithreading Not Enough?

Sat, 28 May 2022 07:54:19 +0000

While working with UniVRM, I noticed that many Unity development scenarios rely on Coroutines — such as opening a file dialog or loading resources. In this article, I'll explain what a Coroutine is and compare it with Threads.

How to Enable and Detect Memory Leaks in the Unity Editor

Tue, 03 May 2022 06:51:18 +0000

(the post is automatically translated by AI)

Introduction

A memory leak occurs when allocated memory is never freed. While it doesn’t necessarily cause immediate crashes, a leak gradually reduces the available memory, degrading system performance over time. In severe cases, it can lead to unpredictable errors or even security vulnerabilities 1.

Memory: “Hmm? Something smells.”

One of the most common causes of memory leaks is forgetting to free dynamically allocated memory — for instance, calling new on the heap and never calling delete. The unpredictable timing of when this causes problems makes debugging quite difficult.

How to Import a VRoid Studio Model into Unity with Mixamo Animations

Fri, 04 Feb 2022 09:08:23 +0800

A step-by-step guide on how to create a Vtuber model with VRoid Studio, export it as VRM, and bring it into Unity with Mixamo animations.

How to Implement an XY Pad with JUCE

Tue, 25 Jan 2022 14:13:30 +0800

The XY Pad is a common UI design in audio plugins that lets you control two parameters simultaneously. This article covers how to implement an XY Pad using the JUCE framework, explaining the relevant Component classes and override methods.

How to Use git rebase to Integrate Branches

Thu, 20 Jan 2022 11:43:53 +0800

Our plugin development is wrapping up, and it's time to integrate my partner's changes. In this article, I explain how to use git rebase and walk through a hands-on example.

How to Use std::function to Write a Callback Function in C++

Tue, 18 Jan 2022 00:53:58 +0800

std::function is a C++11 feature defined in <functional>. Similar to a function pointer in C, it can store, copy, and invoke any CopyConstructible Callable object.

About

Wed, 12 Jan 2022 17:35:20 +0800

Contact me

How to Run GitLab Runner in Docker

Mon, 25 Oct 2021 12:38:23 +0800

Besides running a locally installed GitLab Runner, GitLab also provides Docker images for running GitLab Runner inside a container. This article follows the official documentation to walk through the setup.