Progress Devlog 1:

I now modified main.py in my workspace folder ~/touch-grass(Yes I am a Linux User >_<). I included this block specifically:

    def start_breathing_blackout(self):    
            self.canvas.configure(bg="#000000")        
            self.canvas.delete("all")        
            self.blackout = True        
            self.locked_until = time.time() + FIVE_MINUTES_SEC        
            self.breath_label = self.canvas.create_text(            
                   self.width // 2, self.height // 2 - 140,            
                   text="Inhale...", font=("Helvetica", 22), fill="#89b4fa"        
            )        
            self.timer_text = self.canvas.create

Apparently this text telling the user “Inhale” and “Exhale” initiates like a part in their brain which make s them realize that they’re doomscrolling and they should stop. I don’t really think it will work, but I am adding it anyways.

My Next Goals:

Create the Wizard Installer for easier access and user permissions
Create my Git Repo and writing a ReadMe that doesnt suck(Thnx to Stardance Docs: They have a really good article on how to make a README that’s actually good)
Testing :)

Hopefully this internet meme based Doomscroll Breaker(DB) actually works, and it does good in Ratings!

So first day on Touch Grass SIM for frictionless. It is basically a thing for computer programmers, gamers, and doomscrollers to finally breath in fresh air and touch grass. It starts as digital, reducing blue light and slowly reducing and breaking bad habits to rebuild better ones instead.

Today I added my files, with a python file for my Installer Wizard, and a .html file for use on android and IOS. I also nw have a README.md which is completely empty, but I’m going to work on that.

Progress Devlog 2 - Phoenix 1:

So basically, YOLO didn’t really work out, so I had to delete it because I didn’t have enough RAM on my Raspberry Pi. Instead, I got ROS 2(Specifically ROS 2 Jazzy, an older version released for Ubuntu 24.04.02). For my original version of main.py, which is a system that launches 4 separate files(Ultrasonics and Motors, both arduino and python). Now using ROS 2 I built a separate mapping system called Rviz2, which is a very versatile mapping system that can spawn things like walls and stuff, and its pretty cool. But then I had to create a bunch of new files, like “phoenix_config.rviz” and I needed to create a new launching system called ./launch.sh, which booted the necessary rviz terminal commands and my main.py simultaneously. I also made something called an RF Model, also known as Random Forest.

What’s Random Forest?
It’s basically a module that you can import via python that uses ultrasonic readings and turns them into basic YOLO detection: Like “Corner” or “Left Wall” and that RF communicates to my Rviz2 display, telling it to snap walls or stuff like that when it detects “Corner” or “T-Junction”.

For my RF Model, I used a CSV file which uses my binary encodings(1 for blocked ultrasonic and 0 for not blocked ultrasonic). It was pretty simple, and with my 4 ultrasonic sensors I was able to create 16 total types of obstacles through my RF:

0,0,0,0,Path Clear
1,1,0,0,Left Corner Trap
1,0,1,0,Right Corner Trap
1,1,1,0,Dead End
1,1,1,1,Total Box Trap
0,1,1,0,Narrow Choke Point
0,0,0,1,Back Blocked
0,1,0,0,Left Wall
0,0,1,0,Right Wall
1,0,0,0,Front Wall
1,1,0,1,T-Junction Right Open
1,0,1,1,T-Junction Left Open
1,0,0,1,Fork
0,1,1,1,U-Tunnel Forward Open
0,1,0,1,Left Lane Guard
0,0,1,1,Right Lane Guard

I also created a few JSON files with timestamps and stuff to log where the walls were created in Rviz2 and when and stuff like that:

[
   {    
        "label": "Front wall",    
        "timestamp": "Jul 16 15:49",    
        "coordinates":   [      
            3.0,      
            0.0    
        ]  
    },
    {    
        "label": "Front wall",    
        "timestamp": "Jul 16 15:49",    
        "coordinates":   [      
            3.0,      
            -0.25    
        ]  
    }
]

So that’s basically what I spent my 9 hours of precious time on. It was Lwk such a pain but it was worth it.

Progress Devlog 1 - Phoenix 1:

If you saw my previous devlog, you should know what Phoenix 1 is. However, if you didn’t read it(Which you probably should :) ) you’re probably wondering: What is Phoenix 1?

Well, it’s an obstacle avoidance robot that is known as an SAR(Search & Rescue). It uses sensor pads featuring thermal and ultrasonic sensors to navigate its way through tough terrain. It also uses things like a servo to drive its way through rubble and save lives!

Today(Or maybe another day when you read this) I worked on my motor drivers and motors, and implemented a smart-driving system that utilizes specific readings that it is trained to recognize to understand how to maneuver itself through those places. I used Binary Code for this to implement a less than, and more than {distance} system. Here’s basically what I did in python:

def process_distances_to_flags(front, left, right, back):
    # 1 if less than threshold (blocked), 0 if clear
    f_blocked = 1 if front < 150 else 0
    l_blocked = 1 if left < 150 else 0
    r_blocked = 1 if right < 145 else 0
    b_blocked = 1 if back < 150 else 0
    
    return [f_blocked, l_blocked, r_blocked, b_blocked]

# Example: If your live readings are [400, 120, 80, 400]
processed_data = process_distances_to_flags(400, 120, 80, 400)
print(processed_data) 
# Output will be: [0, 1, 1, 0]

I still have a way to go before I finish, but I feel like I have good progress. Also, if you can, please try to explain why a 12 V DC Motor doesn’t work, even though I have the right wirings with my L298N motor drivers(Lwk stuck here). This is still what I have on my checklist though to complete for my SAR:

• Implementing Smart-Terrain Driving - Partial
• Fix the Motors - Partial
• Get a Ras Pi Camera, as well as a Hailo 10h(Separate VRAM hardware) for YOLO(See my What’s YOLO devlog for more!)
• Get a Power module & Thermal sensors
• Design Sensor Pads and Test PCBs(KiCad is what I use)

Have you ever heard of YOLO?

If you’re a normal person, you may have heard of it as the saying: “You only live once :)”

But, if you’re a computer-geek or a hack clubber, you may have also heard it as “You Only Look Once”

However, what’s the difference?

Well, YOLO is an AI Software that is a real-time image detection algorithm. It’s kind of like a Mock-LiDAR in a sense. If you have a regular camera, it generally isn’t possible to have a sense of perception, unlike LiDAR, which fires lasers to have depth. Below is how I used YOLO in my project!

My project uses a Raspberry Pi camera from Waveshare, and a few ultrasonic(HC_SR04) sensors for distance detection. I used YOLO nano to take the readings from my dist. sensors and camera and know what exactly is in front of me, not just a “thing”.

What’s Phoenix 1?

Started on my very cool robot, which uses different sensors like ultrasonic sensors and heat sensors, to detect its surroundings.

To be more specific, it is an SAR(Search and Rescue) Robot, which rescues people in different terrains by using sensor pads as well as LiDAR(A thing that uses 3D Scanning to acknowledge the environment around them.)

I just finished coding my ultrasonic sensors(Sensors that record distance: if you’re like ‘IDK what that is’) and tested them. They are good to go!

My next goals: That will hopefully be done :)

• Motors and Motor Drivers
• PCB Design using KiCAD(More on that in my later posts)
• Camera
• AI Module + Servos

Below is my code that I used for the ultrasonic sensors, I just used an arduino nano as an extension to manage the sensors, and python as a translator and stuff, in VSCode.
You can see the rest of my code in my git repo(Which i will be posting soon)