Asky Q&A - Recent questions and answers in AI + Rasberry PI

Answered: Multi-Zone Traffic Analytics (Multiple Lines + Directions) on Raspberry Pi

Wed, 07 Jan 2026 22:35:18 +0000

How much RAM need it?

Simple AI Traffic Analytics (Object Count + Speed) on Raspberry P

Sun, 04 Jan 2026 22:02:11 +0000

Hardware: Raspberry Pi 4 / Raspberry Pi 5
AI type: Computer Vision – Traffic Analytics

--------------------------------------------------

Overview

This project combines AI-based object counting and speed estimation to build
a simple traffic analytics system on Raspberry Pi.

The system detects vehicles, counts them, and estimates their speed using
camera input and lightweight AI models. Everything runs locally without
cloud services or GPUs.

--------------------------------------------------

What you build

- Vehicle detection using AI
- Real-time vehicle counting
- Approximate speed estimation
- Fully offline traffic analytics

--------------------------------------------------

Required hardware

- Raspberry Pi 4 or Raspberry Pi 5
- Camera (USB or Raspberry Pi Camera)
- microSD card
- Power supply

--------------------------------------------------

Software requirements

- Raspberry Pi OS
- Python 3
- OpenCV
- Ultralytics YOLO (lightweight model)

--------------------------------------------------

System architecture

1. Camera captures video frames
2. AI model detects vehicles
3. Each detected vehicle is counted
4. Vehicle movement between frames is tracked
5. Speed is estimated using distance and time

--------------------------------------------------

Installation

sudo apt update
sudo apt upgrade
sudo apt install python3-opencv python3-pip
pip3 install ultralytics

--------------------------------------------------

AI model

A lightweight YOLO Nano model is used for vehicle detection.
The model is pre-trained and used only for inference.

--------------------------------------------------

Python code (copy-paste)

import cv2
import time
import math
from ultralytics import YOLO

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture(0)

PIXELS_PER_METER = 60
prev_positions = {}
vehicle_id = 0
counted = set()

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame, verbose=False)
    boxes = results[0].boxes

    current_time = time.time()
    current_positions = {}

    for box in boxes:
        x1, y1, x2, y2 = box.xyxy[0]
        cx = int((x1 + x2) / 2)
        cy = int((y1 + y2) / 2)

        matched = False
        for vid, (px, py, pt) in prev_positions.items():
            dist = math.hypot(cx - px, cy - py)
            if dist < 50:
                speed = (dist / PIXELS_PER_METER) / (current_time - pt)
                current_positions[vid] = (cx, cy, current_time)
                matched = True
                break

        if not matched:
            current_positions[vehicle_id] = (cx, cy, current_time)
            counted.add(vehicle_id)
            vehicle_id += 1

    prev_positions = current_positions

    cv2.putText(frame, f"Vehicles counted: {len(counted)}",
                (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
                0.8, (0, 255, 0), 2)

    cv2.imshow("AI Traffic Analytics", frame)

    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

--------------------------------------------------

How it works

Vehicles are detected using AI and represented by their center point.
By comparing movement between frames and measuring time differences,
the system estimates approximate speed.

Counting is performed by assigning each detected vehicle a unique ID.

--------------------------------------------------

Calibration note

The PIXELS_PER_METER value depends on camera position and scene scale.
It must be adjusted experimentally for realistic speed values.

--------------------------------------------------

Practical applications

- Traffic flow monitoring
- Speed trend estimation
- Smart city prototypes
- Educational AI projects

--------------------------------------------------

Limitations

- Speed values are approximate
- Camera angle affects accuracy
- Not suitable for legal speed enforcement

--------------------------------------------------

Conclusion

This project demonstrates that meaningful traffic analytics can be built
on Raspberry Pi using AI, without expensive hardware or cloud services.

Affordable hardware combined with smart software design enables
practical AI solutions.

--------------------------------------------------

ESP32 Motion Sensor Trigger → Raspberry Pi AI Vision

Sun, 04 Jan 2026 22:00:20 +0000

Hardware: ESP32 + Raspberry Pi 4 / 5
AI type: Hybrid AI (Sensor Trigger + Computer Vision)

--------------------------------------------------

Overview

This project demonstrates a hybrid AI system where an ESP32 with a motion sensor
acts as a low-power trigger, while a Raspberry Pi runs AI vision only when motion
is detected.

This approach saves power and CPU resources by activating AI processing only
when needed.

--------------------------------------------------

What you build

- ESP32 motion detection node
- Raspberry Pi AI vision system
- Wireless trigger via Wi-Fi
- Fully local processing

--------------------------------------------------

Required hardware

- ESP32 development board
- PIR motion sensor (HC-SR501 or compatible)
- Raspberry Pi 4 or Raspberry Pi 5
- Camera (Pi Camera or USB camera)
- Wi-Fi network

--------------------------------------------------

Software requirements

ESP32:
- Arduino IDE
- WiFi library

Raspberry Pi:
- Raspberry Pi OS
- Python 3
- OpenCV
- Ultralytics YOLO

--------------------------------------------------

System architecture

1. ESP32 monitors motion using a PIR sensor
2. When motion is detected, ESP32 sends a Wi-Fi message
3. Raspberry Pi receives the trigger
4. AI vision starts only on demand

--------------------------------------------------

ESP32 Arduino code (motion trigger)

#include <WiFi.h>

const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_PASSWORD";

const char* pi_ip = "192.168.1.100";
const int pi_port = 5000;

int pirPin = 13;

void setup() {
pinMode(pirPin, INPUT);
Serial.begin(115200);

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
}

void loop() {
if (digitalRead(pirPin) == HIGH) {
WiFiClient client;
if (client.connect(pi_ip, pi_port)) {
client.println("MOTION");
client.stop();
}
delay(3000);
}
}

--------------------------------------------------

Raspberry Pi Python trigger listener

import socket
import subprocess

HOST = "0.0.0.0"
PORT = 5000

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((HOST, PORT))
sock.listen(1)

print("Waiting for ESP32 trigger...")

while True:
conn, addr = sock.accept()
data = conn.recv(1024).decode().strip()
if data == "MOTION":
print("Motion detected - starting AI vision")
subprocess.Popen(["python3", "ai_vision.py"])
conn.close()

--------------------------------------------------

Raspberry Pi AI vision example (ai_vision.py)

import cv2
from ultralytics import YOLO

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture(0)

for i in range(100):
ret, frame = cap.read()
if not ret:
break
results = model(frame, verbose=False)
cv2.imshow("AI Vision", frame)
if cv2.waitKey(1) & 0xFF == 27:
break

cap.release()
cv2.destroyAllWindows()

--------------------------------------------------

How it works

The ESP32 continuously monitors motion with very low power usage.
When motion is detected, it sends a simple trigger message to the Raspberry Pi.
The Raspberry Pi then activates AI vision for a limited time.

--------------------------------------------------

Practical applications

- Smart surveillance systems
- Wildlife monitoring
- Energy-efficient AI cameras
- Security triggers

--------------------------------------------------

Limitations

- Requires Wi-Fi connectivity
- PIR detects motion, not object type
- AI runtime duration must be managed

--------------------------------------------------

Conclusion

By combining ESP32 sensors with Raspberry Pi AI vision, efficient hybrid AI systems
can be built on affordable hardware.

AI without millions is achieved through smart architecture, not expensive hardware.

Line Crossing Counter with AI on Raspberry Pi (Entry / Exit Detection)

Sun, 21 Dec 2025 21:03:34 +0000

Line Crossing Counter with AI on Raspberry Pi

Hardware: Raspberry Pi 4 / 5
AI type: Computer Vision – Object Detection

Overview

This project shows how a Raspberry Pi can count entries and exits using AI.
Objects are detected by a lightweight AI model and counted when they cross a virtual line.
Everything runs locally, without cloud services or GPUs.

What you build

AI object detection on Raspberry Pi
Entry / exit counting using a virtual line
Fully offline processing

Required hardware

Raspberry Pi 4 or 5
Camera (Pi Camera or USB)
microSD card
Power supply

Software

Raspberry Pi OS
Python 3
OpenCV
Ultralytics YOLO

Installation

Concept

A horizontal virtual line is placed in the video frame.
When an object’s center crosses the line, it is counted as entry or exit depending on direction.

Python code (copy-paste)

import cv2 from ultralytics import YOLO model = YOLO("yolov8n.pt") cap = cv2.VideoCapture(0) line_y = 240 prev_y = None entries = 0 exits = 0 while True: ret, frame = cap.read() if not ret: break results = model(frame, verbose=False) boxes = results[0].boxes if len(boxes) > 0: x1, y1, x2, y2 = boxes[0].xyxy[0] cy = int((y1 + y2) / 2) if prev_y is not None: if prev_y < line_y and cy >= line_y: entries += 1 elif prev_y > line_y and cy <= line_y: exits += 1 prev_y = cy cv2.line(frame, (0, line_y), (frame.shape[1], line_y), (255, 0, 0), 2) cv2.putText(frame, f"Entries: {entries}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,255,0), 2) cv2.putText(frame, f"Exits: {exits}", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,0,255), 2) cv2.imshow("Line Counter", frame) if cv2.waitKey(1) & 0xFF == 27: break cap.release() cv2.destroyAllWindows()

Applications

People entry/exit counting
Store traffic analysis
Simple access monitoring

Limitations

Works best with one main object
Occlusions reduce accuracy

Conclusion

Raspberry Pi can perform practical AI analytics like entry and exit counting without expensive hardware.
This is a real, deployable AI use case on affordable devices.

Speed estimation with AI on Raspberry Pi

Fri, 19 Dec 2025 07:22:17 +0000

Hardware: Raspberry Pi 4 / Raspberry Pi 5
AI type: Computer Vision – Detection + Speed Estimation

Overview

This project shows how a Raspberry Pi can estimate the speed of moving objects using AI-based object detection and simple motion analysis.
The system runs fully offline and does not require GPUs or cloud services.

The goal is not absolute precision, but a practical and reproducible AI approach using affordable hardware.

What you will build

AI-based object detection on Raspberry Pi
Tracking object movement across frames
Estimating object speed using pixel distance and time
Fully local processing

Required hardware

Raspberry Pi 4 or Raspberry Pi 5
Raspberry Pi Camera or USB camera
microSD card
Power supply

Software requirements

Raspberry Pi OS
Python 3
OpenCV
Ultralytics YOLO (lightweight model)

Project architecture

Camera captures video frames
AI model detects objects
Object positions are tracked
Speed is calculated from movement over time

Installation steps

Update system and install dependencies:

sudo apt update
sudo apt upgrade
sudo apt install python3-opencv python3-pip
pip3 install ultralytics

AI model choice

A lightweight YOLO Nano model is used for detection.
The model is pre-trained and used only for inference.

import cv2
from ultralytics import YOLO
import time
import math

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture(0)

prev_pos = None
prev_time = None
speed = 0

PIXELS_PER_METER = 50 # calibration value

while True:
ret, frame = cap.read()
if not ret:
break

results = model(frame, verbose=False)
boxes = results[0].boxes

if len(boxes) > 0:
x1, y1, x2, y2 = boxes[0].xyxy[0]
cx = int((x1 + x2) / 2)
cy = int((y1 + y2) / 2)

current_time = time.time()

if prev_pos is not None:
dist_pixels = math.hypot(cx - prev_pos[0], cy - prev_pos[1])
dist_meters = dist_pixels / PIXELS_PER_METER
dt = current_time - prev_time
if dt > 0:
speed = dist_meters / dt

prev_pos = (cx, cy)
prev_time = current_time

cv2.circle(frame, (cx, cy), 5, (0, 255, 0), -1)

cv2.putText(frame, f"Speed: {speed:.2f} m/s",
(10, 30), cv2.FONT_HERSHEY_SIMPLEX,
1, (0, 255, 0), 2)

cv2.imshow("AI Speed Estimation", frame)

if cv2.waitKey(1) & 0xFF == 27:
break

cap.release()
cv2.destroyAllWindows()

How it works

The AI model detects an object and extracts its center position.
The distance between positions across frames is measured in pixels and converted to meters using a calibration factor.
Speed is calculated as distance divided by time.

Calibration note

The PIXELS_PER_METER value depends on camera position and scene scale.
It must be adjusted experimentally for better accuracy.

Practical applications

Traffic speed monitoring
Robot motion analysis
Conveyor belt monitoring
Educational AI projects

Limitations

Approximate speed estimation
Sensitive to camera angle and calibration
Not suitable for high-precision measurements

Conclusion

This project demonstrates that Raspberry Pi can perform meaningful AI-based speed estimation without GPUs or cloud services.
With lightweight models and simple math, affordable hardware can deliver practical AI solutions.

AI without millions remains an engineering reality.

Object Tracking and Unique Counting with AI on Raspberry Pi

Thu, 18 Dec 2025 05:05:44 +0000

Hardware: Raspberry Pi 4 / Raspberry Pi 5
AI type: Computer Vision – Object Detection + Tracking

Overview

Simple object counting detects how many objects appear in a frame, but it cannot distinguish between new and already seen objects.
This project extends basic AI detection by adding object tracking, allowing the Raspberry Pi to count each object only once.

The result is a more practical AI system suitable for real-world scenarios such as people flow monitoring or vehicle counting.

What you will build

AI-based object detection on Raspberry Pi
Object tracking across video frames
Unique object counting (count once per object)
Fully local and offline system

Required hardware

Raspberry Pi 4 or Raspberry Pi 5
Raspberry Pi Camera or USB camera
microSD card
Power supply

Software requirements

Raspberry Pi OS
Python 3
OpenCV
Ultralytics YOLO (lightweight model)

Project architecture

Camera captures video frames
AI model detects objects in each frame
Tracker assigns IDs to detected objects
Each object ID is counted only once

This avoids double counting and improves accuracy.

Installation steps

Update system

sudo apt update sudo apt upgrade

Install dependencies

sudo apt install python3-opencv python3-pip pip3 install ultralytics

Reboot the system

AI model and tracking method

This project uses a lightweight YOLO model for detection and a simple centroid-based tracking logic.
Each detected object is assigned an ID based on its position across frames.

This approach is computationally efficient and suitable for Raspberry Pi hardware.

Python code (copy-paste)

import cv2 from ultralytics import YOLO import math model = YOLO("yolov8n.pt") cap = cv2.VideoCapture(0) object_id = 0 objects = {} counted_ids = set() def distance(p1, p2): return math.hypot(p1[0] - p2[0], p1[1] - p2[1]) while True: ret, frame = cap.read() if not ret: break results = model(frame, verbose=False) boxes = results[0].boxes current_centroids = [] for box in boxes: x1, y1, x2, y2 = box.xyxy[0] cx = int((x1 + x2) / 2) cy = int((y1 + y2) / 2) current_centroids.append((cx, cy)) for centroid in current_centroids: matched = False for oid, prev in objects.items(): if distance(centroid, prev) < 50: objects[oid] = centroid matched = True break if not matched: objects[object_id] = centroid counted_ids.add(object_id) object_id += 1 for oid, (cx, cy) in objects.items(): cv2.circle(frame, (cx, cy), 5, (0, 255, 0), -1) cv2.putText(frame, f"ID {oid}", (cx + 5, cy + 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) cv2.putText(frame, f"Unique count: {len(counted_ids)}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) cv2.imshow("AI Object Tracking", frame) if cv2.waitKey(1) & 0xFF == 27: break cap.release() cv2.destroyAllWindows()

How it works

Each detected object is represented by its centroid.
The system compares centroids between frames and assigns the same ID if the distance is below a threshold.

When a new object appears, it receives a new ID and is counted only once.

This simple tracking logic avoids the complexity of advanced trackers while remaining effective.

Performance notes

Works best with moderate object movement
High-speed motion may cause ID switching
Lower camera resolution improves stabilit

Practical application

People flow analysis
Vehicle counting
Queue monitoring
Entrance and exit statistics
Smart surveillance prototypes

Limitations

Simple tracker may lose objects during occlusion
Not suitable for dense crowds
Advanced tracking requires more compute

Despite this, the solution is ideal for low-cost AI systems.

Conclusion

By combining AI detection and lightweight tracking, Raspberry Pi becomes capable of unique object counting without GPUs or cloud services.
This project demonstrates how far affordable hardware can go with the right software architecture.

AI without millions is not a compromise — it is a design choice.

Object Counting with AI on Raspberry Pi (Offline Computer Vision)

Wed, 17 Dec 2025 05:16:32 +0000

Hardware: Raspberry Pi 4 / Raspberry Pi 5
AI type: Computer Vision – Object Detection and Counting

Overview

This project demonstrates how a Raspberry Pi can be used to run an AI-based object detection system that counts objects in real time using a camera.
The system works locally, without cloud services or GPUs, proving that practical computer vision projects are possible on affordable hardware.

The focus is not on large models or high accuracy benchmarks, but on a functional and reproducible AI pipeline.

What you will build

Raspberry Pi running AI-based object detection
Real-time object counting from a camera feed
Fully local inference (offline)
Simple Python-based setup

Required hardware

Raspberry Pi 4 or Raspberry Pi 5
Raspberry Pi Camera Module or USB camera
microSD card (16GB or larger)
Power supply

Software requirements

Raspberry Pi OS (64-bit recommended)
Python 3
OpenCV
Pre-trained lightweight object detection model

Project architecture

Camera captures video frames
Frames are processed locally on Raspberry Pi
AI model detects objects in each frame
Objects are counted and displayed in real time

All processing happens on the Raspberry Pi.

Installation steps

Update the system

sudo apt update sudo apt upgrade

Install required packages

sudo apt install python3-opencv python3-pip pip3 install ultralytics

Reboot the Raspberry Pi

AI model selection

For this project, a lightweight YOLO model is used.
YOLO Nano or YOLOv8 Nano variants are suitable for Raspberry Pi due to their low computational requirements.

The model is pre-trained and used only for inference.

Python code :

import cv2
from ultralytics import YOLO

# Load lightweight YOLO model
model = YOLO("yolov8n.pt")

# Open camera
cap = cv2.VideoCapture(0)

while True:
ret, frame = cap.read()
if not ret:
break

# Run inference
results = model(frame, verbose=False)

# Extract detections
boxes = results[0].boxes
count = len(boxes)

# Display object count
cv2.putText(
frame,
f"Objects detected: {count}",
(10, 30),
cv2.FONT_HERSHEY_SIMPLEX,
1,
(0, 255, 0),
2
)

cv2.imshow("Object Counting AI", frame)

if cv2.waitKey(1) & 0xFF == 27:
break

cap.release()
cv2.destroyAllWindows()

How it works

Each video frame captured by the camera is passed to the YOLO model running on the Raspberry Pi.
The model detects objects in the frame and returns bounding boxes.
The number of detected objects is counted and displayed in real time.

This approach does not require object tracking and keeps the system simple and efficient.

Performance notes

Raspberry Pi 4: approximately 3–6 FPS depending on resolution
Raspberry Pi 5: higher and more stable frame rates
Lower camera resolution improves performance

Practical applications

People counting
Vehicle counting
Inventory monitoring
Simple security and monitoring systems
Educational computer vision projects

Limitations

Limited frame rate compared to GPU systems
Reduced accuracy for small or distant objects
Not suitable for large or complex models

These limitations are expected and acceptable for low-cost AI systems

AI Without Millions: Real Intelligent Projects on Raspberry Pi and ESP32

Mon, 15 Dec 2025 07:49:34 +0000

Artificial Intelligence Is Not Just for Corporations

AI is often associated with GPU clusters, cloud services, and large budgets. This perception suggests that meaningful AI projects are out of reach for individuals and small teams. In reality, modern low-cost hardware enables fully functional intelligent systems without significant financial investment.

Raspberry Pi as an AI Platform

Raspberry Pi 4 and Pi 5 provide enough computing power for local AI inference. They are commonly used for:

computer vision (OpenCV, YOLO Nano variants)
audio and signal analysis
intelligent systems without constant internet access
hybrid AI architectures with local decision-making

While Raspberry Pi is not designed for training large models, it is highly effective for running them.

ESP32: AI on a Microcontroller

ESP32 expands what is possible on a microcontroller. Using TensorFlow Lite Micro and Edge Impulse, ESP32-based systems can perform:

image classification on ESP32-CAM
keyword spotting
sensor data classification
anomaly detection

These capabilities come with very low power consumption and extremely low hardware cost.

What Makes a Project “AI”

An AI project is defined by intelligent behavior, not by model size. Common patterns include:

local inference
hybrid rule-based and ML systems
distributed intelligence across devices
fallback logic for robustness

A typical example is an ESP32 detecting an event and forwarding data to a Raspberry Pi for higher-level processing.

Practical Applications Without Large Budgets

Such systems are already used for:

privacy-friendly local video monitoring
early fault detection
intelligent alarm systems
autonomous sensor nodes

They deliver real functionality without expensive infrastructure.

Constraints Are Part of Engineering

Low-cost AI systems come with limitations: smaller models, constrained memory, and the need for careful optimization. These constraints shift the focus from budget to engineering skill.

Conclusion

Artificial intelligence is no longer exclusive to large corporations. With affordable hardware and thoughtful system design, real AI projects can be built without millions in funding.

How I Built an AI-Powered Multi-Language Currency Converter and Hosted It on a Raspberry Pi

Sat, 29 Nov 2025 21:47:43 +0000

Many people use Raspberry Pi for small experiments, but it can also run real web services when combined with modern AI tools. One of the newest features on asky.uk is a multi-language euro currency converter that was designed with the help of AI and runs entirely on a Raspberry Pi.

This article explains how the tool was created, how it works, and why it fits perfectly into the platform’s mission of combining AI and low-cost hardware.

Idea and Goals

The converter needed to be:

fast and lightweight
multilingual
minimalistic in design
accurate (using ECB reference rates)
fully autonomous
hosted on a Raspberry Pi 2 without external cloud services

The goal was to demonstrate that a real, useful web service can be developed with AI assistance and deployed on extremely small hardware.

How AI Helped Build It

AI was used to generate most of the converter:

HTML, CSS, and responsive layout
JavaScript logic for EUR ⇄ national currencies
translations into seven languages
dark/light themes
flag icons and UI structure
a Python script to download and store ECB rates daily

This dramatically reduced development time and produced clean, efficient code suited for low-power devices.

Automatic Updates via Raspberry Pi

The converter retrieves fresh exchange rates from the European Central Bank.
A daily cron job on the Raspberry Pi:

downloads the newest rates
writes them to rates.json
updates timestamps
keeps the tool fully autonomous

No external database or manual updates are required.

Hosting on Raspberry Pi

The entire service runs on a Raspberry Pi 2 using Apache2 and Let’s Encrypt SSL. Even this older Pi model easily handles:

real-time conversions
multi-language UI
dark mode
fast static hosting
AdSense integration

This proves that small devices can power real, production-ready web applications when the code is optimized.

Multi-Language Support

The interface includes translations for:

English
Bulgarian
Czech
Polish
Hungarian
Romanian
Turkish

The converter automatically selects the correct language using browser settings (and optionally IP), allowing people from different countries to use it in their native language.

Design and Speed Optimization

The converter is built as a single static HTML file:

no frameworks
no server-side rendering
almost instant load time
excellent mobile performance
optional AMP version

This approach improves SEO and ensures the site works smoothly even on older phones.

Part of a Larger AI + Raspberry Pi Project

asky.uk focuses on projects created with or enhanced by AI.
This converter is part of a broader effort to:

build small AI-assisted tools
host them on Raspberry Pi devices
demonstrate how modern AI can simplify coding, automation, and deployment

It shows how AI can turn a simple idea into a complete, autonomous service running entirely on your own hardware.

Conclusion

The euro currency converter is a practical example of what can be achieved when AI technology and Raspberry Pi hardware are combined.
It is fast, multilingual, self-updating, and completely self-hosted — a perfect demonstration of the direction in which asky.uk continues to evolve:

lightweight, intelligent, AI-built tools running on small, affordable hardware.

CONVERTOR

Have you tried Manus yet?

Sat, 15 Nov 2025 15:43:17 +0000

One of the perfect AI tools through which you can bring any of your projects to success

MANUS

Monetizing a Asky AI Bot

Wed, 17 Sep 2025 07:57:36 +0000

Building an AI-powered project such as an HTML/CSS generator is fun, but turning it into a sustainable source of income requires clear monetization strategies. If you don’t want to rely solely on AdSense, here are practical alternatives that don’t require user accounts or heavy data collection (important for GDPR and privacy compliance).

1. One-Time Digital Product Sales

Instead of subscriptions, you can package outputs as downloadable assets:

Static bundles: pre-designed templates, CSS themes, or landing page packs.
Customized bundles: the app generates a ZIP file tailored to the user’s description.

Implementation:

Use Stripe Checkout, PayPal Buy Now, or Gumroad/Payhip for transactions.
Deliver via expiring download links (e.g., valid for 1 hour).
Price range: £1–£10 for small templates, £10–£30 for bundles.

This model is simple, requires minimal personal data, and is compatible with small traffic volumes.

2. Freemium With Pay-Per-Use

Keep the app free for light use, but charge for “power features”:

More than 1–2 generations per day.
Access to advanced templates (responsive, dark/light modes).
Direct code download (instead of copy/paste).

Implementation:

Add a “Buy More Generations” button.
Stripe Payment Links can sell credits (e.g., 20 generations for £5).
No accounts: you can deliver credits via ephemeral tokens, emailed codes, or even short-lived cookies.

3. Premium API Access

Your AI app could also work as a micro-API:

Example endpoint: /generate_html?desc=blue+login+form.
Free for hobbyists (limited calls/day).
Paid tier for developers who want to integrate it into their own workflows.

Implementation:

Host the API behind RapidAPI or Stripe-based usage credits.
Good for attracting other programmers and SaaS builders.

This option scales better than selling static templates but requires stable uptime and rate-limiting.

4. Pay-What-You-Want Donations (Enhanced)

While “donate” buttons are common, they can be made more compelling:

Offer a bonus file or extended functionality when someone donates (e.g., a premium template).
Integrate BuyMeACoffee, Ko-fi, or Stripe’s “tip jar” feature.

Implementation:

Minimal dev work, no data storage.
Works best if you already have traffic from open-source communities or learners.

5. Plugins & Marketplace Integrations

Instead of only offering a web tool, wrap your AI generator into a product for existing ecosystems:

WordPress plugin: “Generate CSS blocks from plain English.”
Shopify app: “AI quick theme tweaks.”
VS Code extension: “Generate HTML snippets in editor.”

Implementation:

Start with a simple downloadable plugin.
Sell it as a one-time purchase (£10–£20) on marketplaces.

This approach extends reach beyond your own site and makes revenue more stable.

6. Fiverr / Upwork Automation

Turn the tool into a semi-passive service:

Create a Fiverr gig: “I’ll generate a responsive HTML/CSS template with AI.”
Behind the scenes, clients interact with your tool instead of you coding manually.
Delivery can be automated: payment → webhook → file generation → delivery.

Implementation:

Reuse the same code as your app, just wrap it for gig platforms.
Can generate £20–£200/month even at low traffic, depending on pricing.

Pricing Tips

Low-friction pricing (under £5) works best for instant purchases.
Bundles (£10–£30) are attractive for small business owners or students.
For developers, API credits are more natural (£5–£15 per 1,000 requests).

Legal & Privacy Considerations

Use Stripe, PayPal, or Gumroad — they handle payment security and compliance.
Keep a minimal privacy policy: clearly state that no personal data is stored.
For EU/UK: digital product sales may be subject to VAT — keep that in mind if scale grows.

Conclusion

AdSense may bring a trickle of revenue, but the real opportunity lies in direct monetization of what your AI app creates. Selling small, useful digital products or offering pay-per-use access can generate anywhere from a few pounds to a few hundred pounds per month, all without user accounts or storing personal data.

Start simple: package one or two template bundles, add a “Buy Now” button, and deliver via expiring download links. Once you see traction, consider expanding into APIs, plugins, or marketplaces.

Building an AI-Powered LoRa Mesh Network on Raspberry Pi 5: A Community Communication Project for Small Villages

Sun, 07 Sep 2025 11:52:53 +0000

In remote or underserved areas, reliable communication can be a challenge due to limited internet access or infrastructure. This project outlines how to create a small-scale, decentralized communication network using Raspberry Pi 5 boards equipped with LoRa (Long Range) modules. The network is designed to support 50-100 users in a small populated place, such as a village, enabling text-based messaging, data sharing, and basic alerts without relying on cellular or Wi-Fi networks.

To add intelligence, we'll integrate AI capabilities on the Raspberry Pi 5 using lightweight models like TensorFlow Lite. The AI can handle tasks such as automated message routing, sentiment analysis for community alerts (e.g., detecting urgent messages), or even simple natural language processing (NLP) for chat moderation. LoRa's low-power, long-range capabilities (up to several kilometers in open areas) make it ideal for mesh networking, where devices relay messages to extend coverage.

This setup assumes a mesh topology, where each user's device acts as a node, relaying data to others. For 50-100 users, you'll need multiple nodes, but we'll focus on building a single node prototype that can be replicated.

Key Benefits:
- Low cost: Each node costs around $100-150.
- Energy efficient: Suitable for solar-powered setups in off-grid areas.
- Privacy-focused: Decentralized, no central server required.
- Scalable: Easily expand by adding more nodes.

Estimated Range and Capacity:
- LoRa can cover 2-10 km per hop depending on terrain and antenna.
- For 50-100 users, aim for 10-20 gateway nodes to handle traffic, with users connecting via simple LoRa-enabled devices (e.g., smartphones with LoRa adapters or dedicated handhelds).

Required Components

For a single node (Raspberry Pi 5 as a gateway/router):
- Raspberry Pi 5 (4GB or 8GB model recommended for AI tasks).
- LoRa module: SX1276/SX1278-based HAT or breakout board (e.g., Dragino LoRa HAT or Waveshare SX1262).
- Antenna: High-gain outdoor antenna (5-9 dBi) for better range.
- Power supply: 5V/3A USB-C adapter; consider solar panels for remote deployment.
- Storage: 16GB+ microSD card with Raspberry Pi OS (Lite version for efficiency).
- Display/Keyboard (optional for setup): HDMI monitor and USB peripherals.
- Enclosure: Weatherproof case for outdoor use.
- Additional for AI: USB accelerator like Coral TPU (optional for faster inference).

For user endpoints (simpler nodes):
- ESP32 or Arduino boards with LoRa modules (cheaper alternatives to full Pi setups for end-users).
- Mobile app integration: Use Bluetooth to connect smartphones to LoRa nodes.

Total cost per gateway node: ~$120. Scale up by distributing simpler nodes to users.

Step-by-Step Instructions

Step 1: Hardware Assembly
1. Set up the Raspberry Pi 5:
- Insert the microSD card with Raspberry Pi OS installed (download from raspberrypi.com and flash using Raspberry Pi Imager).
- Connect the LoRa HAT/module to the Pi's GPIO pins. For Dragino HAT, align pins and secure.
- Attach the antenna to the LoRa module's connector.
- Power on the Pi and boot into the OS.

2. Test Connections:
- SSH into the Pi (enable SSH in raspi-config).
- Verify LoRa module: Run `ls /dev` to check for `/dev/spidev0.0` (SPI interface).

Step 2: Software Installation
1. Update System:
```
sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip git -y
```

2. Install LoRa Libraries:
- Use PyLoRa or LoRaWAN libraries. Clone a mesh networking library like Meshtastic (which supports LoRa for chat networks).
```
git clone https://github.com/meshtastic/Meshtastic-python.git
cd Meshtastic-python
pip3 install -r requirements.txt
```
- Alternatively, for custom setup: Install `RPi.GPIO` and `spidev`.
```
pip3 install RPi.GPIO spidev
```

3. Install AI Frameworks:
- TensorFlow Lite for edge AI:
```
sudo apt install libatlas-base-dev -y
pip3 install tensorflow-lite
```
- For NLP/sentiment analysis, add Hugging Face's Transformers (lite version):
```
pip3 install transformers torch
```
- Download a pre-trained model, e.g., DistilBERT for sentiment:
```
from transformers import pipeline
classifier = pipeline('sentiment-analysis')
```

Step 3: Configure LoRa Mesh Network
1. Set Up LoRa Parameters:
- Frequency: Use 433MHz, 868MHz, or 915MHz based on your region's regulations (check local laws).
- In code, configure spreading factor (SF7-SF12) for range vs. speed trade-off. Higher SF for longer range but slower data.
- Example Python script for basic send/receive:
```python
import time
import LoRa # Assuming PyLoRa library

lora = LoRa.LoRa(verbose=False)
lora.set_mode(LoRa.MODE.STDBY)
lora.set_freq(915.0) # Adjust frequency
lora.set_spreading_factor(7)

# Send message
lora.write_payload([ord(c) for c in "Hello LoRa!"])
lora.set_mode(LoRa.MODE.TX)
time.sleep(1)

# Receive loop
while True:
if lora.received_packet():
payload = lora.read_payload()
print("".join(chr(b) for b in payload))
```

2. Implement Mesh Topology:
- Use libraries like PainlessMesh or adapt Meshtastic for LoRa.
- Each node broadcasts its ID and relays messages if not the destination.
- For 50-100 users: Limit hops to 3-5 to avoid latency. Use channel hopping to reduce interference.

3. Integrate AI:
- Message Routing with AI: Use a simple ML model to predict optimal routes based on signal strength history.
- Collect data: Log RSSI (Received Signal Strength Indicator) from LoRa packets.
- Train a basic model (e.g., scikit-learn on Pi):
```
pip3 install scikit-learn
```
Example: Linear regression for path prediction.
- Sentiment Analysis for Alerts: Analyze incoming messages.
```python
from transformers import pipeline
classifier = pipeline('sentiment-analysis', model='distilbert-base-uncased-finetuned-sst-2-english')

def analyze_message(msg):
result = classifier(msg)[0]
if result['label'] == 'NEGATIVE' and result['score'] > 0.8:
return "Alert: Potential emergency!"
return "Normal message"

# Integrate into receive loop
msg = "".join(chr(b) for b in payload)
print(analyze_message(msg))
```
- NLP for Moderation: Filter spam or translate messages using lightweight models.
- Run AI on boot: Use systemd service to start scripts.

### Step 4: User Interface and Deployment
1. Build a Simple App:
- Web-based UI: Use Flask on Pi.
```
pip3 install flask
```
Create a dashboard for sending/receiving messages.
- Mobile Integration: Pair with Bluetooth for smartphone access (use BlueZ on Pi).
- For end-users: Distribute ESP32-LoRa kits with a simple LCD/button interface.

2. Network Deployment:
- Place gateway Pis on high points (roofs, hills) for coverage.
- Test range: Start with 2-3 nodes, send messages, measure latency.
- Scale: Assign unique IDs to users. Use encryption (e.g., AES via pycryptodome) for privacy.
- Power Management: Enable sleep modes on LoRa for battery life.

3. Testing and Optimization:
- Simulate 50-100 users: Use multiple virtual nodes or scripts to flood messages.
- Monitor with AI: Implement anomaly detection to flag network issues.
- Bandwidth: LoRa is low-data ( ~0.3-50 kbps), so limit to text/short data.

Challenges and Considerations
- Regulatory Compliance: Ensure LoRa frequency use is legal in your area (e.g., FCC in US, ETSI in Europe).
- Security:Add authentication to prevent unauthorized access.
- Scalability Limits: For >100 users, consider hybrid with Wi-Fi gateways.
- AI Performance: Raspberry Pi 5's NPU helps, but heavy models may need optimization or offloading.
- Maintenance:Remote SSH for updates; use Watchdog for reliability.

Conclusion
This AI-enhanced LoRa mesh network on Raspberry Pi 5 empowers small communities with resilient communication. By following these steps, you can prototype a node in a weekend and deploy a full network in weeks. Experiment, iterate, and share your improvements—open-source the code on GitHub for community benefit!

Turn Your Raspberry Pi into a Chat-with-PDF AI Assistant

Tue, 22 Jul 2025 06:47:24 +0000

Turn Your Raspberry Pi into a Chat-with-PDF AI Assistant

The Raspberry Pi 5 is powerful enough to handle some surprisingly advanced AI tasks. Today, we’ll show you how to build a Chat-with-PDF Assistant on your Pi — a local tool that lets you upload PDF files and ask questions about them using natural language, just like ChatGPT.

No need for the cloud. Everything runs locally on your Raspberry Pi.

What You’ll Build

A local AI assistant that can:

Ingest PDF files
Convert text to vector embeddings
Accept questions in plain English
Answer based on PDF contents
All without sending your documents to the cloud.

What You’ll Need

Raspberry Pi 5 (or Pi 4 with swap enabled)
64-bit Raspberry Pi OS
Python 3.9+
pip and virtualenv
PDF document(s) to test with
Internet connection (initial setup only)

Step 1: Install Required Packages

First, update your Pi and install basic dependencies:

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv

Create and activate a virtual environment:

python3 -m venv pdfbot-env
source pdfbot-env/bin/activate

Now install the core Python libraries:

pip install --upgrade pip
pip install langchain faiss-cpu pypdf openai tiktoken

Optionally:
Replace openai with llama-cpp-python or transformers if you want to use local models instead of OpenAI’s API.

Step 2: Load and Split Your PDF

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import CharacterTextSplitter

loader = PyPDFLoader("your_file.pdf")
pages = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
documents = text_splitter.split_documents(pages)

Step 3: Embed and Store Text

Use FAISS to store searchable vectors:

from langchain.vectorstores import FAISS
from langchain.embeddings.openai import OpenAIEmbeddings

embedding = OpenAIEmbeddings()
db = FAISS.from_documents(documents, embedding)

Step 4: Set Up the Chat Function

from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI

chain = load_qa_chain(OpenAI(), chain_type="stuff")

def ask(query):
    docs = db.similarity_search(query)
    answer = chain.run(input_documents=docs, question=query)
    return answer

Example usage:

print(ask("What does the report say about revenue growth in 2023?"))

️ Optional: Use a Local Model Instead of OpenAI

Replace OpenAI() with a local LLM like llama.cpp, or use an API like Ollama running on your Pi. Just swap out the LLM in load_qa_chain.

Final Notes

Raspberry Pi 5 handles vector search + API queries easily.
RAM-intensive operations like LLM inference locally may require swap files or 8GB model variants.
For full local use, combine with llama.cpp and a local embedding model.

Summary

You’ve now built a Chat-with-PDF Assistant that runs on your Raspberry Pi and can answer questions about any document you upload. It's private, fast, and extendable.

Run a Stable Diffusion Image Generator Locally on Raspberry Pi 5

Sun, 20 Jul 2025 18:58:24 +0000

Run a Stable Diffusion Image Generator Locally on Raspberry Pi 5

Create stunning AI-generated images on your Pi — without internet!

️ Overview

Stable Diffusion is a powerful open-source image generation model that turns text prompts into photorealistic or artistic images. While it's typically run on desktops with powerful GPUs, recent optimizations and the Raspberry Pi 5's performance improvements make it possible (with compromises) to run lightweight versions of it locally.

In this article, we’ll show you how to:

✅ Run a CPU-friendly version of Stable Diffusion on Raspberry Pi 5
✅ Generate images from text prompts
✅ Use Python and diffusers library from HuggingFace
✅ Work fully offline after setup

⚠️ This guide uses a highly optimized model suited for CPU-only inference. Don’t expect real-time speed — but it works!

Requirements

Component	Version / Notes
Raspberry Pi	Pi 5 (8GB RAM strongly recommended)
OS	Raspberry Pi OS Bookworm (64-bit)
Python	≥ 3.10
Disk Space	~6 GB
Internet	Only for installation and model download
Model	Stable Diffusion 1.5 (CPU-optimized)

Step 1: System Setup

sudo apt update && sudo apt upgrade -y
sudo apt install python3 python3-venv python3-pip -y

Create and activate a Python virtual environment:

python3 -m venv sd-env
source sd-env/bin/activate

Step 2: Install Required Python Libraries

pip install --upgrade pip
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
pip install diffusers transformers accelerate scipy safetensors

We use the CPU-only version of PyTorch to ensure compatibility with the Raspberry Pi’s hardware.

Step 3: Download a CPU-optimized Model

Let’s use the runwayml/stable-diffusion-v1-5 or smaller variant from HuggingFace.

You can use this script to automatically load and save the model locally:

from diffusers import StableDiffusionPipeline
import torch

pipeline = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float32,
)
pipeline = pipeline.to("cpu")

prompt = "A cyberpunk robot cat, neon background"
image = pipeline(prompt).images[0]
image.save("output.png")

Tip: Use Smaller Models

If your Pi struggles, try:

from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base")

Or explore CPU-optimized models like:

CompVis/stable-diffusion-v1-4
Linaqruf/stable-diffusion-1-5-better-vae
SG161222/Realistic_Vision_V5.1_noVAE

How Long Does It Take?

On Raspberry Pi 5 (8GB):

Image Size	Inference Time
256x256	~2-4 minutes
512x512	~7-12 minutes

⚠️ Do not expect desktop GPU speeds — but for low-volume, offline creative projects, it's functional.

Optional: Serve as a Web App with Gradio

pip install gradio

Add this to the script:

import gradio as gr

def generate(prompt):
    image = pipeline(prompt).images[0]
    return image

gr.Interface(fn=generate, inputs="text", outputs="image").launch()

Access locally via http://localhost:7860

Example Output

Prompt	Result
“A medieval knight riding a dragon through the clouds”	️
“A serene lake in the forest during sunset, ultra-realistic”	️

(You can host real examples or dummy images later on your blog)

Summary

You’ve now turned your Raspberry Pi 5 into a local AI image generator using Stable Diffusion. While it’s not lightning-fast, it’s fully offline, works with open-source tools, and gives you creative freedom at the edge.

Image Caption Generator using BLIP + PiCamera on Raspberry Pi

Sun, 20 Jul 2025 11:21:30 +0000

️ Image Caption Generator using BLIP + PiCamera on Raspberry Pi

Turn your Raspberry Pi into a smart image captioning device using BLIP, an AI model that generates natural language descriptions of images.

Overview

In this project, you will:

Capture images using the PiCamera
Use the BLIP (Bootstrapped Language Image Pretraining) model to generate captions
Display or store the generated captions
Optionally build a simple web interface with Gradio

This project works best with Raspberry Pi 4 or 5 and requires an internet connection (for downloading models or using APIs).

Requirements

Raspberry Pi 4 or 5 (Pi 3 will struggle with BLIP model inference)
Raspberry Pi OS 64-bit (updated)
PiCamera or USB camera
Python 3.9+
pip and virtualenv
Git

Step 1: Install System Dependencies

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv libjpeg-dev libopenjp2-7-dev

Step 2: Set Up Python Environment

mkdir ~/blip-caption
cd ~/blip-caption
python3 -m venv venv
source venv/bin/activate
pip install torch torchvision

Step 3: Install HuggingFace Transformers and BLIP

pip install transformers timm pillow

Step 4: Capture Image with PiCamera

If you're using the legacy PiCamera:

pip install picamera

And use this code to capture an image:

from picamera import PiCamera
from time import sleep

camera = PiCamera()
camera.start_preview()
sleep(2)
camera.capture('image.jpg')
camera.stop_preview()

For USB camera, use OpenCV:

pip install opencv-python

import cv2
cap = cv2.VideoCapture(0)
ret, frame = cap.read()
cv2.imwrite('image.jpg', frame)
cap.release()

Step 5: Generate Caption Using BLIP

from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import torch

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

raw_image = Image.open("image.jpg").convert('RGB')
inputs = processor(raw_image, return_tensors="pt")
out = model.generate(**inputs)
caption = processor.decode(out[0], skip_special_tokens=True)
print("Caption:", caption)

Optional: Add Gradio Interface

pip install gradio

import gradio as gr

def caption_image(image):
    inputs = processor(image, return_tensors="pt")
    out = model.generate(**inputs)
    return processor.decode(out[0], skip_special_tokens=True)

gr.Interface(fn=caption_image, inputs="image", outputs="text").launch()

✅ Conclusion

You've built a working image caption generator using Raspberry Pi, PiCamera, and the BLIP AI model. You can now:

Add automatic uploads or email integration
Extend it into a surveillance or accessibility tool
Use it in photo archiving projects

Build an AI Resume / CV Generator on Raspberry Pi

Sat, 19 Jul 2025 19:59:30 +0000

One of the most requested AI tools today is an automatic CV or Resume Generator powered by language models. In this guide, we'll show you how to build one on a Raspberry Pi 4 using Python and Open Source models. This lightweight solution doesn't require paid API keys, and it can be deployed as a local or web-based app.

Requirements

Raspberry Pi 4 (4GB or 8GB RAM recommended)
Raspberry Pi OS (Bookworm or Bullseye)
Python 3.9+
pip (Python package manager)
Basic knowledge of Python and command line
(Optional) Flask or Gradio for Web Interface

Step 1: Update and Prepare Your Pi

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip git

Step 2: Create Project Directory

mkdir ~/cv_generator && cd ~/cv_generator
python3 -m venv venv
source venv/bin/activate

Step 3: Install Required Libraries

pip install transformers gradio torch

On Raspberry Pi 4, Torch may take a while to install. Use pip install torch==1.13.1 if you face version issues.

Step 4: Choose a Small Language Model

We'll use the lightweight distilGPT2 to generate CV content.

from transformers import pipeline

generator = pipeline("text-generation", model="distilgpt2")

def generate_cv(name, job_title):
    prompt = f"Create a professional resume for {name}, applying for a {job_title} position."
    result = generator(prompt, max_length=300, num_return_sequences=1)
    return result[0]['generated_text']

Step 5: Add Gradio Interface

import gradio as gr

def run_cv_gen(name, job):
    return generate_cv(name, job)

gr.Interface(fn=run_cv_gen,
             inputs=["text", "text"],
             outputs="text",
             title="AI CV Generator on Pi",
             description="Enter your name and job title to generate a sample CV.").launch()

Step 6: Run the App

python3 app.py

Open your browser at http://localhost:7860

Step 7: Optional - Make It Public

Use ngrok or localtunnel to share your local Pi app with the world.

Example with localtunnel:

npx localtunnel --port 7860

Final Tips

You can replace distilgpt2 with any other small language model for more detailed results.
Add a "Download as PDF" button using pdfkit or reportlab for resume export.
Consider adding language selection for multi-lingual CVs.

Future Enhancements

Add support for uploading an existing resume and improving it
Integrate with job boards or LinkedIn scraping
Add image/logo or AI-generated portrait with Stable Diffusion

Run Whisper Speech-to-Text on Raspberry Pi 5

Sat, 19 Jul 2025 14:54:30 +0000

How to Run Whisper AI Speech-to-Text on Raspberry Pi 5 (Offline)

Contents:

✅ What is Whisper?
✅ How it works on Raspberry Pi 5
✅ Step-by-step installation
✅ Record your voice
✅ Transcribe with Whisper
✅ Optimization tips
✅ Test result

What is Whisper?

Whisper is a powerful AI model for converting speech to text, created by OpenAI. It supports over 90 languages and can work entirely offline thanks to whisper.cpp – a C/C++ port of the original model optimized for low-resource devices like Raspberry Pi.

Requirements

Component	Recommended
Raspberry Pi 5	4GB or 8GB RAM ✅
Microphone	USB or 3.5mm Jack
OS	Raspberry Pi OS 64-bit
Internet	Only during installation

Step 1: Install Dependencies

sudo apt update
sudo apt install git build-essential cmake python3-pip portaudio19-dev ffmpeg -y

Clone and build whisper.cpp:

git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make

Step 2: Download the tiny.en model (~75MB)

./models/download-ggml-model.sh tiny.en

This is the fastest and most suitable model for Raspberry Pi 5.

️ Step 3: Record 10 seconds of audio

Use arecord:

arecord -D plughw:1,0 -f cd -t wav -d 10 -r 16000 test.wav

To find your device name:

arecord -l

Step 4: Transcribe the audio with Whisper

./main -m models/ggml-tiny.en.bin -f test.wav -otxt

This will produce test.wav.txt containing the recognized speech.

Tips for Better Performance

Always use tiny.en model for speed
Disable GUI / run in CLI mode (raspi-config → Boot to CLI)
Use class 10 U3 microSD or USB SSD for better I/O

Example Result

[00:00:00.000 --> 00:00:05.000] Hello, this is a test of the Whisper AI on Raspberry Pi 5.

Support the Project

<a href="https://ko-fi.com/askyai" target="_blank">
  ☕ Support this tutorial on Ko-fi
</a>