AI claude
OpenHug: Open-Source Remote Touch Project
Idea by [your name], October 2026. Released under CC0: no patent, no owner, free for everyone to build, improve, sell or give away.
1. What this project is
Video calls give us sight and sound but no touch. OpenHug is an open design for a phone call you can feel: when a loved one calls, their touch (a squeeze, a pat, a hug) travels over the connection and is reproduced by a soft wearable on the receiver, while an avatar or video shows who is touching you.
It is meant for people who are isolated: elderly people living alone, patients in hospitals or care homes, and anyone far from family.
Honest scope. This guide builds a working first version: one person squeezes a pressure pad, and another person feels a gentle, controlled squeeze or vibration on a wearable. Full-body hugs, realistic warmth and floating holograms are future research. They are listed in the roadmap so the community can work on them.
2. Safety rules (read first)
These rules apply to every version of the project.
- Low voltage only. Everything runs from a 5 V USB power bank. Never connect anything worn on the body to mains power.
- No heating in the first version. Warmth comes later, and only with a temperature sensor and an automatic cutoff (see Stage 3).
- Pressure and strength limits are set in firmware and cannot be exceeded by the incoming signal.
- Instant stop. A physical stop button on the wearable cuts all output. The output also stops by itself if the signal is lost for half a second.
- Soft materials against skin. Cover all electronics with fabric. No bare wires or sharp edges.
- Consent first. Test only with people who agree to take part. Stop if anyone feels discomfort.
- Not a medical device. Do not use it for people with pacemakers or implanted devices, or for treatment, without review by a qualified engineer or doctor.
This guide is not a safety certification. Anyone building a product for wider use should have it reviewed by an electrical or medical-device engineer.
3. How the system works
SENDER SIDE RECEIVER SIDE
(the person who calls) (the person who is touched)
Pressure pad -> ESP32 (sender) -> [radio or internet] -> ESP32 (receiver) -> Motor driver -> Vibration motors in a vest or sleeve
^
Stop button + signal-loss cutoff
Phone video call (WebRTC or any video app) runs alongside, so you see and hear the person.There are three build stages:
- Stage 1: Bench prototype (same room). Two ESP32 boards talk directly over ESP-NOW. No internet or router needed. Fully described below.
- Stage 2: Over the internet. Replace ESP-NOW with MQTT or WebSocket through a phone app, so the sender and receiver can be in different cities.
- Stage 3: Comfort upgrades. Air-pressure pockets, safe warmth, AR avatar, more sensors.
4. Stage 1 parts list
Prices are rough estimates in US dollars and vary by country and shop. The whole kit is usually about 25 to 40 dollars.
# | Part | Qty | Notes | Approx. cost |
|---|---|---|---|---|
1 | ESP32 development board (ESP32-WROOM-32 DevKit) | 2 | One sender, one receiver | $10 |
2 | Force-sensitive resistor (FSR 402 or similar, round, about 12 mm) | 1 | The pressure sensor | $6 |
3 | 10 kΩ resistor | 1 | Pairs with the FSR | $0.10 |
4 | ULN2003 driver module (4 or 7 channel, with flyback diodes) | 1 | Drives the motors safely | $2 |
5 | Coin vibration motors (3 V, 10 mm) | 4 | The "touch" output | $5 |
6 | Momentary push button | 1 | Stop button | $0.50 |
7 | USB power banks (5 V) | 2 | Power for each board | $15 (or reuse) |
8 | Breadboard and jumper wires | 1 set | For prototyping | $5 |
9 | Soft fabric vest, sleeve or strap, plus tape or Velcro | 1 | Holds the motors against the body | $5 |
10 | Foam sheet, 5 mm | 1 | Cushion between motor and skin | $2 |
Tools: a USB cable for each board, a computer with the Arduino IDE (free), and a small screwdriver. Soldering is helpful for the final wearable but not needed for the bench prototype.
5. Wiring
5.1 Sender (pressure pad to ESP32)
3V3 ----[ FSR ]----+---- GPIO34
|
[10 kΩ]
|
GND ---------------+- One FSR leg goes to 3V3.
- The other FSR leg goes to GPIO34 and also to one end of the 10 kΩ resistor.
- The other end of the resistor goes to GND.
- Power the board from a USB power bank.
The harder you press the FSR, the higher the voltage on GPIO34.
5.2 Receiver (ESP32 to driver to motors)
ESP32 pin | Goes to |
|---|---|
GPIO25 | ULN2003 input 1 (IN1) |
GPIO26 | ULN2003 input 2 (IN2) |
GPIO27 | ULN2003 input 3 (IN3) |
GPIO14 | ULN2003 input 4 (IN4) |
GPIO33 | One leg of the stop button (other leg to GND) |
GND | ULN2003 GND, power bank GND |
5V (VIN) | ULN2003 motor supply pin (often labeled + or VCC) |
- Connect each coin motor between the ULN2003 output for its channel (OUT1 to OUT4) and the 5 V supply line. The ULN2003 module's built-in diodes protect the board from motor spikes.
- All grounds must be joined together.
- Check the polarity of your ULN2003 module's markings, because they differ slightly between brands.
- Power the receiver from the USB power bank.
Mounting. Sew or tape each motor into a small fabric pocket, with a piece of foam between the motor and skin. Keep wires routed along seams, covered, and strain-relieved so they cannot be pulled.
6. Firmware
Install the Arduino IDE, then install the ESP32 board package by Espressif (version 3.x). Select the board "ESP32 Dev Module".
6.1 Find the receiver's MAC address
Upload this to the receiver board, open the Serial Monitor at 115200 baud, and note the address it prints.
#include <WiFi.h>
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
delay(500);
Serial.println(WiFi.macAddress());
}
void loop() {}6.2 Sender firmware
Put the receiver's MAC address into receiverMac (for example AA:BB:CC:DD:EE:FF becomes 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF). Upload to the sender board.
#include <WiFi.h>
#include <esp_now.h>
// Replace with your receiver's MAC address
uint8_t receiverMac[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
const int PAD_PIN = 34; // FSR input
typedef struct {
uint8_t pressure; // 0 (no touch) to 255 (hard press)
} TouchMessage;
float smoothed = 0;
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW init failed");
return;
}
esp_now_peer_info_t peer = {};
memcpy(peer.peer_addr, receiverMac, 6);
peer.channel = 0;
peer.encrypt = false;
if (esp_now_add_peer(&peer) != ESP_OK) {
Serial.println("Failed to add peer");
}
}
void loop() {
int raw = analogRead(PAD_PIN); // 0 to 4095
smoothed = 0.8f * smoothed + 0.2f * raw; // smooth out jitter
// Ignore tiny readings (noise), then scale to 0-255
int level = 0;
if (smoothed > 150) {
level = map((int)smoothed, 150, 3500, 0, 255);
level = constrain(level, 0, 255);
}
TouchMessage msg;
msg.pressure = (uint8_t)level;
esp_now_send(receiverMac, (uint8_t *)&msg, sizeof(msg));
delay(20); // 50 updates per second
}6.3 Receiver firmware
Upload to the receiver board.
#include <WiFi.h>
#include <esp_now.h>
const int MOTOR_PINS[] = {25, 26, 27, 14};
const int NUM_MOTORS = 4;
const int STOP_PIN = 33; // stop button to GND
// Safety limits
const uint8_t MAX_DUTY = 160; // never drive motors above this (max 255)
const unsigned long SIGNAL_TIMEOUT = 500; // ms: stop if no data arrives
const float RAMP_STEP = 4.0f; // how fast strength changes per loop
typedef struct {
uint8_t pressure;
} TouchMessage;
volatile uint8_t targetLevel = 0;
volatile unsigned long lastMessageTime = 0;
float currentLevel = 0;
// Called whenever a message arrives (ESP32 Arduino core 3.x)
void onReceive(const esp_now_recv_info_t *info, const uint8_t *data, int len) {
if (len != sizeof(TouchMessage)) return;
TouchMessage msg;
memcpy(&msg, data, sizeof(msg));
targetLevel = msg.pressure;
lastMessageTime = millis();
}
void setup() {
Serial.begin(115200);
pinMode(STOP_PIN, INPUT_PULLUP);
for (int i = 0; i < NUM_MOTORS; i++) {
ledcAttach(MOTOR_PINS[i], 1000, 8); // 1 kHz, 8-bit
ledcWrite(MOTOR_PINS[i], 0);
}
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW init failed");
return;
}
esp_now_register_recv_cb(onReceive);
lastMessageTime = millis();
}
void loop() {
uint8_t goal = targetLevel;
// Safety 1: stop button pressed
if (digitalRead(STOP_PIN) == LOW) goal = 0;
// Safety 2: signal lost
if (millis() - lastMessageTime > SIGNAL_TIMEOUT) goal = 0;
// Safety 3: limit maximum strength
if (goal > MAX_DUTY) goal = MAX_DUTY;
// Smooth ramp up and down so it feels gentle, not jerky
if (currentLevel < goal) currentLevel = min((float)goal, currentLevel + RAMP_STEP);
else if (currentLevel > goal) currentLevel = max((float)goal, currentLevel - RAMP_STEP);
for (int i = 0; i < NUM_MOTORS; i++) {
ledcWrite(MOTOR_PINS[i], (uint8_t)currentLevel);
}
delay(10);
}If you use an older ESP32 core (2.x): replace ledcAttach(pin, 1000, 8) with ledcSetup(channel, 1000, 8) plus ledcAttachPin(pin, channel), replace ledcWrite(pin, value) with ledcWrite(channel, value), and change the receive callback to void onReceive(const uint8_t *mac, const uint8_t *data, int len). The simplest fix is to update to core 3.x.
7. Testing
7.1 Bench test (no one wearing anything)
- Power the receiver. Confirm nothing vibrates.
- Power the sender. Press the FSR lightly, then firmly. The motors should ramp up smoothly, never above the
MAX_DUTYlimit. - Release the pad. Motors should fade to zero.
- Switch the sender off. Within half a second the motors must stop by themselves.
- Press the stop button while pressing the pad. Motors must stop immediately.
Do not put the wearable on anyone until all five checks pass.
7.2 Comfort test (with consenting people)
- Start at very low strength and increase slowly.
- Ask: Is it comfortable? Does it feel like a gentle squeeze or a pat? Is it too buzzy?
- Try different motor positions (upper back, shoulders, upper arm).
- Record the answers. Comfort data is as valuable as technical data.
7.3 Common problems
Problem | Likely cause |
|---|---|
Nothing happens | Wrong MAC address in sender; boards on different ESP32 core versions |
Motors always on or jittery | Missing 10 kΩ resistor, or noisy FSR readings; raise the 150 threshold |
Motors weak | Power bank cannot supply enough current; try another one |
Board resets when motors start | Motors drawing too much; reduce |
Compile error on | Old ESP32 core; update to 3.x or use the 2.x changes above |
8. Stage 2: Over the internet
To let the two people be in different places:
- Replace ESP-NOW with Wi-Fi plus MQTT. Both boards connect to a broker (Mosquitto or a free hosted broker) and publish and subscribe on a private topic, for example
openhug/<random-room-code>/touch. - Use TLS and a username and password on the broker so strangers cannot send touch signals to a wearable.
- Keep the same safety logic on the receiver: maximum strength, ramping, signal-loss cutoff and stop button. Never trust the network to be safe.
- Build a simple phone or web app that starts a WebRTC video call and shows touch activity next to the video. Open WebRTC libraries make this possible.
- Add latency measurement. Touch feels natural when the delay is under about 150 milliseconds.
A phone-only sender is also possible: the phone's camera and body tracking (for example MediaPipe) can detect a hug gesture instead of a pressure pad.
9. Stage 3: Comfort upgrades
- Air-pressure pockets. Small silicone or TPU air bladders with a mini pump and valve give a real squeeze instead of vibration. Use a pressure sensor and a hard pressure limit with a release valve.
- Safe warmth. Thin flexible heating pads with a temperature sensor on the pad, a hardware thermal cutoff, and a firmware limit of around 38 to 40 °C at the skin surface. Always test on a bench first. Never leave heating on unattended.
- More zones. Add motors or pockets across the back, shoulders and arms so a hug feels like it wraps around.
- AR avatar. Show the caller as a 3D avatar in AR glasses or on the phone, synced to the touch signal.
- AI smoothing. Turn raw sensor data into natural touch patterns (a slow squeeze, a pat on the back, a gentle release) with a small on-device model. Keep AI inside the safety limits, never above them.
- Two-way touch. Give both people a suit or pad so the touch is truly mutual.
10. Roadmap
Phase | Goal | Rough time for a small team |
|---|---|---|
1 | Bench prototype: pad to vibration motors | Days to weeks |
2 | Internet link with video call | 1 to 3 months |
3 | Comfortable wearable (vest or sleeve), tested with volunteers | 6 to 12 months |
4 | Air-pressure squeeze and safe warmth | 1 to 2 years |
5 | Full upper-body hug, AR avatar, two-way touch | Research stage, several years |
11. Suggested repository layout
openhug/
README.md (this document)
LICENSE (CC0 for docs, MIT or Apache 2.0 for code, CERN-OHL for hardware)
firmware/
sender/sender.ino
receiver/receiver.ino
find_mac/find_mac.ino
hardware/
wiring-diagrams/
parts-list.csv
wearable-patterns/
app/
(phone or web app for Stage 2)
docs/
safety.md
test-results.md
comfort-study.md12. How to publish and keep it free
- Create a free GitHub account and a new public repository named
openhug. - Paste this document as
README.mdand add the firmware files. - Add the licenses: CC0 for documents, MIT or Apache 2.0 for software, CERN-OHL for hardware designs.
- Make a Zenodo upload from the GitHub release. This gives a permanent, dated record, which is useful public prior art.
- Post on X with a link to the repository and the date.
Publishing openly does not stop other people from patenting their own separate improvements, and this is not legal advice. For anything important, a short consultation with an IP lawyer or an open-source organization is worthwhile.
13. How to contribute
Anyone is welcome: engineers, designers, textile makers, doctors, nurses, psychologists, and people who have lived with loneliness. Useful contributions include:
- Better wiring diagrams and a printed circuit board design
- Comfortable, washable wearable patterns
- Safer heating and air-pressure designs
- Latency and comfort test results
- Translations of this guide
- Care-home pilots with proper consent and ethics approval
14. Current limits (honest summary)
- Vibration and squeeze can comfort, but they recreate touch. They are not the other person's actual touch.
- A floating hologram you can physically touch does not exist today. Seeing the person needs video, a screen, or AR glasses.
- Realistic warmth, full-body hugs and long-wear comfort are open research problems.
- This guide describes a starting point, not a certified product.
Free for everyone. Build it, improve it, share it.
============================================================
my original chat with AI
HOLOGRAPHIC HUMAN THROUGH FUTURE PHONE
as a thread (5 posts)
1/5
OPEN IDEA, CC0, no patent, free for everyone to build. A phone call you can feel: when a loved one rings, an AI links their presence to a haptic suit you wear, so you can receive a warm hug from far away. For people who are isolated. 🧵
2/5
How it works:
- Phone rings
- The caller appears as a hologram or AR avatar
- AI turns their movements into touch signals
- A haptic suit applies pressure and warmth where you reach out
- The caller wears a suit or sensors too, so the touch is really theirs
3/5
Possible today: haptic vests, remote-hug devices, AR glasses, AI motion tracking.
Needs research: realistic full-body touch, warmth control, a light and comfortable suit.
Any real device needs proper safety testing.
4/5
Why: video calls give sight and sound but no touch. Touch comforts people. This could help elderly people, patients, and anyone far from family.
5/5
No patent, no owner. Copy it, improve it, build it, sell it, or give it away. Idea shared by [KURIAN.MODALE.KORA= name], October 2026. Released under CC0. #OpenSource #CC0 #Haptics
..............................................................................................................................................................
AI GOOGLE:- FIRST CHAT -WHEN I APPROACHED WITH MY IDEA
- The Inbound Call: A loved one or an AI companion calls a smartphone.
- The Holographic Trigger: The phone instantly projects a 3D visual hologram of that specific person into the room.
- The AI Neural Bridge: The phone's AI acts as the "brain," translating the caller's movements and gestures into physical data.
- The VR Suit Mapping: The AI beams this data directly to a smart haptic VR suit worn by the isolated user. The suit's internal fabric shifts, compresses, and warms up.
- The Genuine Embrace: When the user reaches out to touch the floating hologram, the VR suit resists their movement and applies pressure at the exact contact points. The user feels the authentic weight, shape, and warmth of a real human being.
- Global Scientific Collaboration: Universities, independent developers, and tech giants can openly share code. An AI developer in India can optimize the tracking system, while a material engineer in Germany perfects the haptic suit fabric, and both can integrate their work instantly.
- Affordability for Healthcare: Without expensive patent licensing fees, the technology can be manufactured at a fraction of the cost. This means hospitals, nursing homes, and mental health clinics worldwide can easily afford these setups for isolated patients [health].
- Rapid Evolution: Open-source projects evolve exponentially faster than closed, patented ones. What might take a single corporation 15 years to build could be achieved in 3 to 5 years by a passionate global community.
SO MY WISH IS FOR ITS USE SOON BY EVERYBODY FOR A HAPPIER LIFE
