DEV Community: Someone.

DEVLOG – How to Move Straight in a Line?

Someone. — Sun, 14 Dec 2025 00:36:07 +0000

Getting a small robot (SPIKE Prime, in my case) to move in a straight line is harder than it looks.

Thus, methods such as PID exist, but I didn't want to use such complicated (and not 100% understood) algorithms just because it's there (Notice that I did not do any research, this was all trail-and-error work).

Problem Statement

To cope with any problem, we first need to tailor it into a problem statement that is explicit and understandable, so here's ours: "How can I make a SPIKE Prime robot move X distance in a straight line, while pulling an external load?"

Center of Mass

It may seem obvious,"Just let it move 0 degrees!", you might say. However, the center of mass (the point at which the total mass of the object is concentrated) is not always in the center. In fact, only regular bodies have their center of mass coinciding with the geometric center; for all other objects, these points do not coincide.

Therefore, commanding the robot to move at angle 0, will let it tilt over time.

PROPOSAL #1: MOVE(0 - YAW)

My initial idea was to let the robot move (0 - yaw) degrees, That is, ensuring that whenever the robot detects any tilting (by it's internal gyroscope), it readjusts accordingly.

However, due to the robot programming limitations, I needed this function to run in a loop, and loops do not support "MOVE UNTIL X DISTANCE", so I had to find a way to move it with a time. Thus, I came up with this idea:

Start a timer (T)
Let the robot move X cm at 0 degrees.
Let speed = X ÷ T

This is the not on the required path, as the track have many tasks:
1 - Move to point A-B straight
2 - Move to point B-C with a load.

so, for task 1, the robot can move in a straight line due to the short distance and that there no external load. Thus, we can calculate the speed of the robot.

Then, for task 2, we need to run a loop for the MOVE(0 - YAW) method to work, and to get the required time the robot needs to run to go to X distance, we can do: time = d/v, which we already have d and v.

PROPOSAL #2: Displacement-based Movement

The first proposal introduced a way to move in a straight line, however, since the robot doesn't move in a linear movement, but in tilting (0 - yaw) movement, Time becomes obsolete, as the total distance will increase, time needed will also increase.

So, instead of relying on time, we track the actual straight-line displacement of the robot from its starting point. This means we care only about the distance “as the crow flies,” not the total path traveled, which may curve slightly due to tilting.

How it works:

Initialize a vector position (Rx, Ry) at (0, 0).
Every small time interval (tick):

Measure how far the robot moved since the last tick. This can be done via the wheel encoders.
Read the current yaw angle from the gyroscope.
Update the vector position along the direction of motion:

Rx = Rx + A × cos(yaw)

Ry = Ry + A × sin(yaw)

Here, A is the distance moved in this tick, computed from the wheel rotation (or, A = v × t).

Calculate the straight-line displacement: R = sqrt(Rx^2 + Ry^2)
Stop the robot when R ≥ X, where X is the desired straight-line distance.

While this is theoretically correct, it didn't work out due to the robot limitations! Well... I guess back to PID 😄.

Python Dunder Functions: What They Are and How to Use Them

Someone. — Sat, 11 Mar 2023 13:27:19 +0000

Dunder functions are special methods in Python that begin and end with a double underscore (e.g. init, str). They are also known as magic methods or special methods. In this post, we'll explore what dunder functions are, what they're used for, and how to use them in your Python code.

What Are Dunder Functions?

Dunder functions are pre-defined methods in Python that have special meanings. They are called "dunder" functions because their names begin and end with double underscores (i.e. "__"). These functions are also called magic methods because they allow Python classes to emulate built-in types and perform various operations, such as object initialization, comparison, and iteration.

Dunder functions are not called directly like regular methods. Instead, they are invoked implicitly by Python in response to certain events or operators. For example, the str method is called when you use the str() function on an object, or when you use the print() function to output the object.

How to Use Dunder Functions

To use a dunder function, you simply define it in your Python class. Here's an example of a class with a str method:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name}, {self.age} years old"

In this example, we define a Person class with an init method that initializes the name and age attributes, and a str method that returns a string representation of the object. To use this class, we can create instances of it and then print them:

p1 = Person("Alice", 25)
p2 = Person("Bob", 30)

print(p1) # Output: Alice, 25 years old
print(p2) # Output: Bob, 30 years old

When we print the Person objects, Python calls the str method implicitly to get their string representation.

Here are some other common dunder functions and their uses:

`__init__`: Initializes an object when it is created. This method is called immediately after an object is created and allows you to set the initial values for the object's attributes.

`__eq__`: Defines the behavior of the == operator. This method is called when you use the == operator to compare two objects of the same class.

`__lt__`: Defines the behavior of the < operator. This method is called when you use the < operator to compare two objects of the same class.

`__len__`: Returns the length of the object. This method is called when you use the len() function on an object.

`__repr__`: Returns a string representation of the object that can be used to recreate it. This method is called when you use the `repr()` function on an object.

You can define other dunder functions in your classes as well, depending on your needs. For example, you can define a add method to specify the behavior of the + operator for your class.

Benefits of Dunder Functions

Using dunder functions can make your code more concise and easier to read, as well as more powerful and flexible. By defining these special methods, you can make your classes behave like built-in types, and you can control how they respond to operators and events. This can make your code more intuitive and easier to use.

Conclusion

Dunder functions are a powerful feature of Python that allow you to customize.

Is Python a programming?

Someone. — Sat, 11 Mar 2023 13:21:06 +0000

Introduction

Hello , this article is indicated in it's title, even if the title is not clear, we will talk about "Why some people don't want to learn python".
In this article, we will discuss several pens, the most important of them:

What is python?
Is python that easy?
Is it really a language?
Conclusion

What is Python?

Python is a high-level, interpreted programming language that was created by Guido van Rossum and first released in 1991.
It has a design philosophy that emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than in languages such as C++ or Java.
Python has become one of the most popular programming languages in the world, used for web development, data analysis, artificial intelligence, and many other fields.

Is Python that easy?

Python is often touted as an easy language to learn, particularly for beginners. Its syntax is straightforward and readable, and its built-in libraries and frameworks make it simple to accomplish many common programming tasks.
However, like any programming language, Python still requires effort and practice to master.
It's not a magic bullet that will make programming easy for everyone, but it is an accessible language that can help people get started with coding.

Is it really a language?

Some people argue that Python is not a "real" programming language because it is interpreted rather than compiled. However, this is a misconception.
Python is a fully-featured programming language that can be used to create complex applications, just like any other language.
The fact that it is interpreted means that it can be slower than compiled languages in some cases, but it also has benefits such as being more flexible and easier to debug.

Conclusion

In conclusion, Python is a powerful and versatile programming language that has become hugely popular in recent years.
While it may not be the best choice for every situation, it is a language that is worth learning for anyone who wants to become a programmer or work in a field that requires coding skills.
Despite some misconceptions about its ease of use and status as a "real" language, Python has proven itself to be a valuable tool for developers around the world.