The truck has one motor to control the wheels and one servo to control steering.

any help please 

I am Barsha. An electrical and electronics engineer and tech blogger. 

I have in the past enjoyed to dronbot videos and I like to read the Q&A sections, where I usually learn even more.

I look forward to spending time exchanging ideas and experiences in the forums!

After installing the WireClaw firmware successfully on the ESP32-C6 and configuring WireClaw I can now read chip temp under Devices.

But after writing this command in Telegram; what is the chip temperature?  I keep on getting this Error.

      "error: LLM call failed]”

I have configured: Telegram Bot Token, Chat ID & API Key correctly, according to the instructions.

I have spent several days with this problem and I find this to be a very useful and interesting project.

My question is;  Do you have any magic tips How to solve this error? 

Greatful for any tips or hints.

Best regards,

@bomtech

or anyone else that might like to comment or give suggestions...

Today I decided to use AnyDesk to be able to program and send commands from my desktop laptop to the robot laptop. So now I can sit in my office/bedroom and drive it around the house like I have seen on many utube robots. I think it is possible to do the same between a Windows PC and the Linux RPi should I ever get the time to do a Rpi version. However manual control is not the goal. I am interested in autonomous control of the motors and reading the sensors in order to carry out some spoken command.

My visually controlled robot was coded using FreeBASIC code but to perhaps be more interesting to others I decided I had better write a Python version. Things have moved on since I first joined the forum and I know Python a bit better and AI makes learning and using it easier.

Although I am not just using the original target detection code in the project I decided to use AI to help write a Python version of my said target FreeBASIC code. The Python version wasn't all that good until I told it to write an exact copy of my algorithm although it had to use OpenCV so it wasn't a perfect copy.

At least anyone with Python installed and a camera can run it.

This is an output (laptop camera used) of the FreeBASIC version.

This is an output (laptop camera used) of the Python version.

For some reason it used yellow dots on the centroids of each found blob. I had done likewise on the target blobs so maybe I gave it a different FB version to translate.

Here is the Python code.

import cv2
import numpy as np
from dataclasses import dataclass
import random

# ============================================================
# CONFIGURATION
# ============================================================

IMGW = 640 #1100
IMGH = 360 #600

CAMERA_INDEX = 0

MIN_BLOB_AREA = 10
TARGET_DISTANCE = 5

SHOW_BINARY = False
SHOW_LABELS = False

# ============================================================
# BLOB STRUCTURE
# ============================================================

@dataclass
class Blob:
    area: int
    xMin: int
    yMin: int
    xMax: int
    yMax: int
    xCentroid: int
    yCentroid: int

# ============================================================
# FAST LOCAL THRESHOLD
# ============================================================

def fast_local_threshold(gray):
    """
    Faster replacement for the original pixel-loop threshold.

    Uses OpenCV adaptive threshold internally.
    Much faster than manual nested loops.
    """

    binary = cv2.adaptiveThreshold(
        gray,
        255,
        cv2.ADAPTIVE_THRESH_MEAN_C,
        cv2.THRESH_BINARY_INV,
        7,      # neighborhood size
        7       # threshold offset
    )

    return binary


# ============================================================
# CAMERA
# ============================================================

cap = cv2.VideoCapture(CAMERA_INDEX)

cap.set(cv2.CAP_PROP_FRAME_WIDTH, IMGW)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, IMGH)

if not cap.isOpened():
    print("ERROR: Could not open camera.")
    exit()

print("ESC = quit")
print("B   = toggle binary view")
print("L   = toggle label view")

# ============================================================
# MAIN LOOP
# ============================================================

while True:

    ret, frame = cap.read()

    if not ret:
        break

    frame = cv2.resize(frame, (IMGW, IMGH))

    # ========================================================
    # GRAYSCALE
    # ========================================================

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # ========================================================
    # FAST THRESHOLD
    # ========================================================

    binary = fast_local_threshold(gray)

    # Optional cleanup
    binary = cv2.medianBlur(binary, 3)

    # ========================================================
    # CONNECTED COMPONENTS
    # ========================================================

    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
        binary,
        connectivity=8
    )

    blobs = []

    # stats columns:
    # 

    for label in range(1, num_labels):

        x = stats
        y = stats
        w = stats
        h = stats
        area = stats

        if area < MIN_BLOB_AREA:
            continue

        cx = int(centroids)
        cy = int(centroids)

        blob = Blob(
            area=area,
            xMin=x,
            yMin=y,
            xMax=x + w,
            yMax=y + h,
            xCentroid=cx,
            yCentroid=cy
        )

        blobs.append(blob)

    # ========================================================
    # FIND CLOSEST CENTROIDS
    # ========================================================

    hit1 = None
    hit2 = None

    min_distance = 999999.0

    blob_count = len(blobs)

    for i in range(blob_count):

        b1 = blobs

        for j in range(i + 1, blob_count):

            b2 = blobs

            dx = b2.xCentroid - b1.xCentroid
            dy = b2.yCentroid - b1.yCentroid

            dist = np.hypot(dx, dy)

            if dist < min_distance:
                min_distance = dist
                hit1 = b1
                hit2 = b2

    # ========================================================
    # DISPLAY
    # ========================================================

    display = frame.copy()

    # Draw all blobs (optional)
    for blob in blobs:

        cv2.circle(
            display,
            (blob.xCentroid, blob.yCentroid),
            2,
            (0, 255, 255),
            -1
        )

    # ========================================================
    # TARGET DETECTION
    # ========================================================

    if hit1 is not None and hit2 is not None:

        dx = hit2.xCentroid - hit1.xCentroid
        dy = hit2.yCentroid - hit1.yCentroid

        distance = np.hypot(dx, dy)

        # Draw line between nearest blobs
        cv2.line(
            display,
            (hit1.xCentroid, hit1.yCentroid),
            (hit2.xCentroid, hit2.yCentroid),
            (0, 255, 255),
            1
        )

        if distance < TARGET_DISTANCE:

            # Draw target rectangle
            cv2.rectangle(
                display,
                (hit1.xMin, hit1.yMin),
                (hit1.xMax, hit1.yMax),
                (0, 128, 255),
                2
            )

            cv2.rectangle(
                display,
                (hit1.xMin - 2, hit1.yMin - 2),
                (hit1.xMax + 2, hit1.yMax + 2),
                (0, 0, 255),
                1
            )

            size_text = f"{hit1.xMax-hit1.xMin}, {hit1.yMax-hit1.yMin}"

            cv2.putText(
                display,
                size_text,
                (hit1.xMax + 5, hit1.yMax),
                cv2.FONT_HERSHEY_SIMPLEX,
                0.5,
                (0, 255, 255),
                1
            )

            cv2.putText(
                display,
                "TARGET",
                (30, 40),
                cv2.FONT_HERSHEY_SIMPLEX,
                1,
                (0, 255, 0),
                2
            )

        else:

            cv2.putText(
                display,
                "NO TARGET",
                (30, 40),
                cv2.FONT_HERSHEY_SIMPLEX,
                1,
                (0, 0, 255),
                2
            )

    # ========================================================
    # FPS DISPLAY
    # ========================================================

    fps = cap.get(cv2.CAP_PROP_FPS)

    cv2.putText(
        display,
        f"Blobs: {len(blobs)}",
        (30, 80),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.7,
        (255, 255, 255),
        2
    )

    # ========================================================
    # SHOW WINDOWS
    # ========================================================

    cv2.imshow("OpenCV Connected Components Tracking", display)

    if SHOW_BINARY:
        cv2.imshow("Binary", binary)

    if SHOW_LABELS:
        color_labels = labels_to_color(labels)
        cv2.imshow("Labels", color_labels)

    # ========================================================
    # KEYBOARD
    # ========================================================

    key = cv2.waitKey(1) & 0xFF

    if key == 27:
        break

    elif key == ord('b'):
        SHOW_BINARY = not SHOW_BINARY

    elif key == ord('l'):
        SHOW_LABELS = not SHOW_LABELS

# ============================================================
# CLEANUP
# ============================================================

cap.release()
cv2.destroyAllWindows()

An ESP32-based project seems ideal for this. I want to build a hidden motion-activated switch that can send alerts over cellular. Power isn’t a major concern since I can run it off solar — I’m planning to use a small 5W 5V solar panel, TP4056 charger, and a 2200mAh LiPo battery.

My main question is: What’s the best way to add cellular connectivity to an ESP32?

I know the ESP32 has WiFi, but I need to transmit data over cellular (4G/LTE preferred).

Copilot is moving to usage-based billing on June 1. For the best experience and latest updates, install Visual Studio 2026 — or at minimum, update to the latest version. Get VS 2026 Update VS 2022 Learn more

GitHub Copilot is moving to usage-based billing - The GitHub Blog

For me, what was conspicuously missing from the blog was how this would affect me, someone who had the free version. I now have the feeling that I'm going to be repeatedly asked to subscribe to the service until I do.

Approximately 2 years ago Microsoft told me that I could have CoPilot for free and have it integrated into my Visual Studio IDE. I said OK. I didn't use it but tried to get used to its suggestions. Now I use it semi-regularly.

Now it sounds like they want me to pay for it.

Thank God I don't depend upon it.