DEV Community: Muhammad Ikhwan Fathulloh

Professional Inverse Kinematics on Arduino: Deep Dive into NocKinematics

Muhammad Ikhwan Fathulloh — Tue, 21 Apr 2026 08:04:28 +0000

Building a robotic arm often starts with a simple challenge: "I want the claw to move to point (X, Y, Z)." However, translating a 3D coordinate into specific servo angles is a nightmare of trigonometry and matrix calculus.

While professional robotics often use the Jacobian Inverse or Cyclic Coordinate Descent (CCD), these methods are either too "heavy" for an Arduino or produce jerky, unnatural movements.

Today, we are exploring NocKinematics, a lightweight C++ library that brings the industry-standard FABRIK algorithm to the world of microcontrollers.

🔬 The Science: Why FABRIK?

NocKinematics is built upon the foundational research of Andreas Aristidou and Joan Lasenby. If you are looking for the academic rigor behind this library, you should refer to the original paper:

> Aristidou, A., & Lasenby, J. (2011). "FABRIK: A fast, iterative solver for the Inverse Kinematics problem." Graphical Models, 73(5), 243-260.

Why this matters for Embedded Systems:

Unlike traditional methods that rely on expensive trigonometric functions or matrix inversions, FABRIK (Forward And Backward Reaching Inverse Kinematics) uses an iterative approach based on finding points on a line.

Low Computational Cost: Perfect for 8-bit AVR (Arduino Uno) and 32-bit ESP32 alike.
Fast Convergence: It usually finds a solution in just a few iterations.
Handle Constraints: It gracefully handles "unreachable" targets by stretching the arm to its maximum toward the point.

🛠️ Key Features of NocKinematics

Developed by Muhammad Ikhwan Fathulloh and the Nocturnailed Community, this library bridges the gap between game engine math and hardware.

N-Joint Support: Solve kinematics for 2, 3, or even 20+ joints (ideal for snake robots or tentacles).
Memory Optimized: It avoids std::vector to prevent heap fragmentation. It allocates memory exactly once during initialization.
Platform Agnostic: Runs on Arduino Uno, Nano, Mega, ESP8266, and ESP32.

🚀 Step-by-Step Implementation

1. Define Your Robot's Anatomy

Think of your robot as a collection of "joints" connected by "bones." If you have 4 joints, you have 3 bones.

#include <NocKinematics.h>

const int NUM_JOINTS = 4;
// Length of each bone segment in your chosen unit (cm, mm, etc.)
float boneLengths[NUM_JOINTS - 1] = { 10.0, 8.0, 5.0 }; 

// Initialize the solver on the Heap
NocKinematics::FABRIK* armSolver = new NocKinematics::FABRIK(boneLengths, NUM_JOINTS);

2. Set the Anchor

The "Base" is the stationary part of your robot (e.g., the shoulder).

armSolver->setBasePosition(NocCore::Vector3(0, 0, 0));

3. Reach the Target

Instruct the arm to calculate the positions needed to touch a point in space.

NocCore::Vector3 target(12.0, 5.0, 3.0);
bool success = armSolver->solve(target);

4. Mapping to Hardware (Servos)

The library gives you Vector3 coordinates for each joint. To move a real servo, you simply use atan2 to find the angle between these points.

for (int i = 0; i < NUM_JOINTS; i++) {
    NocCore::Vector3 pos = armSolver->getJointPosition(i);
    Serial.print("Joint "); Serial.print(i);
    Serial.print(": "); Serial.print(pos.x_val);
    Serial.print(", "); Serial.println(pos.y_val);
}

📂 Real-World Examples Included

The library ships with several built-in examples (File > Examples > NocKinematics):

BasicArm.ino: The "Hello World" of kinematics.
DynamicTarget.ino: Watch the arm follow a moving coordinate in real-time.
MultiJointSnake.ino: A stress test showing 10+ joints moving smoothly on an Arduino.
ServoArm4DOF/5DOF: The most practical scripts. They show how to translate $X, Y, Z$ math into actual servo.write(angles) commands.

📦 Installation

Get started today by downloading the library through your preferred channel:

Arduino Library Manager: Search for NocKinematics.
GitHub: Nocturnailed-Community/NocKinematics
Documentation: Arduino Libraries Info

Conclusion

Inverse Kinematics doesn't have to be a "math wall" that stops your project. With NocKinematics, you can focus on building the hardware and the behavior, while the FABRIK algorithm handles the heavy lifting of spatial geometry.

License: Released under the MIT License.
Maintained by: Nocturnailed Community.

#Robotics #Arduino #InverseKinematics #FABRIK #ESP32 #OpenSource #NocLab #Mathematics

Bringing Generative AI to Microcontrollers: Introducing NocLLM

Muhammad Ikhwan Fathulloh — Tue, 21 Apr 2026 05:30:05 +0000

The barrier between resource-constrained hardware and Large Language Models (LLMs) has finally been broken. While microcontrollers lack the VRAM to run a 70B parameter model locally, they can now act as intelligent gateways to the world's most powerful AI engines.

Enter NocLLM, an optimized integration and inference library designed specifically for Arduino and embedded systems.

What is NocLLM?

NocLLM is a high-performance C++ library that allows microcontrollers to communicate with LLM providers (OpenAI, Gemini, Groq, DeepSeek) or local LLM servers (Ollama, LMStudio) using a non-blocking, stream-oriented architecture.

Unlike traditional HTTP clients that hang while waiting for a full JSON response, NocLLM parses incoming data chunks in real-time. This means your Arduino can keep reading sensors or driving motors while the AI is "typing" its response.

Core Strengths:

Zero-Overhead Streaming: Uses background TCP polling to prevent CPU stalls.
Multi-Provider Support: One unified syntax for various AI infrastructures.
Smart Parsing: Automatically adapts its internal configuration based on the target URL (e.g., switching between Gemini and OpenAI protocols).
Edge-First Design: Optimized for memory efficiency, preventing "Out of Memory" crashes during long AI conversations.

5 Ways to Power Your Hardware with LLMs

NocLLM ships with five comprehensive examples (found in File -> Examples -> NocLLM) to get you started:

01_Sumopod: DeepSeek-V3 integration via Sumopod Cloud.
02_OpenAI: The industry standard—perfect for GPT-4o or GPT-3.5 Turbo.
03_Gemini_Native: Harness Google’s gemini-3-flash. NocLLM handles the specific Google GenAI headers and parsing logic automatically.
04_Groq: Experience ultra-low latency with llama3-70b. Ideal for voice assistants or real-time robotics.
05_Local_LMStudio: The privacy-focused choice. Connect to Ollama or LMStudio on your local network. It uses bare TCP streams with 0 SSL overhead, providing blazing-fast speeds for local AI setups.

Technical Spotlight: Non-Blocking Execution

The most powerful feature of NocLLM is its ability to multitask. Here is how simple it is to implement a streaming AI response without freezing your microcontroller:

#include "NocLLM.h"

// Initialize with your Key, Endpoint, and Model
NocAI ai("YOUR_API_KEY", "https://api.openai.com/v1", "gpt-3.5-turbo");

// Callback function triggered as each word/chunk arrives
void onStream(String chunk) {
    Serial.print(chunk);
}

void setup() {
    Serial.begin(115200);
    // ... [Insert your WiFi connection logic here] ...

    // Attach the listener and trigger a prompt
    ai.onMessage(onStream);
    ai.beginStream("Write a 1-sentence poem about a robot."); 
}

void loop() {
    // This gently pulls the data from the network in the background
    ai.loop();

    // Your main logic stays alive!
    // Example: Blink an LED or read a DHT22 sensor here.
}

Why Use NocLLM for Your Next Project?

Interactive Robotics: Give your robot a "brain" that can understand complex natural language commands.
Smart Home Hubs: Build a private voice assistant that processes logic via a local Ollama server.
Intelligent Data Analysis: Send sensor logs to an LLM to receive a human-readable summary of system health.

Installation & Resources

Ready to build the next generation of smart hardware?

Arduino Library Manager: Search for "NocLLM" and click install.
GitHub Repository: Nocturnailed-Community/NocLLM
Registry Details: NocLLM on Arduino Libraries

NocLLM is part of the Noc Lab ecosystem, dedicated to pushing the boundaries of what is possible on the edge.

#Arduino #LLM #GenerativeAI #IoT #EdgeAI #NocLab #OpenSource #Programming

Bringing Intelligence to the Edge: Introduction to NocML for Arduino

Muhammad Ikhwan Fathulloh — Tue, 21 Apr 2026 05:22:10 +0000

Edge AI is often seen as a field reserved for powerful single-board computers, but what if you could run machine learning logic directly on a standard Arduino?

In this article, we will explore NocML, an efficient machine learning library specifically designed for resource-constrained microcontrollers.

What is NocML?

NocML is a lightweight C++ library built to bridge the gap between complex ML logic and the limited processing power of microcontrollers like the ESP32, Arduino Uno, or Nano. Inspired by the Scikit-Learn API, it offers a familiar workflow for developers coming from a Python background.

Key Features:

Low Memory Footprint: Optimized to run within the tight SRAM limits of common microcontrollers.
Data Preprocessing: Includes tools like MinMaxScaler for data normalization on-device.
Versatile Algorithms: Supports Classification (KNN, Naive Bayes), Clustering (K-Means), and Regression (Linear Regression).
Zero Latency: Perform inference locally on the device, ensuring privacy and real-time response without cloud dependency.

Use Case: K-Nearest Neighbors (KNN) Classification

One of the strongest features of NocML is its ability to perform sensor classification directly on the "edge." Imagine building a device that classifies activity types based on accelerometer data.

Here is a practical example of how to implement a KNN algorithm using NocML:

#include <NocML.h>

// Define training data (Features)
float X_train = {
  {1.0, 2.0}, // Category A
  {1.5, 1.8}, // Category A
  {5.0, 8.0}, // Category B
  {6.0, 7.0}  // Category B
};

// Labels for training data
int y_train = {0, 0, 1, 1};

// Initialize KNN with k=3
KNN knn(3);

void setup() {
  Serial.begin(115200);

  // Local training (Fit)
  knn.fit((float*)X_train, y_train, 4, 2);
  Serial.println("KNN Model Ready!");
}

void loop() {
  // New sensor data to classify
  float input = {1.2, 2.1};

  // Perform prediction
  int prediction = knn.predict(input);

  Serial.print("Classification Result: ");
  Serial.println(prediction == 0 ? "Category A" : "Category B");

  delay(2000);
}

Why NocML?

Smart IoT: Transform passive sensors into intelligent nodes that make decisions without a server.
Predictive Maintenance: Detect anomalous vibration patterns in industrial motors before failure occurs.
Human-Machine Interaction: Recognize gestures or simple audio patterns in real-time.

Getting Started

You can easily integrate NocML into your project via the Arduino Library Manager or by visiting the official repositories.

Installation

Open your Arduino IDE.
Go to Sketch -> Include Library -> Manage Libraries...
Search for "NocML" and click install.

Alternatively, explore the source code and documentation:

GitHub Repository: Nocturnailed-Community/NocML
Arduino Library Registry: NocML on Arduino Libraries

Conclusion

NocML is part of the TinyML movement, making artificial intelligence accessible on devices costing only a few dollars. By bringing logic closer to the data source, we create faster, more reliable, and smarter IoT systems.

Are you working on an Edge AI project? Give NocML a try and share your results!

#Arduino #MachineLearning #TinyML #IoT #OpenSource #NocLab #ArtificialIntelligence