PipeInspect: Wired Ethernet Control & Wi-Fi Video Streaming
PipeInspect drives a dual-steer pipe inspection robot over W5500 Ethernet on ESP32-C3, keeping commands wired while SJ4000 video streams over Wi-Fi
0
Project description
๐ Overview
PipeInspect๋ ๋ฐฐ๊ด ๋ด๋ถ๋ฅผ ์ ๊ฒํ๋ dual-steer inspection robot์ PC์ web dashboard์์ ์กฐ์ข ํ๋ open source project์ ๋๋ค. Robot controller๋ ESP32-C3์ด๋ฉฐ, W5500์ด SPI๋ก ์ฐ๊ฒฐ๋์ด PC์์ command link๋ฅผ wired Ethernet์ผ๋ก ๋ด๋นํฉ๋๋ค.
์ด project์์ ๋์ ๋๋ ์ ์ control path์ video path๋ฅผ ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋ถ๋ฆฌํ๋ค๋ ๊ฒ์ ๋๋ค. ์กฐ์ข ๋ช ๋ น์ W5500 Ethernet์ ํตํด ์ ์ ์ผ๋ก ์ ๋ฌ๋๊ณ , ์์์ SJCAM SJ4000 action camera์ ์์ฒด Wi-Fi AP๋ฅผ ํตํด ์ ๋ฌ๋ฉ๋๋ค. PC๋ ๋ network์ ๋์์ ์ ์ํ ์ํ์์ Flask ๊ธฐ๋ฐ web UI๋ฅผ ์ ๊ณตํ๋ฉฐ, ์ฌ์ฉ์๋ ๋ธ๋ผ์ฐ์ ํค๋ณด๋ ์ ๋ ฅ๋ง์ผ๋ก ์ฃผํยท์กฐํฅยทcamera pan/tilt๋ฅผ ์กฐ์ํฉ๋๋ค.
Repository๋ ๋ค์ ์ธ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
firmware/pipeinspect_esp32c3/pipeinspect_esp32c3.inoโ ESP32-C3 + W5500 Arduino sketchapp.py+requirements.txtโ Flask server ๋ฐ camera stream proxytemplates/+static/โ HTML/CSS/JS front-end
Language ๋น์ค์ C++ 24.3%, JavaScript 22.0%, Python 19.4%, HTML 17.3%, CSS 17.0%๋ก firmware์ web stack์ด ๊ฑฐ์ ๊ท ๋ฑํ๊ฒ ๋๋์ด ์์ต๋๋ค.
๋ค๋ง ์ด repository๋ commit 4๊ฐ, star 0, license ์์, release ์์์ ์ด๊ธฐ prototype ๋จ๊ณ์ด๋ฉฐ, ๋ค์์ ์ค๋ช ํ ๋ฏธ์์ฑ ๋ถ๋ถ๊ณผ pin ์ถฉ๋์ด ์กด์ฌํฉ๋๋ค. ์์ฑ๋ ์ ํ ์ฌ๋ก๊ฐ ์๋๋ผ W5500์ mobile robot์ control link๋ก ์ฌ์ฉํ ์ด๊ธฐ ๊ตฌํ ์ฌ๋ก๋ก ์ฝ๋ ๊ฒ์ด ์ ํํฉ๋๋ค.
๐Components
| Component | Role | ์๋ |
|---|---|---|
| WIZnet - W5500 | ESP32-C3์ wired Ethernet interface (SPI ์ฐ๊ฒฐ) | x 1 |
| ESP32-C3 | Robot controller, HTTP command server | x 1 |
| Drive motors | Forward / reverse ๊ตฌ๋ | x 2 |
| Front / back steer servos | ์ ๋ฅยทํ๋ฅ ๋ ๋ฆฝ ์กฐํฅ | x 2 |
| Pan / tilt servos | Camera mount ๋ฐฉํฅ ์ ์ด | x 2 |
| SJCAM SJ4000 | Wi-Fi action camera (MJPEG / RTSP video feed) | x 1 |
| PC | Flask web UI ๋ฐ stream proxy ์คํ | x 1 |
๐ Features

1. Dual-steer โ ์ ๋ฅ๊ณผ ํ๋ฅ์ ๋ ๋ฆฝ ์กฐํฅ
์ผ๋ฐ์ ์ธ rover๋ ์ ๋ฅ๋ง ์กฐํฅํ๊ฑฐ๋ differential drive๋ก ํ์ ํฉ๋๋ค. PipeInspect๋ front steer servo์ back steer servo๋ฅผ ๊ฐ๊ฐ ๋ณ๋ key๋ก ์ ์ดํฉ๋๋ค.
| ๊ตฌ๋ถ | ์ข | ์ฐ | ์ค์ ๋ณต๊ท |
|---|---|---|---|
| ์ฃผํ | W ์ ์ง (hold) | S ํ์ง (hold) | STOP |
| ์ ๋ฅ ์กฐํฅ | A | D | F |
| ํ๋ฅ ์กฐํฅ | Z | C | V |
| Camera pan/tilt | 4 / 6 (pan), 8 / 2 (tilt) | โ | 5 |
Numpad key๋ ์ง์ํฉ๋๋ค. Steer key๋ hold ๋ฐฉ์์ผ๋ก ๊ฐ๋๋ฅผ 45โ135ยฐ ๋ฒ์์์ 40 ms๋ง๋ค 2ยฐ์ฉ ์ด๋์ํค๊ณ , key๋ฅผ ๋ผ๋ฉด ๊ทธ ๊ฐ๋๋ฅผ ์ ์งํฉ๋๋ค. ์ ๋ฅ๊ณผ ํ๋ฅ์ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ๊บพ์ผ๋ฉด ํ์ ๋ฐ๊ฒฝ์ ์ค์ผ ์ ์๊ณ ๊ฐ์ ๋ฐฉํฅ์ผ๋ก ๊บพ์ผ๋ฉด crab steering์ด ๋๋ฏ๋ก, ์ข์ ๋ฐฐ๊ด ๋ด๋ถ์ฒ๋ผ ์ ํ ๊ณต๊ฐ์ด ๋ถ์กฑํ ํ๊ฒฝ์ ๋ง๋ ์ ํ์ ๋๋ค.
2. Control์ W5500 wired Ethernet, video๋ camera Wi-Fi
Firmware๋ Arduino Ethernet.h (W5x00) library๋ก W5500์ ์ด๊ธฐํํ๊ณ static IP 192.168.1.100์์ port 80์ HTTP server๋ฅผ ์ฝ๋๋ค.
#define W5500_CS 7
#define W5500_RST 10
#define SPI_MOSI 6
#define SPI_MISO 5
#define SPI_SCK 4
SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI, W5500_CS);
Ethernet.init(W5500_CS);
Ethernet.begin(mac, ip, gateway, subnet); // MAC DE:AD:BE:EF:FE:ED
EthernetServer server(80);Video๋ SJ4000์ด ๋ง๋๋ ๋ณ๋ Wi-Fi AP(192.168.1.254)์์ ๊ฐ์ ธ์ต๋๋ค. ์ฆ PC๋ Ethernet๊ณผ Wi-Fi ๋ interface๋ฅผ ๋์์ ์ฌ์ฉํ๋ ๊ตฌ์กฐ์
๋๋ค.
3. ๊ฐ๊ฒฐํ HTTP/JSON command protocol
| Method | Endpoint | Body |
|---|---|---|
GET | /status | โ |
POST | /command | {"key":"W","action":"down"} |
action์ down(key ๋๋ฆ ์ ์ง), up(๋), press(์๊ฐ ์
๋ ฅ) ์ธ ๊ฐ์ง์ด๊ณ , key๋ W, S, STOP, A, D, F, Z, C, V, 8, 2, 4, 6, 5์
๋๋ค. ์๋ต์ {"key_received":"W","action":"up"} ํํ์ JSON์
๋๋ค. Firmware์ server ์์ชฝ์ GET query string fallback๋ ๊ตฌํ๋์ด ์์ด, JSON POST๊ฐ ์คํจํ๋ ํ๊ฒฝ์์๋ ๋์ํ ์ ์์ต๋๋ค.
Command๊ฐ ์ํ(state)๊ฐ ์๋๋ผ key event๋ก ์ ์๋์ด ์๋ค๋ ์ ์ด ํน์ง์
๋๋ค. Firmware๊ฐ key hold ์ํ๋ฅผ ์ง์ ๊ด๋ฆฌํ๋ฏ๋ก PC๊ฐ ๊ฐ๋๋ฅผ ๊ณ์ฐํด ๋ณด๋ผ ํ์๊ฐ ์๊ณ , ๊ทธ๋งํผ packet ์๊ฐ ์ค์ด๋ญ๋๋ค. ๋ฐ๋๋ก up event๊ฐ ์ ์ค๋๋ฉด ์กฐํฅ์ด ๊ณ์ ์์ง์ด๋ ์ํ์ด ์๋๋ฐ, ๊ณต๊ฐ source์๋ watchdog์ด๋ command timeout์ด ๊ตฌํ๋์ด ์์ง ์์ต๋๋ค.
4. Flask๊ฐ camera stream์ proxy
SJ4000์ mode์ ๋ฐ๋ผ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์์์ ๋ด๋ณด๋ ๋๋ค.
- Photo mode โ MJPEG,
http://192.168.1.254:8192/ - Video mode โ RTSP,
rtsp://192.168.1.254/sjcam.mov
๋ธ๋ผ์ฐ์ ๋ RTSP๋ฅผ ์ง์ ์ฌ์ํ์ง ๋ชปํ๋ฏ๋ก Flask๊ฐ FFmpeg subprocess๋ฅผ ๋์ MJPEG์ผ๋ก ๋ณํํฉ๋๋ค.
ffmpeg -rtsp_transport tcp -i rtsp://192.168.1.254/sjcam.mov -c:v mjpeg -f mpjpeg pipe:1Mode ์ ํ์ SJCAM ์์ฒด HTTP command(cmd=3001&par=0|1)๋ก ์ํํฉ๋๋ค. Flask๊ฐ stream์ ์ค๊ณํ๋ ๋ ๋ค๋ฅธ ์ด์ ๋ ๋ธ๋ผ์ฐ์ CORS ์ ์ฝ์ ์ฐํํ๊ธฐ ์ํด์์
๋๋ค.
5. ๋ณ๋ sensor ์์ด camera ์์๋ง์ผ๋ก ์ด์ฉ
Firmware์๋ encoder, IMU, ๊ฑฐ๋ฆฌ ์ผ์ ๋ฑ ์ด๋ค sensor๋ ์์ต๋๋ค. Operator๊ฐ ๋ณด๋ ์ ๋ณด๋ camera ์์ ํ๋๋ฟ์ด๋ฉฐ, robot์ ์์ ์ ์์น๋ ์์ธ๋ฅผ ์์ง ๋ชปํฉ๋๋ค. Pipe inspection์ด๋ผ๋ ๋ชฉ์ ์์ ๋ณด๋ฉด "์ฌ๋์ด ์์์ ๋ณด๊ณ ํ๋จํ๋ค"๋ ์ ์ ๊ฐ ๋ช ํํ ์ค๊ณ์ด์ง๋ง, ์๋ ์ฃผํ์ด๋ ์์น ๊ธฐ๋ก์ผ๋ก ํ์ฅํ๋ ค๋ฉด sensor์ telemetry ๊ณ์ธต์ ์๋ก ์ถ๊ฐํด์ผ ํฉ๋๋ค.
๐ System Architecture

ํ์ธ ๊ฐ๋ฅํ ์ ์ฒด ํ๋ฆ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
[ Browser (keyboard) ]
โ HTTP :5000
โผ
[ PC โ Flask app.py ]
โ โโโ FFmpeg (RTSP โ MJPEG)
โ โฒ
โ HTTP/JSON โ Wi-Fi
โ POST /command โ
โผ โ
Ethernet (W5500) [ SJCAM SJ4000 AP ]
โ 192.168.1.254
โผ
[ ESP32-C3 โ 192.168.1.100 : 80 ]
โ
โโโ Drive motors (fwd / rev)
โโโ Front steer servo
โโโ Back steer servo
โโโ Camera pan / tilt servosPC ์ชฝ network ๊ตฌ์ฑ์ ๋ค์๊ณผ ๊ฐ์ด ๋ ๊ฐ๋์ ๋๋ค.
PC โโ Ethernet โโโบ Router / Switch โโโบ ESP32-C3 192.168.1.100
PC โโ Wi-Fi โโโโโโโโโโโโโโโโโโโโโโโโโโบ SJ4000 AP 192.168.1.254์ฌ๊ธฐ์ ํ ๊ฐ์ง ์ง์ด ๋ ์ ์ด ์์ต๋๋ค. ๋ ๋์์ด ๋ชจ๋ 192.168.1.0/24 ๋์ญ์ ์์ต๋๋ค. ํ๋๋ Ethernet interface ๋๋จธ์, ํ๋๋ Wi-Fi interface ๋๋จธ์ ์์ผ๋ฏ๋ก PC์ routing table์ ๋์ผ subnet์ด ๋ ๊ฐ ์๊ธฐ๊ณ , ์ด๋ interface๋ก packet์ ๋ณด๋ผ์ง OS๊ฐ ๊ฒฐ์ ํ๊ฒ ๋ฉ๋๋ค. ์ค์ ์ค์น์์๋ robot ์ชฝ์ ๋ค๋ฅธ ๋์ญ(์: 192.168.2.x)์ผ๋ก ์ฎ๊ธฐ๊ฑฐ๋ interface metric์ ๋ช
์์ ์ผ๋ก ์ง์ ํ๋ ํธ์ด ์์ ํฉ๋๋ค. ์ด ๋ฌธ์ ๋ ๊ณต๊ฐ README์ ์ธ๊ธ๋์ด ์์ง ์์ผ๋ฉฐ, ์ ๊ตฌ์ฑ์ repository์ ๊ธฐ์ฌ๋ ๊ธฐ๋ณธ๊ฐ ๊ธฐ์ค์
๋๋ค.
๐ Role and Application of the WIZnet Chip
์ฌ์ฉ๋ chip
Firmware header์ PipeInspect dual-steer robot firmware for ESP32-C3 + W5500 Ethernet.์ผ๋ก ๋ช
์๋์ด ์์ผ๋ฉฐ, README hardware table์๋ ESP32-C3 + W5500์ด "Robot controller over Ethernet"์ผ๋ก ๊ธฐ์ฌ๋์ด ์์ต๋๋ค. ํ์ธ๋๋ WIZnet chip์ W5500 ํ๋์
๋๋ค.

Network์์ ๋ด๋นํ๋ ์ญํ
ESP32-C3
โ SPI (SCK 4 ยท MISO 5 ยท MOSI 6 ยท CS 7 ยท RST 10)
โผ
W5500
โ 10/100 Ethernet ยท static 192.168.1.100 ยท TCP :80
โผ
Router / Switch
โ
โผ
PC (Flask)W5500์ Arduino Ethernet.h library๋ฅผ ํตํด ์ฌ์ฉ๋๋ฏ๋ก, socket ์ฒ๋ฆฌ๋ library๊ฐ W5500์ hardware socket์ ํธ์ถํ๋ ํํ์
๋๋ค. ๋ค๋ง ์ด project๋ WIZnet socket API๋ฅผ ์ง์ ํธ์ถํ๊ฑฐ๋ offload ์ฑ๋ฅ์ ์ธก์ ํ์ง ์์ผ๋ฏ๋ก, W5500์ ํ์ฉํ Ethernet ์ฐ๊ฒฐ ์ฌ๋ก๋ก ํด์ํ๋ ๊ฒ์ด ์ ํํฉ๋๋ค.
Mobile inspection robot์์ wired control link๊ฐ ๊ฐ๋ ์ค์ฉ์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ด ์ ๋ฆฌํ ์ ์์ต๋๋ค.
- ๊ธ์ ๋ฐฐ๊ด ๋ด๋ถ์ฒ๋ผ Wi-Fi ์ ํ๊ฐ ๊ธ๊ฒฉํ ๊ฐ์ ํ๋ ํ๊ฒฝ์์๋ ๋ช ๋ น ์ ๋ฌ์ด ์ ์ง๋๋ค.
- ์กฐ์ข ๋ช ๋ น์ latency์ jitter๊ฐ ๋ฌด์ ๋ณด๋ค ์์ธก ๊ฐ๋ฅํ๋ค.
- Robot์ด ์ด๋ฏธ tether(๊ฒฌ์ธยทํ์์ฉ ์ผ์ด๋ธ)๋ฅผ ๋ฌ๊ณ ๋ค๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์, ๊ทธ ์ผ์ด๋ธ์ Ethernet์ ํจ๊ป ๋ฃ๋ ๋ฐ ์ถ๊ฐ ๋ถ๋ด์ด ์ ๋ค.
- ์์์ ๋์ญํญ์ ๋ง์ด ์ฐ์ง๋ง ์ ์ค๋์ด๋ ์ฌ์๋๊ฐ ๊ฐ๋ฅํ๊ณ , ๋ช ๋ น์ ๋์ญํญ์ ์์ง๋ง ์ ์ค๋๋ฉด ์ํํ๋ค โ ๋ traffic์ ๋ค๋ฅธ ๋งค์ฒด๋ก ๋ถ๋ฆฌํ ๊ฒ์ ์ด ์ฑ์ง์ ๋ถํฉํ๋ค.
์ ๋ด์ฉ์ project์ wiring ๊ตฌ์กฐ๋ฅผ ๋ฐํ์ผ๋ก ํ ๊ธฐ์ ์ ํด์์ด๋ฉฐ, ๊ณต๊ฐ ์๋ฃ์ ์ ์ ๊ณผ ๋ฌด์ control link๋ฅผ ๋น๊ตํ ์ธก์ ๊ฒฐ๊ณผ๋ ์์ต๋๋ค.
ํ์ธ๋๋ ํ๊ณ
์ ํํ ํ๊ฐ๋ฅผ ์ํด ๊ณต๊ฐ source์์ ํ์ธ๋๋ ๋ฏธ์์ฑ ๋ถ๋ถ์ ํจ๊ป ๊ธฐ๋กํฉ๋๋ค.
| ํญ๋ชฉ | ๋ด์ฉ |
|---|---|
| Servo ์ถ๋ ฅ ๋ฏธ์์ฑ | Servo ๊ตฌ๋์ด analogWrite placeholder์ด๋ฉฐ TODO: replace with your servo library (ESP32Servo, PCA9685, etc.) ์ฃผ์์ด ๋จ์ ์์ |
| ์๋ ์ ์ด ์์ | Drive motor๊ฐ PWM ์์ด digital HIGH/LOW๋ก๋ง ์ ์ด๋จ |
| Subnet ์ค๋ณต | ESP32-C3์ SJ4000์ด ๋์ผ 192.168.1.0/24 ๋์ญ |
| Safety ๊ณ์ธต ์์ | Command timeout, watchdog, e-stop ๋ฏธ๊ตฌํ |
| ์ด์ ์ค์ | Flask๊ฐ debug=True๋ก ์คํ๋๋ฉฐ production ์ค์ ์ด ์๋ |
๐ Related Existing Contents & Expansion Value
1. W5500-Based ESP32-S3 micro-ROS Node Suite for a Distributed Rover Control System
- Link: WIZnet Maker Site โ W5500-Based ESP32-S3 micro-ROS Node Suite
- Similarity Point: ESP32 ๊ณ์ด MCU์ W5500์ ๋ถ์ฌ rover์ motor์ ์ํ ์ ๋ณด๋ฅผ wired Ethernet์ผ๋ก ์ฃผ๊ณ ๋ฐ๋๋ค๋ ์ ์์ ๋ชฉ์ ์ด ๊ฐ์ต๋๋ค. ๋ฌด์ ๋์ ์ ์ ์ ์ ํํ ์ด์ ๋ link ์ ๋ขฐ์ฑ์ด๋ผ๋ ๊ณตํต์ ์ด ์์ต๋๋ค.
- Difference: micro-ROS Node Suite๋ ๋ค์ฏ ๊ฐ์ ESP32-S3 node๊ฐ ROS 2 topic์ผ๋ก ํต์ ํ๋ distributed architecture์ด๊ณ BMS telemetry๊น์ง ํฌํจํฉ๋๋ค. PipeInspect๋ ๋จ์ผ MCU์ ๋จ์ HTTP/JSON key event๋ฅผ ์ฐ๋ ์ต์ ๊ตฌ์ฑ์ ๋๋ค.
- Connection Value: PipeInspect๋ฅผ telemetry์ ์๋ ์ฃผํ์ผ๋ก ํ์ฅํ ๋ ์ฐธ๊ณ ํ ๋ค์ ๋จ๊ณ์ ํด๋นํฉ๋๋ค. HTTP key event โ ROS 2 topic์ผ๋ก ์ฎ๊ฒจ ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ๋ณด์ฌ ์ค๋๋ค.
2. How to Bridge a ROS2 Jazzy Rover to Wired Ethernet with W5500 on ESP32?
- Link: WIZnet Maker Site โ ROS2 Jazzy Rover Control with W5500
- Similarity Point: ESP32๊ฐ low-level motor I/O๋ฅผ ๋ด๋นํ๊ณ ์์ PC๊ฐ ํ๋จ์ ๋ด๋นํ๋ ์ญํ ๋ถ๋ฆฌ ๊ตฌ์กฐ๊ฐ PipeInspect์ "firmware๋ key event ์ฒ๋ฆฌ, PC๋ UI"์ ๊ฐ์ ๋ฐฉํฅ์ ๋๋ค.
- Difference: MQTT ๊ธฐ๋ฐ message bus๋ฅผ ์ฌ์ฉํ๊ณ ROS2 stack๊ณผ ํตํฉ๋ฉ๋๋ค. PipeInspect๋ broker ์์ด PC๊ฐ robot์ ์ง์ HTTP ์์ฒญ์ ๋ณด๋ ๋๋ค.
- Connection Value: Robot์ ์ฌ๋ฌ ๋๋ก ๋๋ฆฌ๊ฑฐ๋ ์๊ฒฉ ๊ฐ์๋ฅผ ๋ถ์ผ ๋ broker ๋์ ์ด ์ ํ์ํด์ง๋์ง ๋น๊ตํ ์ ์๋ ์ฌ๋ก์ ๋๋ค.
3. PoliTOcean-EVA โ Distributed Underwater Robot Control System
- Link: WIZnet Maker Site โ PoliTOcean-EVA
- Similarity Point: ์ฌ๋์ด ์ ๊ทผํ๊ธฐ ์ด๋ ค์ด ๊ณต๊ฐ(์์ค / ๋ฐฐ๊ด ๋ด๋ถ)์ tether๋ก ์ฐ๊ฒฐ๋ inspection robot์ ์ ์ Ethernet์ผ๋ก ์กฐ์ข ํ๋ค๋ ์ ์์ application ์ฑ๊ฒฉ์ด ๊ฐ์ฅ ๊ฐ๊น์ต๋๋ค.
- Difference: EVA ROV๋ ์ฌ๋ฌ microcontroller๋ฅผ MQTT๋ก ๋ฌถ์ distributed control system์ด๋ฉฐ real-time ์๊ตฌ์ฌํญ์ด ํจ์ฌ ๋์ต๋๋ค. PipeInspect๋ ์ง์ ๋ฐฐ๊ด์ฉ ๋จ์ผ controller์ ๋๋ค.
- Connection Value: Tethered inspection robot์์ ์ ์ Ethernet์ด ํ์ค์ ์ธ ์ ํ์ธ ์ด์ ๋ฅผ ๋ท๋ฐ์นจํ๋ ์์ ์ฐธ๊ณ ์ฌ๋ก์ ๋๋ค.
4. ESP32-CameraWebServer-ov5640 (ESP32-CAM + W5500)
- Link: WIZnet Maker Site โ ESP32-CameraWebServer-ov5640
- Similarity Point: W5500 Ethernet์ผ๋ก ์์์ ์ค์๊ฐ ์ ์กํ๋ ์ฌ๋ก์ ๋๋ค.
- Difference: PipeInspect๋ ์์์ W5500์ด ์๋๋ผ camera์ Wi-Fi๋ก ๋ฐ์ต๋๋ค. ์ด project๋ ๋ฐ๋๋ก ์์๊น์ง ์ ์ ์ผ๋ก ๋ณด๋ ๋๋ค.
- Connection Value: PipeInspect์ ๊ฐ์ฅ ์ ๋ ฅํ ๊ฐ์ ๋ฐฉํฅ์ ๋ณด์ฌ ์ค๋๋ค. Camera๋ฅผ Wi-Fi action cam์์ Ethernet camera module๋ก ๋ฐ๊พธ๋ฉด PC์ dual-network ๊ตฌ์ฑ๊ณผ subnet ์ค๋ณต ๋ฌธ์ ๊ฐ ํจ๊ป ์ฌ๋ผ์ง๋๋ค.
๐ Market & Application Value
์ ์ฉ ๊ฐ๋ฅํ ๋ถ์ผ
| ์ ์ฉ ๋ถ์ผ | ํ์ฉ ๋ฐฉ์ |
|---|---|
| ๋ฐฐ๊ดยทํ์๊ด ์ ๊ฒ | ๊ด ๋ด๋ถ ๊ท ์ด, ํด์ ๋ฌผ, ์ด์๋ถ ์ํ ์ก์ ์ ๊ฒ |
| ๋ํธยทํ๊ธฐ๊ตฌ ์ ๊ฒ | HVAC duct ๋ด๋ถ ์ค์ผ๋ ๋ฐ ์์ ํ์ธ |
| ์ค๋น ํ๋ถยทํ์ ๊ณต๊ฐ | ์ฌ๋์ด ์ง์ ํ๊ธฐ ์ด๋ ค์ด ๊ธฐ๊ณ ํ๋ถ ๋ฐ crawl space ์ ๊ฒ |
| ๊ฑด์ถ๋ฌผ ์ ์ง๋ณด์ | ๋ฒฝ์ฒด ๋ด๋ถ ๊ณต๊ฐ, ๋ฐฐ์ ๊ฒฝ๋ก ํ์ธ |
| ๊ต์กยท์ฐ๊ตฌ | Tethered mobile robot๊ณผ wired control link ์ค์ต ๊ต์ฌ |
Dual-steer ๊ตฌ์กฐ์ ์ํ form factor ๋๋ถ์ ์ ํ ๊ณต๊ฐ์ด ๋ถ์กฑํ ๊ด ๋ด๋ถ์ ์ ํฉํฉ๋๋ค. ๋ค๋ง ๊ณต๊ฐ ์๋ฃ์๋ ๋ฐฉ์ ๋ฑ๊ธ, ๋ด๊ตฌ์ฑ ์ํ, ์ต์ ํต๊ณผ ๊ด๊ฒฝ ๊ฐ์ ์ฌ์์ด ์์ผ๋ฏ๋ก ์ค์ ํ์ฅ ์ ์ฉ ๊ฐ๋ฅ ๋ฒ์๋ฅผ ํ๋จํ ๊ทผ๊ฑฐ๋ ์์ต๋๋ค.
B2C์ B2B ์ ์ฉ์ฑ
- Makerยท๊ต์ก: Arduino ์์ค firmware์ Flask web UI๋ก ๊ตฌ์ฑ๋์ด ์์ด "์ ์ ์ ์ด + ๋ฌด์ ์์"์ด๋ผ๋ ๊ตฌ์กฐ๋ฅผ ํ์ตํ๊ธฐ ์ข์ ์ต์ ์์ ์ ๋๋ค.
- ์๊ท๋ชจ ์์ค๊ด๋ฆฌ: ์์ฉ ๋ฐฐ๊ด ์นด๋ฉ๋ผ ๋๋น ํจ์ฌ ๋ฎ์ ๋น์ฉ์ผ๋ก ์์ฒด ์ ์ํ ์ฌ์ง๊ฐ ์์ต๋๋ค. ๋ค๋ง ํ์ฌ ์ํ๋ก๋ servo ๊ตฌํ๊ณผ pin ๋ฐฐ์น๋ฅผ ์ง์ ์์ฑํด์ผ ํฉ๋๋ค.
- Product developer: ESP32-C3 + W5500 ์กฐํฉ์์ command latency๊ฐ ์ค์ํ motion application์ reference๋ก ํ์ฉํ ์ ์์ต๋๋ค.
Solution package๋ก์ ํ์ฅ ๊ฐ๋ฅ์ฑ
- ESP32-C3 + W5500 SPI reference wiring (pin ์ถฉ๋ ์๋ ์ ์ ๋ณธ)
- Command timeout / watchdog์ ํฌํจํ ์์ ๊ณ์ธต ์์
- Dual-steer ๊ธฐ๊ตฌ ์ค๊ณ ๋ฐ servo ์ ์ ๊ฐ์ด๋
- Ethernet camera๋ก ์ ํํ ๋จ์ผ network ๊ตฌ์ฑ์
- PoE ๊ธ์ ์ผ๋ก tether๋ฅผ ์ ์+๋ฐ์ดํฐ ํ๋๋ก ํตํฉํ๋ ๊ตฌ์ฑ
์ค์ reference package๋ก ๋ฐ์ ์ํค๋ ค๋ฉด ๋ฐฉ์ enclosure, tether ๊ด๋ฆฌ, ์กฐ๋ช , ์ ์ ์ค๊ณ๊ฐ ์ถ๊ฐ๋ก ํ์ํฉ๋๋ค.
๐ External Indicators
์๋ ์์น๋ 2026-08-12 ํ์ธ ๊ธฐ์ค snapshot์ด๋ฉฐ ์ดํ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค.
| Indicator | ํ์ธ ๊ฒฐ๊ณผ | ํด์ |
|---|---|---|
| GitHub Stars | 0 | ์ธ๋ถ ๊ด์ฌ์ด ์์ง ํ์ฑ๋์ง ์์ ๊ฐ์ธ prototype์ ๋๋ค. |
| GitHub Forks | 0 | ์ธ๋ถ ์ฌ์ฌ์ฉ ํ์ ์ด ์์ต๋๋ค. |
| GitHub Commits | 4 | ์ด๊ธฐ ๊ตฌํ ์งํ ๋จ๊ณ์ด๋ฉฐ ์ง์์ ์ ์ง๋ณด์ ์ด๋ ฅ์ ์์ต๋๋ค. |
| Releases / Packages | 0 | ๋ฐฐํฌ ๊ฐ๋ฅํ ์ฐ์ถ๋ฌผ์ด ๋ฐํ๋์ง ์์์ต๋๋ค. |
| License | ์์ | LICENSE file์ด ์์ด ์ฌ์ฌ์ฉยท์ฌ๋ฐฐํฌ ์กฐ๊ฑด์ด ์ ์๋์ง ์์์ต๋๋ค. |
| Topics / Description | ์์ | Repository ๋ฉํ๋ฐ์ดํฐ๊ฐ ๋น์ด ์์ต๋๋ค. |
| Languages | C++ 24.3% ยท JavaScript 22.0% ยท Python 19.4% ยท HTML 17.3% ยท CSS 17.0% | Firmware์ web stack์ด ๊ท ํ ์๊ฒ ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. |
| ๋ฌธ์ ์ผ๊ด์ฑ | README์ project root๊ฐ getabec/๋ก ํ๊ธฐ๋์ด repository ์ด๋ฆ๊ณผ ๋ถ์ผ์น | Rename ์์ฌ๋ก ๋ณด์ ๋๋ค. |
โ ๏ธ License ๊ด๋ จ ์ฃผ์
LICENSE file์ด ์๋ค๋ ๊ฒ์ "์์ ์ด์ฉ ๊ฐ๋ฅ"์ด ์๋๋ผ ๊ธฐ๋ณธ ์ ์๊ถ์ด ๊ทธ๋๋ก ์ ์ง๋๋ค๋ ์๋ฏธ์ ๋๋ค. ์ฝ๋ ์ธ์ฉ ๋ฒ์๋ฅผ ๋์ด์๋ ์๊ฐ๋ ์ฌ๋ฐฐํฌ ์ ์๋ ์์ฑ์ ํ์ธ์ด ํ์ํฉ๋๋ค.
๐ WIZnet Strategic Value
ํ์ธ๋ ์ฌ์ค
PipeInspect๋ W5500์ sensor node๋ controller ๊ณ ์ ์ค์น๊ฐ ์๋๋ผ ์ด๋ํ๋ robot์ command link์ ์ฌ์ฉํ์ต๋๋ค. WIZnet Maker Site์ ์ถ์ ๋ W5500 robotics ์ฌ๋ก์ ํจ๊ป ๋๊ณ ๋ณด๋ฉด ์ผ์ ํ ํ๋ฆ์ด ๋ณด์ ๋๋ค.
W5500 in Robotics โ Maker Site ์ฌ๋ก ๊ณ์ด
์ ์ ์ ์ด (Fixed installation)
โโ STM32F103 Multi-Axis Motion Controller
โโ ESP32UDP LinuxCNC Motion Controller
โโ ๊ณต์๊ธฐ๊ณยท๋ค์ถ ๋ชจ์
, ๊ฒฐ์ ์ latency๊ฐ ํต์ฌ
์ด๋ ๋ก๋ด (Mobile / tethered)
โโ ROS2 Jazzy Rover (ESP32 + W5500 + MQTT)
โโ ESP32-S3 micro-ROS Node Suite (5-node rover)
โโ PoliTOcean-EVA (์์ค ROV, tethered)
โโ PipeInspect (๋ฐฐ๊ด ์ ๊ฒ, tethered) โ ๋ณธ ํ๋ก์ ํธ
โโ ๋ฌด์ ์ด ๋ฟ์ง ์๊ฑฐ๋ ์ ๋ขฐํ ์ ์๋ ๊ณต๊ฐํด์
์ด ๊ณ์ด์ ๊ณตํต ์๊ตฌ๋ ๋ค์๊ณผ ๊ฐ์ด ์ ๋ฆฌ๋ฉ๋๋ค.
- ๋ช ๋ น ์ ๋ฌ์ ์ ๋ขฐ์ฑ์ด ๋์ญํญ๋ณด๋ค ์ค์ํ๋ค.
- ์ด๋ฏธ ๋ฌผ๋ฆฌ์ ์ผ์ด๋ธ(tether)์ด ์กด์ฌํ๋ฏ๋ก ์ ์ ํ ๋น์ฉ์ด ๋ฎ๋ค.
- ๊ธ์ ๊ตฌ์กฐ๋ฌผยท์์คยท์งํ์ฒ๋ผ RF ํ๊ฒฝ์ด ๋์๋ค.
- MCU์ SPI๋ก ์ฐ๊ฒฐ๋๋ compact Ethernet interface๊ฐ ํ์ํ๋ค.
- Motorยทservo ์ ์ด loop์ network ์ฒ๋ฆฌ๊ฐ ๊ฐ์ MCU์์ ๊ณต์กดํด์ผ ํ๋ค.
PipeInspect๊ฐ ์ด ๊ณ์ด์์ ๊ฐ๋ ์์น๋ ๊ฐ์ฅ ๋จ์ํ ์ง์ ์ ์ ๋๋ค. ROS๋ MQTT๋ ์์ด HTTP/JSON๋ง์ผ๋ก ๊ตฌํ๋์ด ์์ด, W5500 ๊ธฐ๋ฐ robot control์ ์ฒ์ ์ ํ๋ ๊ฐ๋ฐ์๊ฐ ์ฝ์ด ๋ผ ์ ์๋ ์ต์ ๊ตฌ์ฑ์ ๋๋ค. ๋ฐ๋๋ก ๋งํ๋ฉด ์ ๋ขฐ์ฑยท์์ ์ฑ ๊ณ์ธต์ ์ ๋ถ ๋น์ด ์์ผ๋ฏ๋ก, ์์ ์ธ ์ฌ๋ก๊ฐ ์ broker์ real-time stack์ ๋์ ํ๋์ง๋ฅผ ๋๋น์ ์ผ๋ก ๋ณด์ฌ ์ฃผ๋ ์๋ฃ์ด๊ธฐ๋ ํฉ๋๋ค.
๐ Summary
PipeInspect(GetabegRobot)๋ ESP32-C3์ W5500์ ์ฌ์ฉํด dual-steer ๋ฐฐ๊ด ์ ๊ฒ robot์ wired Ethernet์ผ๋ก ์กฐ์ข ํ๊ณ , ์์์ SJCAM SJ4000์ Wi-Fi๋ก ๋ณ๋ ์์ ํ๋ open source project์ ๋๋ค. Control๊ณผ video๋ฅผ ์๋ก ๋ค๋ฅธ ๋งค์ฒด๋ก ๋ถ๋ฆฌํ ๊ตฌ์ฑ, hold ๋ฐฉ์ key event ๊ธฐ๋ฐ์ ๊ฐ๊ฒฐํ HTTP/JSON protocol, ์ ๋ฅยทํ๋ฅ ๋ ๋ฆฝ ์กฐํฅ์ด ์ด project์ ํน์ง์ ๋๋ค.
W5500์ ESP32-C3์ SPI(SCK 4 ยท MISO 5 ยท MOSI 6 ยท CS 7 ยท RST 10)๋ก ์ฐ๊ฒฐ๋์ด static IP 192.168.1.100์์ HTTP server๋ฅผ ์ ๊ณตํฉ๋๋ค. Arduino Ethernet.h library๋ฅผ ๊ฒฝ์ ํ๋ฏ๋ก direct socket API๋ TOE ์ฑ๋ฅ ํ์ฉ์ ๊ณต๊ฐ source์์ ํ์ธ๋์ง ์์ผ๋ฉฐ, ์ด ์ฌ๋ก์ ํ์คํ ๊ฐ์น๋ ์ด๋ robot์ ์ ๋ขฐ์ฑ ์๋ command link๋ก W5500์ ์ฌ์ฉํ๋ค๋ ์ ์ ์์ต๋๋ค.
๋์์ ์ด repository๋ commit 4๊ฐ, star 0, license ์์์ ์ด๊ธฐ prototype์ด๋ฉฐ servo ์ถ๋ ฅ์ด ๋ฏธ์์ฑ์ด๊ณ camera servo pin์ด W5500 SPI pin๊ณผ ์ถฉ๋ํฉ๋๋ค. PC ์์ชฝ network๊ฐ ๊ฐ์ subnet์ ์ฐ๋ ๋ฌธ์ ๋ ์์ต๋๋ค. ๋ฐ๋ผ์ ๊ทธ๋๋ก ์ฌํ ๊ฐ๋ฅํ ์์ฑํ์ด ์๋๋ผ, ๊ตฌ์กฐ์ ์์ด๋์ด๋ฅผ ์ฐธ๊ณ ํ๊ณ ๊ตฌํ์ ์ง์ ์ ์ ํด์ผ ํ๋ ์๋ฃ๋ก ๋ค๋ฃจ๋ ๊ฒ์ด ์ ํํฉ๋๋ค.
๐ Key Questions & Clear Answers
1. PipeInspect๋ ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๊ฐ?
์ฌ๋์ด ๋ค์ด๊ฐ ์ ์๋ ๋ฐฐ๊ด ๋ด๋ถ๋ฅผ ์ก์ ์ ๊ฒํ๊ธฐ ์ํด, ์ข์ ๊ณต๊ฐ์์๋ ์ ํํ ์ ์๋ dual-steer robot์ PC ๋ธ๋ผ์ฐ์ ์์ ์กฐ์ข ํ๊ณ ์ค์๊ฐ ์์์ ํ์ธํ ์ ์๊ฒ ํฉ๋๋ค.
2. W5500์ ์ด project์์ ์ด๋ค ์ญํ ์ ํ๋๊ฐ?
ESP32-C3์ SPI๋ก ์ฐ๊ฒฐ๋์ด ์กฐ์ข ๋ช ๋ น ์ ์ฉ wired Ethernet interface๋ฅผ ์ ๊ณตํฉ๋๋ค. ์์ ์ ์ก์ด๋ servo ๊ตฌ๋์๋ ๊ด์ฌํ์ง ์์ต๋๋ค. Direct WIZnet socket API ๋๋ TCP/IP offload ํ์ฉ ์ฌ๋ถ๋ ๊ณต๊ฐ source์์ ํ์ธ๋์ง ์์ต๋๋ค.
3. ์ ์์๊น์ง Ethernet์ผ๋ก ๋ณด๋ด์ง ์์๋๊ฐ?
๊ธฐ์ฑํ SJCAM SJ4000์ ๊ทธ๋๋ก ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋๋ค. ์ด camera๋ ์์ฒด Wi-Fi AP๋ก๋ง ์์์ ๋ด๋ณด๋ ๋๋ค. Ethernet camera module๋ก ๊ต์ฒดํ๋ฉด single-network ๊ตฌ์ฑ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ด๋ ์ด project์ ๊ฐ์ฅ ์ ๋ ฅํ ๊ฐ์ ๋ฐฉํฅ์ ๋๋ค.
4. ์ด ์ฝ๋๋ฅผ ๊ทธ๋๋ก flashํ๋ฉด ๋์ํ๋๊ฐ?
๋์ํ์ง ์์ต๋๋ค. Servo ์ถ๋ ฅ์ด analogWrite placeholder ์ํ์ด๊ณ , CAM_PAN_PIN/CAM_TILT_PIN์ด W5500์ SPI_SCK/SPI_MISO์ ๊ฐ์ GPIO๋ก ์ ์๋์ด ์์ต๋๋ค. Camera servo pin์ ๋ค๋ฅธ GPIO๋ก ์ฎ๊ธฐ๊ณ ESP32Servo ๋ฑ ์ค์ servo library๋ฅผ ์ ์ฉํด์ผ ํฉ๋๋ค.
5. ๊ฐ๋ฐ์๊ฐ ์ฌ์ฌ์ฉํ ์ ์๋ ๋ถ๋ถ์ ๋ฌด์์ธ๊ฐ?
down / up / press ์ธ ๊ฐ์ง action์ผ๋ก ๊ตฌ์ฑ๋ key event protocol ์ค๊ณ, firmware๊ฐ hold ์ํ๋ฅผ ์ง์ ๊ด๋ฆฌํด packet ์๋ฅผ ์ค์ด๋ ๋ฐฉ์, Flask๊ฐ RTSP๋ฅผ FFmpeg์ผ๋ก MJPEG ๋ณํํด CORS๋ฅผ ์ฐํํ๋ stream proxy ํจํด์ด ์ฌ์ฌ์ฉ ๊ฐ์น๊ฐ ์์ต๋๋ค.
6. ์ค์ ์ ํ์ผ๋ก ํ์ฅํ๋ ค๋ฉด ๋ฌด์์ด ๋ ํ์ํ๊ฐ?
Command timeout๊ณผ watchdog์ ํฌํจํ ์์ ๊ณ์ธต, PWM ๊ธฐ๋ฐ ์๋ ์ ์ด, ๋ฐฉ์ enclosure์ ์กฐ๋ช , tether ๊ด๋ฆฌ ๊ตฌ์กฐ, ๊ทธ๋ฆฌ๊ณ license ๋ช ์๊ฐ ํ์ํฉ๋๋ค.
English Version
๐ Overview
PipeInspect is an open source project that drives a dual-steer pipe inspection robot from a web dashboard on a PC. The robot controller is an ESP32-C3, and a W5500 connected over SPI carries the command link to the PC as wired Ethernet.
What stands out here is that the control path and the video path are physically separated. Steering and drive commands travel over W5500 Ethernet on a cable; video arrives over the SJCAM SJ4000 action camera's own Wi-Fi access point. The PC sits on both networks at once and serves a Flask-based web UI, so the operator drives, steers and aims the camera entirely from browser keyboard input.
The repository has three parts:
firmware/pipeinspect_esp32c3/pipeinspect_esp32c3.inoโ ESP32-C3 + W5500 Arduino sketchapp.py+requirements.txtโ Flask server and camera stream proxytemplates/+static/โ HTML/CSS/JS front end
Language share is C++ 24.3%, JavaScript 22.0%, Python 19.4%, HTML 17.3%, CSS 17.0% โ firmware and web stack are split almost evenly.
That said, this repository is an early prototype: 4 commits, 0 stars, no license, no releases, with unfinished code and a pin conflict described below. It should be read not as a finished product but as an early implementation showing the W5500 used as a mobile robot's command link.
๐ Features

1. Dual-steer โ front and back wheels steered independently
A typical rover either steers only the front wheels or turns by differential drive. PipeInspect drives a front steer servo and a back steer servo from separate keys.
| Function | Left | Right | Re-centre |
|---|---|---|---|
| Drive | W forward (hold) | S backward (hold) | STOP |
| Front steering | A | D | F |
| Back steering | Z | C | V |
| Camera pan / tilt | 4 / 6 (pan), 8 / 2 (tilt) | โ | 5 |
Numpad keys are also accepted. Steer keys work by hold: the angle moves 2ยฐ every 40 ms across a 45โ135ยฐ range, and releasing the key holds the current angle. Turning front and back wheels in opposite directions tightens the turning circle; turning them the same way produces crab steering. Both matter inside a pipe, where there is no room to swing the chassis around.
2. Control over W5500 wired Ethernet, video over the camera's Wi-Fi
The firmware initialises the W5500 through the Arduino Ethernet.h (W5x00) library and opens an HTTP server on port 80 at static IP 192.168.1.100.
#define W5500_CS 7
#define W5500_RST 10
#define SPI_MOSI 6
#define SPI_MISO 5
#define SPI_SCK 4
SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI, W5500_CS);
Ethernet.init(W5500_CS);
Ethernet.begin(mac, ip, gateway, subnet); // MAC DE:AD:BE:EF:FE:ED
EthernetServer server(80);Video comes from the separate Wi-Fi AP the SJ4000 creates (192.168.1.254). The PC therefore uses its Ethernet and Wi-Fi interfaces simultaneously.
3. A compact HTTP/JSON command protocol
| Method | Endpoint | Body |
|---|---|---|
GET | /status | โ |
POST | /command | {"key":"W","action":"down"} |
action is one of down (key held), up (released) or press (momentary). key is one of W, S, STOP, A, D, F, Z, C, V, 8, 2, 4, 6, 5. The response is JSON of the form {"key_received":"W","action":"up"}. Both the firmware and the server also implement a GET query-string fallback, so the link still works where JSON POST does not.
The notable design choice is that commands are key events, not state. The firmware owns the hold state, so the PC never has to compute and transmit an angle, and packet volume stays low. The trade-off is that a lost up event leaves the servo stepping โ and the public source implements no watchdog or command timeout.
4. Flask proxies the camera stream
The SJ4000 exposes video two different ways depending on mode:
- Photo mode โ MJPEG,
http://192.168.1.254:8192/ - Video mode โ RTSP,
rtsp://192.168.1.254/sjcam.mov
Browsers cannot play RTSP directly, so Flask spawns an FFmpeg subprocess to transcode it:
ffmpeg -rtsp_transport tcp -i rtsp://192.168.1.254/sjcam.mov -c:v mjpeg -f mpjpeg pipe:1Mode switching uses the SJCAM's own HTTP command (cmd=3001&par=0|1). The other reason Flask relays the stream is to work around browser CORS restrictions.
5. No sensors โ the camera feed is the only feedback
The firmware carries no encoder, IMU or range sensor. The operator's only information is the video, and the robot has no knowledge of its own position or attitude. For pipe inspection that is a coherent assumption โ a human watches and decides โ but extending this to autonomous driving or position logging would require adding a sensor and telemetry layer from scratch.
๐ System Architecture

The verifiable end-to-end flow is as follows.
[ Browser (keyboard) ]
โ HTTP :5000
โผ
[ PC โ Flask app.py ]
โ โโโ FFmpeg (RTSP โ MJPEG)
โ โฒ
โ HTTP/JSON โ Wi-Fi
โ POST /command โ
โผ โ
Ethernet (W5500) [ SJCAM SJ4000 AP ]
โ 192.168.1.254
โผ
[ ESP32-C3 โ 192.168.1.100 : 80 ]
โ
โโโ Drive motors (fwd / rev)
โโโ Front steer servo
โโโ Back steer servo
โโโ Camera pan / tilt servosThe PC-side networking splits in two directions:
PC โโ Ethernet โโโบ Router / Switch โโโบ ESP32-C3 192.168.1.100
PC โโ Wi-Fi โโโโโโโโโโโโโโโโโโโโโโโโโโบ SJ4000 AP 192.168.1.254One point deserves attention here. Both endpoints live in 192.168.1.0/24. One is reached through the Ethernet interface and the other through Wi-Fi, so the PC's routing table ends up with two entries for the same subnet and the OS decides which interface a packet takes. In a real deployment it is safer to move the robot to a different range (for example 192.168.2.x) or to set interface metrics explicitly. This is not mentioned in the public README; the configuration above reflects the defaults committed to the repository.
๐ Role and Application of the WIZnet Chip
Chip used
The firmware header states PipeInspect dual-steer robot firmware for ESP32-C3 + W5500 Ethernet., and the README hardware table lists ESP32-C3 + W5500 as "Robot controller over Ethernet". The only WIZnet chip present is the W5500.

Role in the network
ESP32-C3
โ SPI (SCK 4 ยท MISO 5 ยท MOSI 6 ยท CS 7 ยท RST 10)
โผ
W5500
โ 10/100 Ethernet ยท static 192.168.1.100 ยท TCP :80
โผ
Router / Switch
โ
โผ
PC (Flask)Because the W5500 is reached through the Arduino Ethernet.h library, socket handling is whatever that library issues to the chip's hardware sockets. The project does not call the WIZnet socket API directly or measure offload performance, so this is best described as a case of using the W5500 for Ethernet connectivity rather than a TOE demonstration.
For a mobile inspection robot, a wired control link carries a few practical advantages:
- Command delivery survives environments such as metal pipe interiors where Wi-Fi attenuates sharply.
- Latency and jitter on the control path are more predictable than over a wireless link.
- The robot usually trails a tether for retrieval anyway, so adding Ethernet to that bundle costs little.
- Video is bandwidth-hungry but tolerant of loss; commands are tiny but intolerant of it. Splitting the two across different media matches those properties.
This is a technical reading based on the project's wiring; no measurement comparing wired and wireless control links appears in the public material.
Confirmed limitations
For an accurate assessment, the unfinished parts visible in the public source are recorded here as well.
| Item | Detail |
|---|---|
| Servo output unfinished | Servo drive is an analogWrite placeholder with the comment TODO: replace with your servo library (ESP32Servo, PCA9685, etc.) |
| No speed control | Drive motors are switched with digital HIGH/LOW only, no PWM |
| Subnet overlap | ESP32-C3 and SJ4000 both sit in 192.168.1.0/24 |
| No safety layer | No command timeout, watchdog, or e-stop |
| Runtime settings | Flask runs with debug=True, not a production configuration |
๐ Related Existing Contents & Expansion Value
1. W5500-Based ESP32-S3 micro-ROS Node Suite for a Distributed Rover Control System
- Link: WIZnet Maker Site โ W5500-Based ESP32-S3 micro-ROS Node Suite
- Similarity Point: Same purpose โ an ESP32-family MCU with a W5500 exchanging motor commands and status over wired Ethernet โ and the same reasoning behind choosing wired over wireless: link reliability.
- Difference: The micro-ROS Node Suite is a distributed architecture of five ESP32-S3 nodes communicating over ROS 2 topics, including BMS telemetry. PipeInspect is a minimal single-MCU setup with plain HTTP/JSON key events.
- Connection Value: It is the natural next step if PipeInspect were extended with telemetry and autonomy, showing the path from HTTP key events to ROS 2 topics.
2. How to Bridge a ROS2 Jazzy Rover to Wired Ethernet with W5500 on ESP32?
- Link: WIZnet Maker Site โ ROS2 Jazzy Rover Control with W5500
- Similarity Point: The same division of labour โ the ESP32 handles low-level motor I/O while the host PC handles decisions โ matching PipeInspect's "firmware handles key events, PC handles the UI".
- Difference: It uses an MQTT message bus and integrates with the ROS2 stack. PipeInspect has no broker; the PC talks to the robot with direct HTTP requests.
- Connection Value: A useful comparison for understanding when a broker becomes necessary โ scaling to multiple robots or adding remote monitoring.
3. PoliTOcean-EVA โ Distributed Underwater Robot Control System
- Link: WIZnet Maker Site โ PoliTOcean-EVA
- Similarity Point: The closest match in application character: a tethered inspection robot operating in a space humans cannot enter (underwater / inside a pipe), controlled over wired Ethernet.
- Difference: EVA ROV is a distributed control system linking several microcontrollers over MQTT with far stricter real-time requirements. PipeInspect is a single-controller machine for above-ground pipework.
- Connection Value: Supports the case that wired Ethernet is the standard choice for tethered inspection robots.
4. ESP32-CameraWebServer-ov5640 (ESP32-CAM + W5500)
- Link: WIZnet Maker Site โ ESP32-CameraWebServer-ov5640
- Similarity Point: Real-time video transported over W5500 Ethernet.
- Difference: PipeInspect receives video over the camera's Wi-Fi rather than the W5500. This project does the opposite and sends video over the wire too.
- Connection Value: It points at PipeInspect's most promising improvement: swapping the Wi-Fi action cam for an Ethernet camera module removes the dual-network setup and the subnet overlap in one move.
๐ Market & Application Value
Applicable fields
| Field | Use |
|---|---|
| Pipe and sewer inspection | Visual checks for cracks, sediment and joint condition inside pipework |
| Duct and ventilation inspection | Contamination and damage checks inside HVAC ducting |
| Under-equipment and confined spaces | Machine undersides and crawl spaces humans cannot easily enter |
| Building maintenance | Wall cavities and cable routing verification |
| Education and research | A teaching example of a tethered mobile robot with a wired control link |
The dual-steer layout and small form factor suit pipe interiors where there is no room to turn. However, the public material contains no ingress-protection rating, durability testing or minimum traversable pipe diameter, so there is no basis for judging real-world deployment limits.
B2C and B2B applicability
- Makers and education: Arduino-level firmware plus a Flask web UI makes this a good minimal example of the "wired control, wireless video" pattern.
- Small facility management: There is room to build something similar at a fraction of the cost of a commercial pipe camera โ though in its current state the servo implementation and pin assignment must be completed by hand.
- Product developers: Usable as a reference for ESP32-C3 + W5500 in motion applications where command latency matters.
Expansion into a solution package
- ESP32-C3 + W5500 SPI reference wiring (a corrected version without the pin conflict)
- A safety layer example including command timeout and watchdog
- Dual-steer mechanical design and servo selection guide
- A single-network variant using an Ethernet camera
- A PoE configuration collapsing the tether into one power-plus-data cable
Turning this into a real reference package would additionally require a waterproof enclosure, tether management, lighting, and power design.
๐ External Indicators
The figures below are a snapshot verified on 2026-08-12 and may change.
| Indicator | Result | Interpretation |
|---|---|---|
| GitHub Stars | 0 | An individual prototype with no external attention yet. |
| GitHub Forks | 0 | No evidence of external reuse. |
| GitHub Commits | 4 | Immediately post-initial-implementation; no sustained maintenance history. |
| Releases / Packages | 0 | No distributable artefact has been published. |
| License | None | No LICENSE file, so reuse and redistribution terms are undefined. |
| Topics / Description | None | Repository metadata is empty. |
| Languages | C++ 24.3% ยท JavaScript 22.0% ยท Python 19.4% ยท HTML 17.3% ยท CSS 17.0% | Firmware and web stack are evenly balanced. |
| Documentation consistency | The README's project root is written as getabec/, which does not match the repository name | Appears to be a leftover from a rename. |
โ ๏ธ Note on licensing
The absence of a LICENSE file does not mean the code is free to use โ it means default copyright applies in full. Confirm with the author before any coverage or redistribution that goes beyond fair quotation of code.
๐ WIZnet Strategic Value
Confirmed facts
PipeInspect uses the W5500 not in a fixed sensor node or a stationary controller, but as the command link of a moving robot. Placed alongside the W5500 robotics cases already on the WIZnet Maker Site, a pattern emerges.
W5500 in Robotics โ Maker Site case lineage
Fixed installation
โโ STM32F103 Multi-Axis Motion Controller
โโ ESP32UDP LinuxCNC Motion Controller
โโ machine tools, multi-axis motion; deterministic latency is the point
Mobile / tethered
โโ ROS2 Jazzy Rover (ESP32 + W5500 + MQTT)
โโ ESP32-S3 micro-ROS Node Suite (5-node rover)
โโ PoliTOcean-EVA (underwater ROV, tethered)
โโ PipeInspect (pipe inspection, tethered) โ this project
โโ spaces where wireless does not reach or cannot be trustedInterpretation
The shared requirements across this lineage are:
- Reliability of command delivery matters more than bandwidth.
- A physical tether already exists, so the marginal cost of going wired is low.
- The RF environment is hostile โ metal structures, water, underground.
- A compact Ethernet interface that connects to an MCU over SPI is required.
- Motor/servo control loops and network handling must coexist on the same MCU.
PipeInspect's place in that lineage is the simplest entry point. With no ROS and no MQTT โ just HTTP/JSON โ it is the minimum viable form of W5500-based robot control, readable by a developer encountering the pattern for the first time. Conversely, because its reliability and safety layers are entirely absent, it also illustrates by contrast why the other three cases reached for brokers and real-time stacks.
๐ Summary
PipeInspect (GetabegRobot) is an open source project that uses an ESP32-C3 and a W5500 to drive a dual-steer pipe inspection robot over wired Ethernet, while receiving video separately over the SJCAM SJ4000's Wi-Fi. Its distinguishing traits are the split of control and video across different media, a compact hold-style key-event HTTP/JSON protocol, and independent front and rear steering.
The W5500 connects to the ESP32-C3 over SPI (SCK 4 ยท MISO 5 ยท MOSI 6 ยท CS 7 ยท RST 10) and serves HTTP at static IP 192.168.1.100. Because access goes through the Arduino Ethernet.h library, no direct socket API use or TOE performance figure appears in the public source; the firm value of this case lies in using the W5500 as a reliable command link for a mobile robot.
At the same time this repository is an early prototype โ 4 commits, 0 stars, no license โ with unfinished servo output and, critically, camera servo pins that collide with the W5500 SPI pins. Both PC-side networks also share one subnet. It should therefore be treated as a source of structural ideas whose implementation must be corrected by the reader, not as a reproducible finished build.
๐ Key Questions & Clear Answers
1. What problem does PipeInspect solve?
It lets an operator visually inspect the inside of pipework that humans cannot enter, using a dual-steer robot that can manoeuvre in confined space, driven from a PC browser with a live video feed.
2. What role does the W5500 play?
It connects to the ESP32-C3 over SPI and provides a dedicated wired Ethernet interface for control commands. It is not involved in video transport or servo drive. Whether the direct WIZnet socket API or TCP/IP offload is used is not verifiable from the public source.
3. Why isn't the video sent over Ethernet too?
Because the project uses an off-the-shelf SJCAM SJ4000, which only exposes video through its own Wi-Fi AP. Replacing it with an Ethernet camera module would allow a single-network design, and that is the project's most promising improvement.
4. Will the code work if flashed as-is?
No. Servo output is still an analogWrite placeholder, and CAM_PAN_PIN / CAM_TILT_PIN are defined on the same GPIOs as the W5500's SPI_SCK / SPI_MISO. You must move the camera servo pins to free GPIOs and apply a real servo library such as ESP32Servo.
5. What can a developer reuse?
The key-event protocol design built from just three actions (down / up / press), the approach of letting the firmware own the hold state to reduce packet volume, and the Flask stream-proxy pattern that transcodes RTSP to MJPEG with FFmpeg to sidestep CORS.
6. What would it take to turn this into a product?
A safety layer with command timeout and watchdog, PWM-based speed control, a waterproof enclosure and lighting, a tether management scheme, and an explicit license.