Hi, I´m 15yo student from Slovakia, and I´m getting ready, and preparing to make my first robotic hand using servo motors, and computer vision (OpenCV), to mimic my hand and finger movement, but I have one question. On all the videos I have seen, the fingers can only be fully closed, or fully open, nothing in between, and I want to make something, that van also do partial movements of fingers. Has anyone attempted this? I´m not familiar with, OpenCV yet, so I´m asking, if this is even possible?

Thanks for answers!

Hi, I´m 15 yo student from Slovakia, currently in High School, studying general studies. A while ago I became interested in engineering, programming, embedded systems, robotics, software... and that kind of stuff. I am planning to pursuing this path long term, and I wanted a few tips. I had a conversation with AI, told it what exactly I want to accomplish, what I want to do, and all that stuff around that, and asked for some structured roadmap, that I can follow, and accomplish my goals. I have already some basics in C++, I learned thru www.learncpp.com , and I also bought an ESP32, 51 sensors kit, and some other stuff, like transistors, resistors, capacitors, and many more. Does anyone have any advice, of how can I do this, and how long will it take if, I spend like 2 hours daily? Also, what is the best way to learn all these concepts, I have already tried using flashcard, to learn all the theory, and I spend like 20 minutes daily, reviewing them. Is this a good way of learning this kind of stuff, or am I doing it completely wrong? Here´s the roadmap, can u tell me some thoughts about it, if something is missing, or anything...

🛠️ PART 1: Physical Mechanics, Analog Basics, and First C++ Structures

Here, you will immediately bridge 3D vectors, connect mechanics with analog electronics, and clean up your C++ basics.

Mathematics & Physics:

• [ ] Torque & Levers – Your absolute next step!
• [ ] Moment of Inertia and Center of Mass.

Electronics Theory:

• [ ] Ohm's Law ($I = \frac{U}{R}$) and calculating resistor values for your LEDs.
• [ ] Kirchhoff's Laws (how current and voltage divide in a circuit).
• [ ] Voltage Divider (A key concept for reading analog sensors).
• [ ] Semiconductors: How a diode works, and using a bipolar junction transistor (2N2222) as a switch.

C++ Programming (The start of your new C++ school):

• [ ] Enums (Enumerations): Scoped (enum class) vs unscoped enums. How to use them to define robot states (e.g., State::IDLE, State::FORWARD, State::ERROR).
• [ ] Structs (Structures): How to group data. You'll create a structure for a 3D Vector (struct Vector3D { float x; float y; float z; }).
• [ ] Memory Basics: Static allocation, stack memory, why you should avoid dynamic arrays in microcontrollers, and the basics of std::array.

Hands-on Bench Projects:

• Project 1: Lever Physics and Torque Simulation in Raylib (C++ using enum class and struct).
• Project 2: Dusk-to-Dawn Switch on a Breadboard (Photoresistor + 2N2222 transistor + LED – pure analog without any programming, where you will see Ohm's Law in action).

🤖 PART 2: Matrices, Digital Hardware, Pointers, Diagnostics, and Git

Heading towards memory management in C++, body kinematics, and reading your first digital data via the ESP32-S3.

Mathematics, Kinematics & Version Control:

• [ ] Matrices (Matrix addition and multiplication on paper).
• [ ] Identity and Inverse Matrices.
• [ ] Git & GitHub: How to version your code, understanding commits, pushes, branches, and how to back up your engineering projects like a pro.
• [ ] 3D Rotation Matrices (Rotating objects around the X, Y, and Z axes).
• [ ] Homogeneous Transformation Matrices ($4 \times 4$ matrices for translation and rotation in 3D space).
• [ ] Denavit-Hartenberg (DH) Parameters (The standard convention for describing robot joints).
• [ ] Forward Kinematics (Calculating the exact 3D position of a fingertip/end-effector if you know the joint angles of the motors).

Electronics Theory & Chips:

• [ ] Digital vs. Analog Signals (HIGH/LOW vs. continuous voltage).
• [ ] ADC and DAC Converters (How a chip converts Volts from the real world into numbers in your code, and vice versa).
• [ ] PWM (Pulse Width Modulation) – How to control LED brightness or a servo's position using a digital pin.
• [ ] Communication Protocols: I2C (displays), SPI (SD cards and high-speed sensors), UART (PC communication).
• [ ] [NEW] Logic Diagnostics: How a logic analyzer works, capturing digital signals, and reading I2C/UART data using PulseView software (so you can debug hardware bugs).

C++ Programming (Hardcore C++ Concepts):

• [ ] Pointers & References: What a memory address is (the & operator), pointers (the * operator), and why we pass large data structures by reference in microcontrollers to avoid wasting RAM.
• [ ] Const Correctness: Utilizing const with pointers and references for secure, read-only data access that prevents accidental overwrites.

Hands-on Bench Projects:

• Project 3: Weather Station (Reading data from a DHT11 via I2C and rendering it on an OLED display). Bonus: Connect a logic analyzer to the I2C bus and inspect how the raw bits physically look down the wires.
• Project 4: Temperature-Compensated Sonar (An HC-SR04 measures distance, while code from a DHT11 reads the ambient air temperature and passes it by reference to calculate the exact speed of sound for ultra-precise OLED tracking).
• Project 5: Safe / Combination Lock (Keypad or Rotary Encoder + LCD Display + MG90S Servo Motor).

🚀 PART 3: Dynamics, Filters, Power Delivery, and OOP Architecture

Your robots begin to move smoothly. You'll clean sensor noise and transition to full Object-Oriented Programming and FreeRTOS.

Mathematics & Dynamics:

• [ ] Analytical Inverse Kinematics (Calculating required motor angles from target X, Y, Z coordinates).
• [ ] The Jacobian Matrix and numerical Inverse Kinematics.
• [ ] Kinematic Singularities (When a robot gets stuck or moves erratically due to an impossible or degenerate mathematical orientation).
• [ ] Trajectory Generation (Cubic polynomials and S-curves for smooth motor acceleration without jerking).
• [ ] Newton-Euler and Lagrangian Dynamics (Calculating the forces and torques required to accelerate a robotic arm).

Sensor Fusion, Regulation & Power Delivery:

• [ ] Feedback Loops and system error tracking.
• [ ] PID Controller (Proportional, Integral, and Derivative gains – the backbone of automation).
• [ ] Complementary and Kalman Filters (Mathematically filtering out high-frequency noise from an MPU6050 gyroscope and accelerometer).
• [ ] [NEW] Hardware Power Delivery: How to isolate digital power (for the sensitive ESP32) from inductive loads (motors/servos). The importance of decoupling capacitors, protection against reverse voltage spikes using Schottky diodes, and deploying Buck converters.

C++ Programming (Object-Oriented Programming & Real-time OS):

• [ ] Classes and Objects: Attributes, methods, constructors, and destructors. Data encapsulation (private, public).
• [ ] Inheritance and Polymorphism: Creating a base Sensor class and deriving specific Thermometer or Gyroscope child classes. Working with virtual functions (virtual, override).
• [ ] Real-Time Hardware Management: Interrupts (ISR - Interrupt Service Routines) and hardware Timers.
• [ ] Multithreading and FreeRTOS: How to force a dual-core ESP32-S3 to handle multiple OOP tasks simultaneously in real time.
• [ ] [NEW] Managing Critical Sections in FreeRTOS: What Mutexes (Mutual Exclusion) and Semaphores are. How to safely share variables and data between both cores without data corruption or app crashes (Core Dumps).

Hands-on Bench Projects:

• Project 6: Stabilized Horizon (MPU6050 Gyroscope + Complementary Filter + OLED Display – writing a clean, custom C++ class from scratch).
• Project 7: 3D-Printed Arm Joint Controlled by Joystick (Recording movements to the ESP32 memory and playing them back smoothly via S-curves).
• Project 8: Self-Balancing Robot (Balancing Bot) with active PID regulation. Here you will test Mutexes in a real scenario: one core rapidly calculates PID stability while the second core uses a Mutex to safely read telemetry and update the display.

🎨 PART 4: Intro to Python, Data Processing, and PCB Design

No more messy breadboard jumper wires. You will design real hardware while learning Python to stream data from the ESP32 to a computer for live visualization.

Circuit Design Theory:

• [ ] Schematic Capture, hierarchical blocks, and network buses.
• [ ] Current Capacity and trace sizing (Trace width vs. Amperage).
• [ ] Bypass and Decoupling Capacitors (Filtering power rails directly at the IC pins).
• [ ] Thermal Management (Thermal vias, heatsinking transistors, and voltage regulators).
• [ ] High-Speed Design (Impedance matching differential pairs for USB-C).
• [ ] Manufacturing Outputs (Gerber Files, NC Drill, BOM, Centroid/Pick-and-Place files).

Introduction to Python (Your second programming language):

• [ ] Python Basics: Variables, lists, loops, and functions. Comparing it to C++ (why we don't handle pointers or strict data types explicitly in Python).
• [ ] The PySerial Library: Writing Python code to open a computer's COM port and read data streamed from the ESP32-S3 over USB.
• [ ] Visualization (Matplotlib / Pygame): Taking incoming numeric data and rendering it on your PC screen as a smooth, real-time graph.

Practice and Soldering:

• [ ] Working in professional ECAD software (KiCad or EasyEDA).
• [ ] Designing 2-layer and 4-layer PCBs with an uninterrupted ground plane.
• [ ] SMD Soldering of miniature components under magnification using solder paste and a hot-air rework station or reflow plate.

Hands-on Bench Projects:

• Project 9: Design, order, and assemble your own "ESP32-S3 Master Shield" branded with your LayerLabs logo. It will feature integrated circuit protection, filtered power rails, and dedicated headers for an OLED, servos, and a gyroscope. You'll write a companion Python script to pull diagnostics over USB.

🔥 PART 5: Final Engineering Megaprojekty & Advanced C++ Templates

This is where everything—mathematics, physics, advanced C++ architecture, Python front-ends, 3D printing, and your custom PCBs—merges into complex autonomous machines.

Advanced C++ (Final Level Programming):

• [ ] Templates (Generic Programming): Designing code so your math classes (like a matrix calculator) work seamlessly with float, double, or int data types without duplicating code.
• [ ] Optimization Basics: Code profiling, memory footprints, and static code analysis to guarantee flight safety.

Theory (Optics & Aerodynamics):

• [ ] Optics and Wave Propagation (The Time-of-Flight principle used in Lidar/Radar).
• [ ] Aerodynamics and the physics of quadcopter flight.

Engineering Megaprojects (Your golden ticket to university entry):

• Project 10: 3D Lidar Environmental Scanner (A C++ + Python Masterpiece)
  • A laser ToF sensor (or high-end sonar) mounted onto a dual-axis pan/tilt servo assembly (X and Y axes).
  • An ESP32-S3 running C++ parses spherical coordinates and transforms them into 3D cartesian coordinates $[X, Y, Z]$.
  • This data streams over USB to a PC running a custom Python script paired with the Open3D library, plotting an interactive, rotatable 3D point-cloud map of your room.
• Project 11: Bionic Human Prosthetic Hand (EMG + IK Control)
  • Complete mechanical design and 3D printing of an anatomical palm and fingers.
  • A custom-designed PCB controlling 5 servo motors driven by Inverse Kinematics and smooth acceleration profiles (written using advanced C++ templates and strict OOP classes).
  • Bonus: Control via analog electromyography (EMG) sensors tracking the electrical activity of your forearm muscles.
• Project 12: Autonomous Drone Built from Scratch
  • Designing an ultra-lightweight 3D-printed drone frame.
  • Writing a complete Flight Controller from scratch in pure C++ inside FreeRTOS. It will process gyroscope telemetry via a Kalman filter, stabilize orientation using a PID controller loop, and communicate wirelessly via ESP-NOW to a custom-built transmitter. All designed with robust power delivery to ensure inductive motor noise never resets the MCU.

I´m 15, without any prior coding experience learning C++ from LearnCPP, I had a few suggestion to learn using some graphilac interface. I got recommended two, but I can´t really decide which one to choose.

Can anyone help me?

Is for me better Raylib, or SFML, I want to make simple games like flappy bird, tic tac toe, or simple programms like to do lists and stuff. Which one will suite my needs the best?

Thanks for answers!

Hi, I´m 15, learning C++ with LearnCPP. I´m currently on chapter 14, where is introduction into OOP, classes...

For the theoretical part, I think I understand everything up to this point pretty good, but when it comes to real programming, I´m a little lost. I think the problem is that I don´t have enough of the practical experience, to fully understand it. I tried using AI to give me some exercises, and projects I can build, but none of that really makes difference, cause it is all theme specific and I just can´t figure out, how to use the code in real applications.

Do you have any ideas how can I get better not at understanding the theory, but really building something?

All the people are saying, "Just build something, you learn by experience", but that isn´t the problem, the problem is what to build.

Do anyone have any ideas?

I am currently 15 and learning C++ with LearnCPP, without any prior coding experience (except for scratch, but lets not count that) I´m on chapter 13 (Enum, Struct...)in LearnCPP. I finished writing this program ( it has nothing to do with what I´m currently learning about), and wanted to ask some things.

1. Is there anything that needs to be changed? Are there some things that may function incorrectly in some instances, or do i have any bad practise I should fix?

2. Should I also focus on learning things like for example what is used in this program, the sstream library things and stuff? Because currently, it looks terrifying to use something like this. ( I spent very long time figuring out how to do the check if the input is a integer, and at the end I ended up on some StackOverflow forum.) Is it bad to find information like this, or id it completely normal?

Also one more question, I´m currently 1 month in learning cpp, and I already learned this many things, that I´m proud of. How long will it approximately take to learn all the stuff so I can comfortably write any code that I need.

Thanks for answers!

#include <iostream>
#include <string>
#include <sstream>

int main()
{

std::string inputAsString{};
int inputAsInt{};

while (true)
{
std::cout << "Enter the length of the base of the triangle: ";

std::getline(std::cin, inputAsString);

std::stringstream ss(inputAsString);

if (ss >> inputAsInt && (ss >> std::ws).eof() && inputAsInt > 0)
{
break;
}

std::cout << "ERROR Cannot Generate Triangle with this base lenght.\n\nPossible causes:\n \n1. You did not input a valid integer. \n2. You inputed integer of too high value.(Max Value is: 2147483647)\n3.Entered Value Is '0' or Negative.\n";

}

std::cout << "Which type of triangle would you like to draw: \n";
std::cout << "1. Right triangle\n";
std::cout << "2. Isosceles triangle\n";
std::cout << "Your decision: ";

int triangle{};
std::cin >> triangle;

switch (triangle)
{
case 1:
{
for (int i{ 1 }; i <= inputAsInt; ++i)
{
std::cout << std::string(i, '*') << '\n';

}

break;
}

case 2:
{

for (int i{ 1 };i <= inputAsInt; i += 2)
{
std::cout << std::string((inputAsInt - i) / 2, ' ') << std::string(i, '*') << std::string((inputAsInt - i) / 2, ' ') << '\n';

}

if (inputAsInt % 2 == 0 )
std::cout << "\nTrinagle with desirad base lenght can not be created. The base was rounded to number: " << inputAsInt - 1 << '\n';

break;
}
default:
{
std::cout << "Invalid Selection. (You stupid or what?)";
}

}
}