🤖 Smart Gesture Bot | Hand Gesture Controlled Robot Excited to share one of my personal projects — a robot that I built which can be controlled entirely through hand gestures, no remote or joystick needed! 🖐️ How it works: Using a webcam on my laptop, the system detects and tracks my hand movements in real time using MediaPipe and OpenCV. Based on the gesture recognized, commands are sent to an Arduino via serial/Bluetooth, which then drives the bot in the corresponding direction — forward, backward, left, or right. 🛠️ Tech Stack: → MediaPipe — hand landmark detection & gesture recognition → OpenCV — real-time video processing → Python — core logic & gesture mapping → Arduino IDE — motor control & hardware programming → Serial / Bluetooth — communication between PC and bot 💡 This project gave me hands-on experience combining computer vision, machine learning, and embedded systems — all from scratch as a self-driven build. The best part? It works in real time with minimal delay, and the gesture set can be expanded to add even more controls in the future. 🚀 Always excited to build things that sit at the intersection of software and hardware. Drop a comment or DM if you'd like to know more! #Robotics #ComputerVision #MediaPipe #OpenCV #Arduino #MachineLearning #HandGestureControl #EmbeddedSystems #Python #DIYRobotics #MakerCommunity

𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐚 𝟎 & 𝟏 𝐏𝐨𝐢𝐧𝐭 𝐂𝐥𝐨𝐮𝐝 𝐁𝐨𝐝𝐲 (𝐑𝐞𝐚𝐥-𝐓𝐢𝐦𝐞 𝐀𝐈 𝐕𝐢𝐬𝐢𝐨𝐧) I built a system that turns your entire body into a glowing cloud of 0s and 1s in real time using just a webcam. This project explores how computer vision can transform raw pixel data into structured visual representations—similar to perception systems being developed at NVIDIA and Open Robotics 𝐇𝐞𝐫𝐞’𝐬 𝐰𝐡𝐚𝐭 𝐢𝐭 𝐜𝐚𝐧 𝐝𝐨: - Captures your body using real-time webcam input - Converts pixel brightness into a dynamic 0/1 point cloud - Reveals facial structure and depth using binary visualisation - Creates a glowing, iridescent cyber-style effect - Updates live as you move 𝐔𝐧𝐝𝐞𝐫 𝐭𝐡𝐞 𝐡𝐨𝐨𝐝: - MediaPipe for face/body awareness - OpenCV for real-time frame processing - NumPy for efficient numerical computation - Python Coding for integrating the full pipeline The system processes each frame, maps brightness to binary states, and renders a live point cloud, creating a minimal yet powerful representation of the human body using just 0s and 1s. 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐦𝐚𝐭𝐭𝐞𝐫𝐬: - Demonstrates how visual data can be compressed into meaningful structures - Useful in areas like 3D perception, AR/VR, and digital twins - Connects to real-world applications in autonomous systems and robotics (explored by Tesla and Boston Dynamics) 🔗 Source Code: https://lnkd.in/gsqqR6CB #ComputerVision #ArtificialIntelligence #OpenCV #Python #Robotics

🚀 #LeetCode Day Problem Solving 🚀 Day-20 📌 Problem: A robot starts at position (0, 0) on a 2D plane. You are given a string moves representing its movement sequence. Each character in the string denotes a move: ➡ 'R' → Right ⬅ 'L' → Left ⬆ 'U' → Up ⬇ 'D' → Down 👉 Your task is to determine whether the robot returns to the origin (0, 0) after completing all moves. Return true if it returns to origin, otherwise false. 🧠 Example 1: Input: moves = "UD" ✅ Output: true 📖 Explanation: Move Up → (0, 1) Move Down → (0, 0) ✔ Robot returns to origin 🧠 Example 2: Input: moves = "LL" ❌ Output: false 📖 Explanation: Move Left → (-1, 0) Move Left → (-2, 0) ❌ Robot does not return to origin 💡 Key Insight: ✔ Count movements: Number of 'U' should equal 'D' Number of 'L' should equal 'R' ✔ OR simulate coordinates: Track (x, y) position 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 🧠 What I Learned: ✔ Simple simulation problems can be solved efficiently ✔ Importance of balancing movements ✔ Good practice for coordinate tracking ✅ Day 20 Completed 🚀 Keep going strong with DSA & consistency 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🚀 LeetCode Day Problem Solving 🚀 Day-39 📌 Problem: A robot starts at position (0, 0) on a 2D plane. You are given a string moves representing its movement sequence. Each character in the string denotes a move: ➡ 'R' → Right ⬅ 'L' → Left ⬆ 'U' → Up ⬇ 'D' → Down 👉 Your task is to determine whether the robot returns to the origin (0, 0) after completing all moves. Return true if it returns to origin, otherwise false. 🧠 Example 1: Input: moves = "UD" ✅ Output: true 📖 Explanation: Move Up → (0, 1) Move Down → (0, 0) ✔ Robot returns to origin 🧠 Example 2: Input: moves = "LL" ❌ Output: false 📖 Explanation: Move Left → (-1, 0) Move Left → (-2, 0) ❌ Robot does not return to origin 💡 Key Insight: ✔ Count movements: Number of 'U' should equal 'D' Number of 'L' should equal 'R' ✔ OR simulate coordinates: Track (x, y) position 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 🧠 What I Learned: ✔ Simple simulation problems can be solved efficiently ✔ Importance of balancing movements ✔ Good practice for coordinate tracking ✅ Day 39 Completed 🚀 Keep going strong with DSA & consistency 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀

🤖 Sequential vs Parallel Programming — Lessons from a Robotics Competition In a robotics competition, speed isn’t just an advantage… it’s everything. Now imagine two robots on the field 👇 Robot A (Sequential): Moves → stops → processes → acts → repeats Everything happens step by step. Robot B (Parallel): Moves while processing sensor data Adjusts path in real-time Controls multiple components simultaneously Who wins? ⚡ 💥 Parallel programming changes the game in robotics: • Real-time decision making – Sensors, motors, and logic run together • Faster response – No waiting for one task to finish before starting another • Smarter systems – Vision processing + movement + control happening at once • Competitive edge – Milliseconds can decide the winner Think about it: A robot navigating obstacles can’t afford to “finish thinking” before it moves. It has to think, see, and act — all at the same time. That’s parallel programming in action. ⚠️ But here’s where it gets interesting: Parallel systems are harder to design. More threads, more coordination, more chances for things to go wrong. But in a competition setting? 👉 That complexity is often the difference between average and outstanding. 🚀 The takeaway: Sequential programming builds a working robot. Parallel programming builds a winning robot. And in robotics competitions… there’s no prize for finishing second because your code was “simpler.” #Robotics #Programming #ParallelComputing #Engineering #TechInnovation #STEM #RoboticsCompetition

🚀 Constructing a Vision-Based Robotic Path Planning System (OpenCV + ROS2) I've been working on a self-project for the past several days where I am extending my bachelor's project to a vision-based robotic pipeline in ROS2 simulation environment. I use ROS2 to transform image contours into a robot-executable trajectories. The system uses OpenCV to extract contours from an image, transforms them into continuous, flowing routes. They are published as ROS2 topics, makes the trajectory visible in RViz, and converts the path into positions suitable for robots. ✅ Key learning in this would be, instead of treating vision and robotics separately, I focused on building a full pipeline: Image → Contour → Path → Pose → (followed by a robot execution) ✅ I used Python, OpenCV, ROS2 (jazzy) and Rviz2 tools. ✅ Currently, working on integrating MoveIt to make a UR5 robot follow the generated trajectory. 📌 This project is helping me deeply understand: • ROS2 node architecture • Data flow in robotic systems • Trajectory generation from perception 🔭 Next Steps: I’m planning to extend this work by integrating the trajectory with a simulated robot (UR5) using tools like Gazebo and NVIDIA Isaac Sim. Additionally, I aim to explore navigation frameworks (Nav2) to understand how perception-driven paths can be used in autonomous systems. ☑️ The goal is to move from perception → planning → full robotic execution. Really enjoying building this step by step — open to feedback and suggestions! 🤗 #ROS2 #Robotics #ComputerVision #OpenCV #Automation #Engineering #SelfLearning

Built a fully autonomous AI robot from scratch for under $70. Meet ARIA, AI Robot Intelligence Assistant. Over the past few weeks, I designed and built a robot that can recognize faces, hold AI-powered conversations, follow voice commands, avoid obstacles, and track people using Bluetooth — all running on a Raspberry Pi Zero 2W and Arduino Uno. What surprised me most was not how complex it was, but how much you can build with limited hardware when you understand the fundamentals deeply. Every module (vision, voice, motors, AI) I built and debugged myself. The hardest part was getting three different power systems, serial communication, and Bluetooth working together reliably. Tech stack: Python, OpenCV, Claude API, Google Speech API, Arduino C++, L298N, HC-SR04, gTTS Full code is open source: https://lnkd.in/gk7wukpf Happy to connect with anyone working on robotics, edge AI, or embedded systems. #Robotics #AI #Python #RaspberryPi #Arduino #EdgeAI #MachineLearning #MSBA #DataScience

#day63 🚀 19/04/26 — Precision Tracking: Robot Return to Origin Today, I solved Robot Return to Origin (LeetCode 657), applying coordinate-based tracking to determine if a sequence of moves returns a robot to its starting position. This problem is a great exercise in Simulation and state management using simple array counters. 🤖 The Origin Logic The objective is to determine if a robot, starting at (0,0) on a 2D plane, returns to (0,0) after executing a string of moves: 'U' (up), 'D' (down), 'L' (left), and 'R' (right). The Logic: Coordinate Simulation State Representation: I used a small integer array arr of size 2 to represent the (x, y) coordinates, initialized at {0, 0}. arr[0] tracks horizontal movement (x-axis). arr[1] tracks vertical movement (y-axis). Linear Execution: I iterated through the moves string exactly once. Vertical: Increment arr[1] for 'U' and decrement for 'D'. Horizontal: Increment arr[0] for 'R' and decrement for 'L'. Verification: The robot returns to the origin if and only if both final coordinates are zero (arr[0] == 0 && arr[1] == 0). Complexity: Time: O(n) where n is the length of the moves string. Space: O(1) as we only use a fixed-size array regardless of the number of moves. 📈 Consistency Report: Foundations of Simulation Today's solution emphasizes that complex tracking problems can often be reduced to basic arithmetic operations on a fixed state. This is a more streamlined version of the Two-Pointer and Sliding Window techniques I've been mastering—while those patterns focus on sub-segments of data, this simulation tracks the global state of an object over time. Huge thanks to the roadmap for building this momentum! Moving from array partitioning to 2D state simulation shows how my problem-solving intuition is expanding. My O(n) coordinate tracking implementation is attached below! 📄👇 #DSA #Java #LeetCode #Simulation #Optimization #Complexity #63DayStreak #LearningInPublic

Open Source Robotic Arm for All Developers [📍Github Below] A robotic arm project (reBot-DevArm) dedicated to lowering the barrier to learning Embodied AI. They focus on "True Open Source" (not just the code), they unreservedly open source everything: > Hardware Blueprints: Source files for sheet metal parts and 3D printed parts. > BOM List: Detailed down to the specifications and purchase links for every single screw. > Software & Algorithms: Python SDK, ROS1/2, Isaac Sim, LeRobot, etc. Credit to the Seed Studio and thanks for reaching out, Elaine Wu! 📍GitHub: https://lnkd.in/dH4e8Vxp —- Weekly robotics and AI insights. Subscribe free: 22astronauts.com

Ilir Aliu Appreciate for bringing our fully open-source #reBot Arm to the robotics community—great to see it resonating with developers! reBot is launching this week, and you’re welcome to get early hands-on access by joining our local workshop in Santa Clara 👉 https://luma.com/ryqflfoc Looking forward to building together, and making robotics more accessible and easier in further development. 🤩