ANTSHIV ROBOTICS

Introduction to Heterogeneous Computing in Embedded Systems

Most embedded developers start with single-core microcontrollers - Arduino, STM32, ESP32. One processor handles everything: sensors, processing, communication, UI.

But modern applications need more. That's where heterogeneous computing comes in.

Instead of one generalist processor, you use multiple specialized cores:
- App core for main logic
- Network core for wireless protocols
- DSP core for signal processing
- AI accelerators for machine learning

Three main approaches:
- Wireless-first - Nordic nRF5340 (dual ARM M33)
- Real-time + performance - NXP i.MX RT1170 (M7 + M4)
- AI at edge - TI TDA4VM (A72 + R5F + DSP + GPU)

Benefits: True parallel processing, better power efficiency, optimized performance per core.

Challenges: More complex development, inter-core communication, debugging multiple cores simultaneously.

If you're building IoT devices, industrial controls, or anything with AI/vision, understanding heterogeneous computing is becoming essential.

Planning a deep-dive video series on this topic. Which approach interests you most for your projects?

#EmbeddedSystems #Microcontrollers #ARM #IoT #EdgeAI

Skip the Carousel

1 2 3 4 5

6 months ago (edited) | [YT] | 8

ANTSHIV ROBOTICS

We reached—4000 subscribers! When I started this channel, it was just a fun way to share my tinkering hobbies and projects. And it still is. I never imagined that people around the world would actually be interested in watching my videos.

Thank you for watching and supporting this channel. I'm grateful to each of you.

I'll continue sharing my projects with you. Thanks for making this hobby more meaningful.

8 months ago (edited) | [YT] | 1

ANTSHIV ROBOTICS

**Eigenvalues and eigenvectors**
are straightforward concepts in linear algebra that help us understand how certain transformations work. A matrix can represent a transformation, such as rotation, stretching, or scaling. When we apply that matrix to a vector, we get a new vector. If the direction of that vector doesn’t change, then it is an **eigenvector**, and the factor by which it is stretched or shrunk is the **eigenvalue**. This means we can analyze how systems evolve just by looking at a few special vectors and their corresponding scalars. It’s a simple way to uncover hidden patterns in a complex transformation. ✨

When it comes to state estimation, eigenvalues and eigenvectors play a major role. For instance, in a Kalman filter, we deal with predictions and measurements of a system’s state. We often talk about the covariance matrix, which tells us how uncertain our estimates are. The eigenvalues of that covariance matrix indicate how large or small the uncertainty is in certain directions, while the eigenvectors show which directions in the state space are most affected. When these eigenvalues get too large, it tells us we need to refine our measurements or improve our model. This keeps our state estimates reliable and precise. 🤔

Drones, also known as unmanned aerial vehicles (UAVs), rely heavily on these principles. A drone’s **flight controller** uses sensors like gyroscopes, accelerometers, and GPS to figure out where it is and how it’s moving. These measurements feed into an algorithm—often a Kalman filter—which tracks the drone’s position, velocity, and orientation. By examining the eigenvalues of the system model, we can understand whether the drone’s state is stable over time. If an eigenvalue is bigger than 1, small errors might grow quickly, leading to instability. If it’s between 0 and 1, errors shrink and the system remains stable. This is crucial for safe and predictable flight. 🚁

In practice, working with eigenvalues and eigenvectors helps engineers diagnose and design better control strategies. For example, if a certain vibration mode in the drone is problematic, you might find an eigenvalue that corresponds to that vibration. Reducing that eigenvalue or shifting it away from the flight range helps stabilize the drone. Thus, these concepts become essential for fine-tuning how a drone behaves in the air. They’re not just theoretical constructs; they’re practical tools for real-world issues like controlling oscillations, managing sensor noise, and maintaining steady flight. ⚙️

Keeping a drone stable, especially in windy conditions or during rapid maneuvers, depends on how well we can predict its behavior. Eigenvalues guide us by showing which states are most likely to grow or diminish. Eigenvectors guide us by showing which directions in state space are most sensitive. By combining these insights with sensor data in a **Kalman filter**, we create a robust system that responds accurately to changes, ensuring smoother flights and better reliability. 🚀

In short, eigenvalues and eigenvectors let us look inside the transformations happening within our systems. They help decode the patterns that define how states evolve, making them invaluable in Kalman filtering and drone control. Whether you’re optimizing flight stability, reducing uncertainty, or diagnosing oscillations, these mathematical tools act like a spotlight, revealing critical dynamics in a straightforward way.

#Eigenvalues #Eigenvectors #KalmanFilter #Drones #StateEstimation #Engineering #Robotics #UAV #LinearAlgebra #ControlSystems

Skip the Carousel

1 2 3 4 5

10 months ago | [YT] | 10

ANTSHIV ROBOTICS

🚀 What is a Linear System? Let’s Break It Down! 🤔

If you’ve ever wondered what makes a system “linear” and why it matters, this one’s for you! Let’s keep it simple and clear. 🧩

1. What is a Linear System?
A system is linear if it follows two rules:
- Superposition: If input u1​ gives output y1​ and input u2​ gives output y2y, then input u1+u2​ gives output y1+y2​.
- Scaling: If input u gives output y, then input a⋅u gives output a⋅y.
In simple terms: Double the input, double the output. Add two inputs, get the sum of their outputs. 🔄

2. Examples of Linear Functions
Here are some common linear functions:
- Algebraic: y=2x+3 (a straight line).
- Differential Equations: x˙=Ax+Bu (state-space model).
- Matrix Operations: y=Ax (linear transformation).
- Amplitude Scaling: f(a)=a⋅sin(ωt) (linear in aa).
These are all linear because they follow the superposition and scaling rules. 📈

3. What Makes a Function Nonlinear?
A function is nonlinear if it breaks the rules of superposition and scaling. Examples:
y=x^2: Double x, and y quadruples (not linear).
y=sin⁡(x): Doesn’t scale or add linearly.
y=a⋅sin⁡(ωt): Linear in a, but nonlinear in t.
Nonlinear systems are trickier to analyze but often model real-world behavior better. 🌍

4. Why Linear Systems Matter in Control
Linear systems are easier to analyze and design controllers for. Tools like transfer functions, state-space models, and frequency response rely on linearity.
For example:
- A motor’s speed response to voltage input can often be modeled linearly for small changes.
- Linear systems are predictable and proportional, making them ideal for control applications. 🎛️

5. Linearization in Control Systems
Many real-world systems are nonlinear but can be linearized for analysis. Linearization approximates a nonlinear system as linear near a specific operating point.
Example:
- A pendulum’s dynamics are nonlinear but can be linearized for small angles (sin⁡(θ)≈θsin(θ)≈θ).
- This simplifies controller design and stability analysis.

Key Takeaways
- Linear systems follow superposition and scaling.
- Nonlinear systems break these rules and are harder to analyze.
- Linearization approximates nonlinear systems as linear for simplicity.

Whether you’re designing a controller or analyzing a system, understanding linearity is key! 🔑

#ControlSystems #LinearSystems #EngineeringExplained #STEM #MathIsFun #LearnWithMe #ControlTheory #NonlinearSystems #Linearization #EngineeringLife

Skip the Carousel

1 2 3 4 5

10 months ago | [YT] | 11

ANTSHIV ROBOTICS

Why is Attitude Estimation Nonlinear? 🤔

Attitude estimation—figuring out a drone or object’s orientation—is trickier than it sounds. Here’s why it’s nonlinear and how we handle it. 🚀

🧮 Math Behind Nonlinearity
- Trigonometry Everywhere: Attitude calculations rely on sine, cosine, and arctangent functions, which aren’t linear.
- Rotational Systems: Representing orientation using quaternions, Direction Cosine Matrices (DCMs), or Euler angles adds complexity. These methods involve constraints like maintaining unit norms or orthogonality.
- Cyclic Nature: Angles “wrap around,” meaning 360∘360^\circ equals 0∘0^\circ. That’s tricky to model directly.

📝 Takeaway: The math itself is nonlinear. Simplifying it often requires approximations.

🌐 Coupled Dynamics
- What Happens?: Rotating around one axis can influence the others due to how 3D rotations interact. For example, yaw rotation can affect pitch and roll.
- Nonlinear Effects: The equations that describe these interactions usually involve matrices or trigonometric functions.

🔄 Can It Be Linear?: For small changes, these dynamics can sometimes be approximated as linear. But for larger rotations, the nonlinear effects dominate.

📡 Measurement Noise
- Sensor Data: Instruments like gyroscopes and accelerometers come with noise (random errors in readings).
- Nonlinear Behavior: Combining noisy sensor data into orientation estimates involves equations with trigonometric operations. Noise magnifies the nonlinearity.

🔍 Simplified Case?: If noise is small or the equations are approximated, the behavior can look linear, but it’s still an approximation.

🛠️ How Do We Handle This?
- Linearization: Algorithms like the Extended Kalman Filter (EKF) linearize the problem by using a Jacobian matrix, which captures the local linear behavior.
- Sigma Points: The Unscented Kalman Filter (UKF) uses smart sampling (sigma points) to approximate nonlinear effects without derivatives.
- Why Linearize?: Linearizing the problem makes it computationally efficient and practical for real-time applications like drones.

💡 Alternatives? Fully nonlinear methods, like particle filters, can work, but they’re computationally expensive and harder to use in real-time.

🌟 Key Nonlinear Properties
- Cyclic Angles: Orientation wraps around (e.g., 360∘360^\circ = 0∘0^\circ).
- Non-Euclidean Geometry: Rotational math doesn’t follow simple Euclidean rules.
- Coupled Motion: Rotations aren’t independent and influence each other.
- Noise Interactions: Sensor noise complicates calculations in nonlinear ways.

🚁 Why This Matters
Understanding these nonlinearities helps build better algorithms to estimate attitude, whether for drones, robots, or any dynamic system.

📌 #AttitudeEstimation #ControlSystems #DroneTech #NonlinearDynamics #EngineeringSimplified #EKF #UKF
Final Thought 🤓

Attitude estimation is challenging but manageable with the right techniques. Linearization is a key trick for simplifying nonlinear systems and making them real-time ready. It’s not perfect but gets the job done!

Skip the Carousel

1 2 3 4 5

10 months ago | [YT] | 16

ANTSHIV ROBOTICS

Building a reliable flight controller architecture is all about creating solid, well‐organized layers that work together seamlessly. We start at the very bottom with sensor interfaces—collecting raw data from accelerometers, gyroscopes, magnetometers, GPS, barometers, and anything else we might need for stable flight. Then comes the state estimation level. This is where we turn that messy, noisy sensor stream into meaningful information about our drone’s orientation, velocity, and position. ✈️

Our focus right now is on **attitude math** and a **robust state estimation library**. Attitude math deals with quaternions, Euler angles, or rotation matrices—whichever is best for converting raw IMU data into a stable reference for how the drone is oriented in three‐dimensional space. Meanwhile, the state estimation library fuses those sensor readings together and corrects for noise and drift. Think of these two as the foundation: get orientation and state estimation right, and you set the stage for smooth, predictable flight. #FlightControl #DroneTech

Next, we’ll tackle the **control system library**. Typically, that means setting up PID loops, which are great for making quick, straightforward corrections. Of course, there are more sophisticated options like adaptive, robust, or model predictive controllers, but for many applications, a good PID gets the job done. Right after that, we plan to create a **dynamic model library**—this will help us simulate how the drone behaves in various real‐world conditions. It’s especially handy when you’re prototyping new features or just wanting to see how your craft might handle challenging scenarios. #ControlLoop #PID #Engineering

Once we have the dynamic model and control library in place, we’ll be ready to develop a **full‐featured INS (Inertial Navigation System)**. INS takes state estimation a step further by integrating velocity and acceleration over time to figure out precise positions. Since it relies heavily on real‐time corrections from the PID loops and accurate dynamic modeling, there’s a clear dependency chain: get your controls nailed down, then build your INS on top of that. The end result should be a flight controller that can not only hover with confidence but also navigate complex paths with minimum drift. #INS #Autonomy

A big part of making all this work is good software design. We want our flight controller to be modular, which means each library can be swapped out or upgraded without messing up the whole system. We’re using a layered approach: low‐level firmware drivers (for reading sensors and sending commands to motors), then our core libraries (attitude, state estimation, control, dynamics, etc.), and finally high‐level logic (mission planning, obstacle avoidance, that sort of thing). This structure ensures that when new sensors or advanced algorithms come along, we can drop them into the existing framework with minimal fuss. #ModularDesign #OpenArchitecture

Ultimately, a properly built flight controller lays the groundwork for advanced features like autonomous navigation, swarming, and machine learning. Our community thrives on experimentation, so having strong building blocks that can grow with new ideas is essential. We’re excited about pushing this project forward—so far, we’ve achieved a more robust state estimation than we initially expected, and we can’t wait to share updates on the control system, dynamic model library, and, eventually, the INS. Stay tuned for more progress and, as always, feel free to chime in with questions or suggestions. Let’s keep taking flight together! 🚀 #DroneDevelopment #DIYDrones #Innovation

Skip the Carousel

1 2 3 4 5

10 months ago | [YT] | 10

ANTSHIV ROBOTICS

Understanding Quaternions: Why They Matter for Drone Navigation


Attitude Math Library Github Link: github.com/antshiv/attitudeMathLibrary
State Estimation Github ink: github.com/antshiv/stateEstimation

Quaternions are a compact, four-component way of representing 3D orientation without the pitfalls you might encounter using Euler angles. If you’ve ever battled gimbal lock, you’ll understand why drones need a method that stays consistent through the full range of motion. Instead of worrying about rotations around separate axes, quaternions let you handle them all in one go, which keeps your control loops running smoothly. ✨

One of the most practical benefits of quaternions is how they seamlessly combine orientation data. For drones, this matters a lot because you typically have multiple sensors—gyroscopes, accelerometers, and magnetometers—all providing rotation or heading info. Using quaternions, you can fuse this data without running into messy trigonometry or weird angle wrapping. That translates to more accurate state estimation and better overall flight stability. ⚙️

It’s worth noting that quaternions stay pretty lean, but they do come with a learning curve. You’ve got four terms—(w,x,y,z)—and you need to keep them normalized (i.e., length equals 1). When you multiply two quaternions, the result is another rotation. That’s actually how we keep track of incremental changes from the gyroscopes. If you skip normalization, though, you might notice drift or irregular rotations creeping in.

In my own work, I built an Attitude Math Library to handle the key operations for quaternions, plus Direction Cosine Matrices (DCMs) and Euler angles. I started from the ground up because I wanted a single place where you could quickly convert between representations, normalize as needed, and handle rotation interpolation. You can check it out on GitHub at Attitude Math Library. 🛠️ github.com/antshiv/attitudeMathLibrary


If you’re wondering how to actually plug this into your flight control or navigation stack, that’s where sensor fusion comes in. I’ve got another repository called State Estimation. This library uses sensor readings (like accelerometer, gyroscope, magnetometer, and other sensors) to figure out the drone’s position and orientation in real time. The quaternion math from my Attitude Math Library fits perfectly here, ensuring smooth orientation updates while minimizing drift.

I find the biggest advantage of quaternions in drone applications is the ability to handle rapid orientation changes without skipping a beat. Drones can pitch, roll, and yaw at high rates—especially if you’re doing flips or aggressive maneuvers. Quaternions let you account for all those rotations without losing track of which way is “up.” When you rely on a stable sense of orientation, your drone’s PID loops (or any other control approach) can adjust the motors quickly and accurately. 🚁

Finally, let’s keep it real—nothing replaces careful testing. Whether you’re writing your own quaternion functions or using my libraries, it’s wise to validate the outputs. Compare the calculated attitudes with real-world drone behavior. If they match, you’re on the right track. If not, double-check normalization, sensor calibration, and timing.

That’s the big picture on why quaternions matter. They’re mathematically robust, keep drone orientation data reliable, and integrate well with sensor fusion frameworks. If you’re curious to try them out, feel free to explore my libraries and see how they fit into your own projects. 🚀

#QuaternionMath #DroneNavigation #AttitudeMath #SensorFusion

Skip the Carousel

1 2 3 4 5

10 months ago | [YT] | 13

ANTSHIV ROBOTICS

Sigma points are special sample points. They approximate a probability distribution without random sampling. Each point represents a distinct offset around the mean. This layout reflects the system’s covariance structure. We use them in the Unscented Transform for non-linear problems. #SigmaPoints #UnscentedTransform 🤔

Traditional linearization relies on Jacobians. That can skip higher-order effects. Sigma points avoid that by sampling directions around the mean. No derivatives are required. #NoDerivatives #NonlinearSystems 🤖

We generate these points using the mean and covariance. First, we compute a matrix square root of the covariance. Then, we place points at fixed intervals around the mean. This arrangement reflects potential variations in the state. #Mean #Covariance 🧩

After we pass these points through a non-linear function, we recalculate the new mean and covariance. This captures important curvature information. We skip the need for complex expansions. #NonlinearFunction #Curvature 🚀

Sigma points also help reduce computational cost. They are fewer in number than Monte Carlo samples. Yet they provide strong coverage of the distribution. This leads to more efficient uncertainty propagation. #Efficiency #Uncertainty 😎

We often see sigma points in Kalman filtering. The Unscented Kalman Filter (UKF) depends on them. It applies these points to handle non-linear sensor models. This helps track states in robotics and navigation. #UKF #Robotics 🤖

In finance, sigma points can model complex price movements. They capture random shocks in market data. This improves accuracy in forecasting and risk analysis. #Finance #RiskManagement 💹

Generating sigma points is deterministic. We rely on known formulas for the spread. This sets them apart from Monte Carlo randomness. #Deterministic #MonteCarlo 🎲

Each point has weights for the mean and covariance. These weights sum in a balanced way. This ensures consistent estimates after transformation. #Weights #Estimation ⚖️

Implementation steps are simple. First, pick a scale parameter. Then, compute the square root of the covariance. Place points around the mean accordingly. Pass them through your function. Recompute mean and covariance from outputs. #Implementation #ScaleParameter 🧩

This method avoids heavy derivative calculations. It suits functions without easy analytic derivatives. #DerivativeFree #ComplexModels 🔧

Sigma points are more accurate than a simple linear approximation. They capture curvature by design. This helps in highly non-linear scenarios. #Accuracy #Curvature 🙂

They are not a magic fix for all problems. But they offer a balance between complexity and performance. #Balance #Performance ⚖️

They scale as the state dimension grows. More dimensions mean more points. This can raise computational costs. #Scaling #Dimensions 📈

Many advanced filters rely on sigma points. These filters include the UKF and other variants. They support stable tracking under uncertainty. #AdvancedFilters #UKF 🚀

Robotics, aerospace, and finance all benefit from them. They help unify sensor data and reduce noise. #Robotics #Aerospace #Finance

The unscented transform is a core part of this. It calculates how sigma points move through the function. Then it aggregates the results for an updated estimate. #UnscentedTransform #Aggregation 📊

Overall, sigma points are a practical tool. They handle non-linearity with fewer assumptions. Implementation is direct and derivative-free. #Practical #NonlinearSolution 🏁

Use them if you need robust, efficient estimation. They work well when linearization falls short. #RobustEstimation #GoSigmaPoints ✅

Skip the Carousel

1 2 3 4 5

11 months ago | [YT] | 12

ANTSHIV ROBOTICS

Understanding the Jacobian Matrix: Why It Matters and How It’s Used 🚀

The Jacobian matrix is a mathematical tool widely used in engineering, robotics, and control systems. It helps us analyze how changes in inputs affect outputs, which is crucial for complex systems. Let’s explore what it is, how it connects to backpropagation, and why it’s essential in applications like the Extended Kalman Filter (EKF).
What is the Jacobian Matrix? 🧮

- The Jacobian matrix represents partial derivatives of a vector function with respect to its inputs.
- It captures how small changes in inputs affect outputs in multi-dimensional systems.
- Think of it as a sensitivity map that shows how one variable impacts another across the system.
- In simpler terms, it generalizes derivatives for systems with multiple inputs and outputs.

How is it Similar to and Different from Backpropagation? 🤔

The Jacobian matrix and backpropagation share common ideas but serve different purposes:

Similar Concepts:
- Both involve derivatives to measure how inputs affect outputs.
- The Jacobian and backpropagation rely on understanding how parameters influence a system.
- In backpropagation, gradients tell us how to adjust weights; in the Jacobian, they explain system sensitivity.

Key Differences:
Jacobian Matrix: Used to approximate linear changes in a system or analyze behavior in physical models.
Backpropagation: Optimizes cost functions in neural networks by updating parameters to reduce error.

While the Jacobian focuses on system analysis, backpropagation is all about improving performance in AI models.
Why Does the EKF Need the Jacobian? 🔍

The Extended Kalman Filter (EKF) is used in nonlinear systems like robotics or drones, where relationships between variables are complex. The Jacobian plays a vital role by:

- Linearizing the system around the current state estimate.
- Predicting how small changes in the state affect measurements.
- Allowing the EKF to work effectively in real-world scenarios by simplifying nonlinear behaviors.

Without the Jacobian, the EKF wouldn’t be able to handle the complexity of these systems.
Where is the Jacobian Used in Engineering? ⚙️

Jacobian matrices are used in a wide range of applications where sensitivity analysis or linearization is needed:

- Robotics: For motion planning, navigation, and sensor fusion (e.g., IMU + camera).
- Aerospace: Aircraft control systems and trajectory optimization.
- Autonomous Vehicles: Real-time localization and path planning.
- Healthcare: Parameter estimation in imaging systems like MRI or CT.
- Control Systems: Stability analysis in feedback loops for complex systems.

Practical Similarities to Backpropagation 🌐

- Both concepts help us understand how small changes propagate through a system.
- Backpropagation focuses on error correction by adjusting weights in a neural network.
- The Jacobian shows sensitivity in physical or nonlinear systems by mapping relationships between inputs and outputs.
- While their applications differ, both provide insights into how parameters influence a system or model.

Key Takeaways 📌

The Jacobian matrix is a critical tool for analyzing and simplifying complex systems, and its concepts closely relate to backpropagation in neural networks. Both techniques focus on understanding relationships between variables, making them essential in their respective fields. Whether you’re working with robots, aircraft, or AI, the Jacobian helps bring clarity to how systems behave.

Skip the Carousel

1 2 3 4 5

11 months ago | [YT] | 15

ANTSHIV ROBOTICS

🚀 C-StateEstimation: Altitude Module Release

github repo link: github.com/antshiv/stateEstimation
alittude page: github.com/antshiv/stateEstimation/blob/main/src/e…

Just added an altitude estimation module to my state estimation library! This C-based implementation now fuses data from multiple sensors (IMU, barometer, and Time of Flight) to provide accurate altitude tracking for drones and robotic systems. #RoboticsEngineering #DroneNavigation #CProgramming

The altitude module uses a 5-state Kalman filter to track altitude, vertical velocity, vertical acceleration, and sensor biases. It handles real-world challenges like sensor dropouts and noise - crucial for actual flight conditions. I've implemented bias estimation for both the barometer and accelerometer to improve long-term stability. 📊 #KalmanFilter #SensorFusion

One of the key features is how it combines different sensor strengths: accelerometer for quick dynamics, barometer for absolute reference, and ToF for precise close-range measurements. The module runs at 100Hz and includes temperature compensation for the barometer - essential for real-world applications. ⚡ #RealTime #Sensors

What sets this implementation apart is its focus on robustness and simplicity. The API is straightforward, making it easy to integrate into existing systems. I've included detailed configuration options for tuning the Kalman filter parameters, process noise, and measurement characteristics. 🛠️ #SoftwareEngineering #Embedded

Testing was a major focus - developed a comprehensive test suite that verifies stability, step response, sensor failure handling, and noise rejection. The tests provide detailed metrics and pass/fail criteria, making it easy to validate performance across different conditions. 🧪 #Testing #QualityAssurance

For those interested in the technical details, the library uses minimal dependencies and is platform-independent. The code is well-documented, and I've included example configurations for common use cases. You can find it alongside the existing attitude estimation module in the C-StateEstimation repository. 💻 #OpenSource #EmbeddedSystems

Future plans include integrating this with the attitude estimation module for full state estimation and adding advanced features like adaptive filtering. Currently working on improving the temperature compensation model and adding more sensor fusion options. 🔄 #Development #Innovation

The module maintains consistent coding standards with the rest of the library and focuses on computational efficiency - crucial for embedded systems. Error handling is robust, with clear status reporting and graceful degradation during sensor failures. 🎯 #CodeQuality #Reliability

Check out the documentation for implementation details and example usage. Happy to receive feedback and contributions from the community! #OpenSource #Robotics #ControlSystems 🤖

---
#CLibrary #StateEstimation #DroneControl #Robotics #EmbeddedSystems #SensorFusion #KalmanFilter #RealTime #Engineering #Programming #IMU #Sensors #Navigation #ControlTheory #AltitudeEstimation

Skip the Carousel

1 2 3 4 5

11 months ago | [YT] | 9