Forem: Payam Hoseini

Agentic AI: A Complete Beginner's Guide

Payam Hoseini — Fri, 02 Jan 2026 14:45:27 +0000

In the world of AI, there are different kinds of AI. You've probably used ChatGPT or Gemini, they are in group of Generative AI's. It means that they generate a content, wether a simple answer of making a photo or gives you a website codes. But there's a new type of AI that's much more interesting in my opinion. It's called "Agentic AI," and it can actually do things for you, not just chat with you. It's an Agent ;)

In this guide, you'll learn what Agentic AI is and how to build your own simple AI agent, even if you've never written code before.

What is Agentic AI?

Think about the difference between asking a friend for advice versus hiring someone to do a job for you.

Regular AI: The Friend Who Gives Advice

When you use ChatGPT or a regular chatbot, it's like talking to a knowledgeable friend who reads many many books and can answer any questions that you may have. You ask questions, and it gives you answers. But that's where it stops. If you want to book a flight, it can tell you how to do it, but you still have to open the airline website and do all the clicking yourself.

Agentic AI: The Person Who Gets Things Done

Agentic AI is different. It's like hiring someone to actually do the work. You can say "Book me a flight to Tehran next week," and it will:

Figure out what information it needs
Ask you the right questions
Search for flights
Actually make the booking
Confirm everything with you

The key difference? Regular AI talks about doing things. Agentic AI actually does them.

What Makes Agentic AI Special?

Agentic AI has three superpowers that regular AI doesn't have:

1. It Can Think in Steps

Imagine you ask it to "plan a birthday party." A regular AI would just give you suggestions. But an Agentic AI breaks it down into steps:

First, I need to know the date and budget
Then I'll search for venues
Next, I'll look for caterers
Finally, I'll send out invitations

It creates a plan and follows it, just like a real person would.

2. It Can Use Tools

This is the game-changer. Agentic AI can connect to other software and websites to actually do things. How Agentic AI connects to other sites or tools? OfCourse, API. Agentic AI can:

Send emails through Gmail
Search the internet
Update spreadsheets
Book appointments
Make purchases
And much more

Without tools, AI is trapped inside a chat box like Generative AI's.

3. It Can Learn from Mistakes

When an Agentic AI tries something and it doesn't work, it notices. It thinks: "That didn't work. What went wrong? How can I do better next time?" Then it tries a different approach.

This is like when you learn to cook. The first time you burn the toast, you remember to watch it more carefully next time.

How to Build Your Own Simple AI Agent

Now for the exciting part of this blog post, I'll show you exactly how to create a simple AI agent that can actually do something useful. We'll build a Weather Assistant that not only tells you the weather but can also send you a text message if it's going to rain.

What You'll Need

A computer (Windows, Mac, or Linux)
Claude or ChatGPT account (the free version works)
About 30 minutes of your time

Don't worry, It's not complicated at all, as i said, only 30 minutes it takes.

Step 1: Choose What Your AI Agent Will Do

First, decide on a simple task. For this guide, i'll create an AI agent that:

Checks the weather for your city
Tells you if you need an umbrella
Can send you a reminder if rain is coming

This is simple but useful, and you'll understand all the concepts.

Step 2: Set Up Your AI Agent (Using Claude)

Open Claude (at claude.ai) and give it these instructions. Copy and paste this:

You are a Weather Assistant AI agent. Your job is to help people prepare for the weather.

You have access to these tools:
1. check_weather(city) - Gets current weather for a city
2. send_reminder(message) - Sends a text reminder to the user

When someone asks about the weather:
- Use check_weather to get current conditions
- Tell them the temperature and conditions
- If it's going to rain, ask if they want a reminder
- If they say yes, use send_reminder to send them a message

Always be helpful and proactive. If you see rain in the forecast, suggest they bring an umbrella.

This is called a "system prompt." It tells the AI what its job is and what tools it can use.

Step 3: Create the Tools (The Easy Way)

Now we need to connect real tools to your AI. Here's the beginner-friendly way:

For the Weather Tool:

Go to weatherapi.com and sign up for a free account
You'll get an "API key" (it's like a password that lets your AI get weather data)
Use a service like Make.com or Zapier (both have free plans) to connect the weather API

For the Reminder Tool:

Use a service like Twilio (free tier available) or IFTTT
Set it up to send you a text message when triggered

If this sounds complicated, don't worry! There's an even easier way which i used a lot:

Use Claude with the Anthropic API (it has built-in tool calling)

Here's a complete example you can copy:

I want you to act as my weather agent.

When I ask about weather, follow these steps:
1. Ask me which city I want to check
2. Pretend to check the weather (in a real setup, you'd use weatherapi.com)
3. Tell me the conditions
4. If it might rain, offer to remind me

Let's start with a simulated version. I'll tell you to "check weather for London" and you'll simulate the process.

Step 4: Test Your Agent

Now talk to your AI agent like it's a real assistant:

You: "What's the weather like in London today?"

AI Agent: "Let me check that for you. [Uses weather tool] It's currently 15°C and cloudy in London. There's a 70% chance of rain this afternoon. Would you like me to send you a reminder to bring an umbrella?"

You: "Yes please"

AI Agent: "Done! I've set up a reminder that will text you at noon to bring your umbrella."

Step 5: Make It Real (Next Level)

Once you understand how it works, you can make it actually functional:

Sign up for API access to Claude or GPT-4 (costs a few dollars)
Use a no-code tool like Zapier or Make.com to connect:
- Weather API for real weather data
- SMS service for real text messages
Set up the workflow so when you message the AI, it triggers the actual tools

Many no-code platforms now have AI agent templates you can copy and customize.

Real Example Tools You Can Connect

Here are services that work with AI agents (most have free tiers):

Weather: OpenWeatherMap, WeatherAPI
Email: Gmail API, SendGrid
Calendar: Google Calendar, Outlook
Messages: Twilio, Telegram Bot API
Reminders: Todoist, IFTTT
Smart Home: Philips Hue, IFTTT

What Else Can You Build?

Once you understand the basics, you can create agents for almost anything:

Personal Assistant Agent

Checks your calendar
Reads your emails
Schedules meetings
Sets reminders

Shopping Agent

Monitors prices on websites
Notifies you of deals
Can add items to your cart
Tracks deliveries

Home Automation Agent

Controls smart lights
Adjusts thermostat
Locks doors
Monitors security cameras

Research Agent

Searches multiple websites
Summarizes articles
Saves interesting content
Creates reports

Alternate Solution

Ai world is growing so fast, each day i check news and i saw new tools in every sections. Recently i work with new tool, n8n (short for “node-to-node”) which is an open-source workflow automation tool that lets you connect apps, APIs, and services together without heavy coding—similar to Zapier or Make, but self-hosted and more flexible. In other word :
“When this happens → do that → then this other thing”

In previous example that i told you, you may have pay a little but for your personal use, n8n wont charge you anything. Here is a sample of n8n workflow:

Common Questions

Q: Do I need to know programming?
A: Not necessarily! Many no-code tools now let you build AI agents by connecting blocks together, like Lego. However, knowing basic programming helps you build more powerful agents.

Q: Is it expensive?
A: You can start completely free using Claude or ChatGPT directly. Building more advanced agents with APIs costs a few dollars per month. n8n is also open-source.

Q: Is it safe?
A: Start with simple, harmless tasks. Don't give your AI agent access to sensitive accounts (like your bank) until you really understand how it works. I am still using it under testing condition because i think we have to check it completely, maybe there were any security issues, but as i follow that, there is not any major problems till now.

Q: How long does it take to build one?
A: A simple agent like the weather assistant? About 30 minutes. A more complex personal assistant? Maybe a few hours to a day.

Your Next Steps

Ready to build your first AI agent? Here's what to do:

Start simple - Try the weather assistant example above
Experiment - Ask the AI to do different things and see how it responds
Add one tool - Connect a real API (weather is the easiest)
Share your results - Show friends and family what you built
Level up - Once comfortable, try connecting two or three tools together

Wrapping Up

Agentic AI is transforming how we interact with technology. Instead of being tools we use, AI agents are becoming digital helpers that work for us.

The best part? The technology is here now, and it's getting easier to use every day. You don't need a computer science degree to build useful AI agents. You just need curiosity to experiment.

Start small, learn by doing, and soon you'll have your own AI agent handling tasks for you while you focus on what matters most.

There is always a concern when people see these kind of improvements and technologies. Maybe you think Agentic Ai's are starting of replacing humans with computers and robots but i am not agree with this at all. In these kind of situations, i always think about Internet Taxi Systems like Uber. Years ago there is not any things like them and people raise their hands for Taxi drivers and they saw them and pick them up and takes them to their destinations. does that kind of Taxi cars and drivers are now jobless? Of course not, they improved themselves and now using Uber or other stuffs like that. What if a taxi driver stand in front of these change for example because they cant work with smartphones to install required apps? yes, they became jobless. So i think AI and it's relevant technologies like Agentic AI's will not make us jobless, we have to use that to make our life more easier.

So Your first agent is just one conversation away. What Agent you want to make for yourself?

Want To Be a Hacker? Getting Started with Ethical Hacking (TryHackMe Journey)

Payam Hoseini — Sat, 27 Dec 2025 16:37:37 +0000

Are you looking for an intro to world of CyberSecurity?
You want to become an ethical hacker? I get it.Like me, years ago.
The cybersecurity world looks intimidating from the outside, all those technical terms, endless tools, and complicated concepts. But here's the truth: you can start learning today, right now, without any prior experience.

Let me show you how TryHackMe makes this possible.

Why TryHackMe? Learn by Actually Doing It

There is a painful fact in this field, Most beginners fail because they read too much and practice too little.
Forget boring textbooks and endless theory. TryHackMe teaches you by letting you hack into real systems (legally, of course) in a safe environment. Think of it like a flight simulator for hackers, you get real experience without any real-world consequences.

The best part? You learn the exact same techniques that real hackers use. When you hear about big companies getting hacked on the news, TryHackMe often has challenges that let you recreate those exact attacks. That's powerful learning. Think of it like A hacking gym for beginners.No damage. No risk. Just learning.

What Are CTF Challenges?

CTF stands for "Capture the Flag." It's basically a hacking puzzle where you break into a system and find hidden "flags" (special text strings) to prove you completed the challenge, like Paintball game if you played ;)

Don't worry, you don't need to be an expert to start. CTFs are designed to teach you as you go. Here's what you'll learn:

Network Scanning: Finding what services are running on a target system
Web Hacking: Breaking into websites and web applications
Linux Skills: Mastering the command line (super important for hackers)
Problem-Solving: Thinking like an attacker to find weaknesses

Your Learning Path: Start Here

1. Create Your Free Account

TryHackMe has tons of free content. Seriously, over 500 free rooms (that's what they call challenges) that you can complete without paying anything.

Recommended paths for beginners:

Pre-Security Path: Start here if you're completely new
Penetration Tester Path: For learning offensive security
SOC Level 1 Path: If you want to work as a security analyst

2. Understanding the Interface

When you open a TryHackMe room, you'll see:

Questions to answer
A virtual machine you can deploy
Instructions and hints
A terminal right in your browser

3. Connect to the VPN

To hack the machines, you need to connect to TryHackMe's network using OpenVPN.

TryHackMe recently focus on their new feature which is AttackBox which runs a complete OS in a Pip view in browser to make it easier for you and get rid of connectiong via OpenVPN. you can also use that feature.

Let's Hack Something: Your First Challenge

Let me walk you through a beginner-friendly CTF called "Bounty Hacker" so you can see exactly what this looks like.

Step 1: Deploy the Machine and Scan It

First, you click "Start Machine" on TryHackMe. It gives you an IP address, let's say 10.81.174.194.

Now you scan it with Nmap to see what ports are open:

What this does:

nmap: The scanning tool
-sV: Detects what services/versions are running
The IP address: Your target

Step 2: Check Open Ports

As you may saw, there are ports open like 22 which belongs to ssh. Your real journey starts here. Each room has it's flag, for example, in a room you will see credentials for ssh so you can connect as a user to target device and your goal (flag) is to become root, means to gain system admin password.
You may ask how to get that valuable information? Yes it is complicated at begining but when you read room's instructions carefully and consider to the clues, you will find a way to find root password.

I remember in one of that rooms, at first i have to coonect to server via ssh, after that and using nmap, i found ftp port is open. Next i found that i can connect to ftp with it's default password (A common mistake that people do in real world a lot). So i can find a Text file that has information about other users, and with the help of a password cracking tool app which name is Hydra, I can finnaly found system admin password and login as root and capture that flag.

Pro Tips from Someone Who's Been There

It's Okay to Get Stuck

I'm going to be honest: you will get stuck. A lot. That's completely normal. When you do:

Read the hints on TryHackMe
Search for writeups (walkthroughs) online
Ask in the TryHackMe Discord

Important: Don't just copy answers. Read the walkthrough, understand WHY that command works, try it yourself, and learn the concept. That's how you grow.

When i stuck anywhere in all of my IT learning process, always i leave my sit and go somewhere else, like another room, then get relaxed and think again from start to that problem. I got the answer every time i use this simple trick, believe me ;)

Keep Track of Your Progress

TryHackMe has a cool leveling system. You start as a "Neophyte" and work your way up to "Titan" and beyond. It's gamified to keep you motivated.

Take Notes

Start a hacking journal. When you learn a new technique, write it down:

## Nmap Scanning

Basic scan: nmap -sV [target-ip]
Full scan: nmap -sC -sV -p- [target-ip]
UDP scan: nmap -sU [target-ip]

When to use: Always scan first to see what services are running

From Hobby to Career: SOC Analyst

If you want to turn this into a career, the SOC Level 1 path is your golden ticket. A SOC (Security Operations Center) Analyst is basically a digital security guard who:

Monitors network traffic for threats
Investigates security alerts
Responds to incidents
Creates reports

The job market is HOT right now. Companies are desperate for SOC Analysts because there aren't enough skilled people. After completing the SOC Level 1 path, you'll know How to analyze network traffic, SIEM tools (security monitoring platforms), Digital forensics and Phishing analysis.

Believe me if you do some stuff like this and prove to any employer that you have this kind of skills, you will be their top candidate.

What You Need to Get Started

Hardware:
A computer (doesn't need to be fancy), Internet connection and That's it!

Software:
TryHackMe account (free), OpenVPN (free), Optional: Kali Linux VM for practicing (free)

Money:
Start with free content, Premium is $13/month if you want access to everything. I dont buy Premium subscription in first 3 months of using.

Final Thoughts

Look, cybersecurity seems scary and complicated from the outside. But here's what I've learned: the best way to learn is to just start.

You don't need a computer science degree. You don't need to know everything about networking. You just need curiosity and persistence. I know peoples that even don't know what DNS or NAT is or what is diffrences between TCP or UDP but they started to DO and make experiences and in their experimenting, they learned all of that scary words in a very good way. Do not stuck in tutorial hell and do projects, even silly ones.

Create that free account. Open your terminal. Run that first Nmap scan. See what happens.

The cybersecurity community needs more people. We need fresh perspectives, different backgrounds, and new ways of thinking. That could be you.

Your hacking journey starts with a single command. Make today that day.

Ready to start? Head over to TryHackMe and create your free account. See you in the challenges!

Machine Learning for Everyone: A Book Review

Payam Hoseini — Wed, 24 Dec 2025 11:51:49 +0000

I attracted to this book when i read book preface first line which is:
Let’s start by telling the truth: machines don’t learn.

This book has been praised by top level managers of Amazon and LinkedIn so if you've been searching for a way to dive into the world of Machine Learning (ML) without getting lost in massive, complicated textbooks, I might have found your solution: The Hundred-Page Machine Learning Book by Andriy Burkov.

It's literally what it says, a simple guide, at around 100 pages (maybe a few more ;) ).I think fastest way to know what Machine Learning and maybe AI is. Experts rave about it, calling it a "great introduction" and praising how it cuts through the noise right from the start. If you're an engineer looking to put ML into your daily work without spending tons of time, this is for you. You definitely don't need a heavy background in high-level math or complex programming to understand it.

What's Inside This Little Book?

This book is a compact handbook on "how to do data science". It moves fast, covering everything from the basics to the really fancy stuff.

The Essential Basics

The book starts by breaking down what Machine Learning actually is. You learn about the main kinds of learning, like:

Supervised Learning: Where your data has labels, like training an email filter to tell the difference between "spam" and "not_spam". The goal is to build a model that predicts the label for new data.

Unsupervised Learning: Where your data doesn't have labels, and you try to find patterns, like grouping similar customers together (clustering).
Semi-Supervised Learning: Where you have a lot of unlabeled data and only a little bit of labeled data, hoping the extra unlabeled examples help you build a better model.

The Core Algorithms

You get to meet five fundamental algorithms used constantly in practice:

Linear Regression: Used for making predictions where the answer is a real number, like estimating a house price.
Logistic Regression: Don't let the name fool you—it's actually a classification algorithm, great for problems like deciding if something is "yes" or "no".
Support Vector Machine (SVM): This clever algorithm finds the best imaginary line (or plane) to separate different categories of examples with the largest possible space between them.
Decision Trees: This uses a tree structure to make decisions based on specific features.
k-Nearest Neighbors (kNN): This simple method keeps all training data and predicts a new example's label by looking at the majority vote of the examples closest to it.

Making It Work in Real Life

The book spends crucial time explaining the common pitfalls and how to actually apply these tools. You learn about Feature Engineering, which is the art of turning raw data (like customer activity logs) into useful numerical values (features) that the machine can use.

It tackles the problem of building a model that predicts your training data perfectly but fails miserably on new data—a problem called Overfitting. To stop overfitting, the book talks about techniques like Regularization, which makes the model simpler so it can generalize better.

There is also exaples of how mailing service find spam e-mails from other e-mails which i understood it well. And of course, since models aren't magic, it shows you how to test if your model is actually good using metrics like the Confusion Matrix, Accuracy, and Precision/Recall.

The Next Level

If you’re interested in the modern parts on ML, the book covers them too:

Neural Networks and Deep Learning: It explains the basic building blocks of neural networks (which are really just nested mathematical functions). Deep learning just means training networks with more than two hidden layers.
Advanced Structures: You’ll learn about Convolutional Neural Networks (CNNs), great for handling images, and Recurrent Neural Networks (RNNs) like Midjourney, used for working with sequences like text or speech.
Ensemble Learning: Ways to combine many simple, "weak" models (like shallow decision trees) into a "strong" meta-model, such as Random Forest and Gradient Boosting, which often achieve fantastic accuracy and honestly i cant undesrstand them till now ;)

Final Word

This book is distributed on a unique principle: Learn Machine Learning in a simple way. If you read it and found it helpful, you can deep dive to it if you want but for many regular persons who dont want to be a machine learning specialist, i think its more than enough. I think in our modern world this book is a Have To Read book.

Complete Guide to Run AI Models Locally, Even on Mid-Tier Laptop

Payam Hoseini — Sat, 20 Dec 2025 12:35:54 +0000

If you focus on companies that invest in AI a lot like Meta and OpenAI or Apple you will see every one of them point to solve a problem. I found Apple solution interesting more than other which is Running AI locally on your device. Why it matters? i want you to read this blog post of mine so you can run an AI model on your PC or Laptop even if it's not a high-end device.
If you are not a Geek, you may not know this that this problem was unthinkable just a few years ago and only powerful computers can do that but nowadays with the help of OpenSource communities, it's not a dream anymore.

In this guide, we’ll explore why running AI locally matters, what hardware and software you actually need in 2025, and walk through a simple, practical setup to get your first local model running today.
If you like it, please support me by reading my blog posts.

1. Why Run AI on Your Own Computer?

Running AI models locally offers too many benefits that may be a concern for you, let's get into that.

🔐 Full Privacy and Control

There is a famous meme on net: There is no Cloud, There is some one else computer

Why someone else see our chats, photos and everything else?

⚡ Instant Speed and Offline Access

Imagine your internet has much latency or weak upload speed to uploading your files and photos. What do you think about removing these kind of limitations?

An added bonus: local models work fully offline. No internet connection, no service outages, no rate limits.

💰 Long-Term Cost Savings

While there may be an upfront hardware investment, running models locally eliminates recurring API fees. You can perform unlimited inferences with no per-token or per-request cost, shifting expenses from ongoing operational fees to a predictable, one-time setup.For myself, No more Remaining token checking :))

2. What You’ll Need: Hardware

Years ago, AI scientist thinks that CPU is the main power we need for machine learning and AI but after testing and comparing, they found that
GPU (Graphics Processing Unit) is better and more efficient than CPU. GPUs excel at parallel processing, allowing them to handle thousands of operations simultaneously—something CPUs are not designed to do efficiently.

The VRAM Imperative

Video RAM (VRAM) is the single most important factor for running AI models locally.

Think of VRAM as the model’s workspace: if the model doesn’t fit, performance drops—or it won’t run at all. The amount of VRAM directly determines:

How large a model you can load
How fast inference will be
How stable long-running sessions are

For a smooth experience with modern models, 8–12 GB of VRAM is the practical minimum in 2025.

Quantization, What Is That?

Let's learn one of most important words in the AI world. Quantization is a clever technique that shrinks AI models so they can fit into smaller VRAM budgets.

Imagine a professional photographer’s massive, high-resolution RAW photo. It’s incredibly detailed—but too large to quickly share or view on a phone. By compressing it into a JPEG, the file becomes much smaller and faster to load. While a tiny amount of detail is lost, the image remains visually excellent and far more practical.

Quantization works the same way for AI models. It compresses them dramatically, making them usable on consumer hardware with minimal—and often imperceptible—quality loss.

Pro Tip: When browsing models on platforms like Hugging Face, look for files labeled GGUF. These are pre-quantized models designed to run efficiently with tools like LM Studio and Ollama.

When You Need CPU and RAM

If a model is too large to fit into VRAM—even after quantization—the system falls back to using system RAM and the CPU.

In these scenarios, raw GPU speed matters less than memory bandwidth and stability. Surprisingly, server-grade CPUs can outperform GPU-heavy setups for certain workflows.

A Note on Apple Silicon

Apple’s M-series chips use a unified memory architecture, allowing the CPU and GPU to share a single, high-bandwidth memory pool. This design effectively sidesteps traditional VRAM limits, making Apple Silicon machines surprisingly capable of running very large models—often beyond what similarly priced discrete GPUs can handle.

Hardware Recommendations at a Glance

B Means Billion

Model Size	Recommended Hardware
Smaller models (e.g. Llama 3 8B, Phi-3 Mini)	NVIDIA GPU with 8–12 GB VRAM and 16 GB system RAM
Larger models (70B+ parameters)	High-end GPU (24 GB+ VRAM), Apple Silicon Mac with 64 GB+ unified memory, or server-grade CPU with high-bandwidth RAM

3. The Toolkit: Essential Software and Apps

To bring local AI to life, you need two things:

A runner to load and interact with models
Acceleration software to make inference fast

3.1 Choosing Your “Runner”

Think of an AI model as a powerful engine. A runner is the car built around it—it lets you start the engine, steer it with prompts, and see the results.

While your choice may depend on hardware and experience level, these three tools dominate the local AI ecosystem in 2025.

Tool	Best For	Key Characteristics
LM Studio	Beginners & non-technical users	Polished GUI, built on `llama.cpp`, browse and download models inside the app, true “open and chat” experience
Ollama	Developers & tinkerers	Simple CLI, local API, easy automation, excellent performance—especially on Apple Silicon
llama.cpp	Power users	Upstream engine, fastest updates, maximum control and performance, requires compilation and CLI usage

3.2 Behind the Scenes: Acceleration Software

Your runner talks to the GPU through specialized acceleration frameworks:

NVIDIA GPUs: CUDA (the industry standard for AI acceleration)
Apple Silicon: Metal (deeply integrated into macOS)

You typically don’t need to install these manually—up-to-date graphics drivers handle everything.

4. Your First Local AI: Step-by-Step (with LM Studio)

In this section, we’ll use LM Studio, one of the easiest and most user-friendly tools for running AI models locally.

The best part? You don’t need a GPU. LM Studio works perfectly with CPU-only systems, and will automatically use your GPU if you have one.

Step 1: Download and Install LM Studio

Visit the official LM Studio website
Download the installer for Windows, macOS, or Linux
Install and launch the app — no command line required

LM Studio comes bundled with everything you need. No CUDA, no environment variables.

Step 2: Choose a Model

Once LM Studio is open:

Go to the Models tab
Browse or search for a model (for example: Phi-3 Mini, Llama 3 8B, or Mistral 7B)
Choose a GGUF version (these are optimized and quantized)
Click Download

💡 Tip: If your system has no GPU, start with smaller models (3B–8B). They run surprisingly well on modern CPUs.

You can also download your desired model from Huggingface site where is the Github of AI models.

Step 3: Run the Model (CPU or GPU)

After the download:

Open the Chat tab
Select your model
Click Load Model

LM Studio automatically detects your hardware:

If you have a compatible GPU, it will use it
If not, it runs entirely on CPU

No extra configuration needed.

You can now start chatting with your local AI — fully offline.

Performance Expectations (Be Realistic)

CPU-only: Slower responses, but totally usable for learning, writing, and experimentation
GPU available: Faster responses and smoother interaction
Apple Silicon: Excellent performance thanks to unified memory

The key takeaway: GPU is a performance upgrade, not a requirement. In my opinion, run a model with CPU is only for experimenting and learning. I Ran a small model with a 10th generation of Intel CPU and it takes a minute to write a paragragh with around 100 words.

5. Conclusion: Local AI Is for Everyone Now

Running AI locally is no longer an elite or expensive experiment.

Today, you can:

Run models without internet
Keep your data fully private
Avoid API limits and monthly fees
Start even with just a CPU

Tools like LM Studio have removed almost all friction. You don’t need to be a machine learning engineer, a Linux wizard, or own a high-end GPU.

If you have:

A laptop
Some free disk space
Curiosity

You’re ready.

Download a model. Run it locally.

And experience AI on your terms.

Try this process as soon as possible that you have around one hour free time, it's worth it.

I maked cover photo and hardwares photo of this blog post with the help of chatbot ;)

Free Up Storage on Linux: ncdu, APT Cleanup, Log Rotation, and Kernel Removal Explained

Payam Hoseini — Tue, 09 Dec 2025 12:34:36 +0000

When i have Windows on my PC, from time to time, because of my system becomes laggy, i go into drives and folders to find unused files and get rid of them and do some other stuffs to make more available space and improve my PC for a while but when i migrate to Linux, as there is no lag or crashes (at least like Windows), I forgot to remove unused data from my PC anymore, But let’s be real: over time, even the best systems accumulate digital clutter. We install software, forget about it, update our kernels, and suddenly, that smooth performance starts to feel a little sluggish, and your disk space notification pops up, demanding attention.

I was reading an article in Linux Magazine issue 297 about this problem, i found it useful but i think there are some lack of information there, so i decided to write a blog post about it and cover as muchas i can about this.

1. Finding The Storage Leech

Before deleting anything, you need to know where the junk is hiding. Running blind with the rm command is a recipe for disaster (trust me, you don't want to accidentally delete a folder a critical program needs!).

Meet Your New Best Friend: Ncdu

The best tool for this job isn't some complex script; it's ncdu (NCurses Disk Usage). It’s super user-friendly and gives you an interactive, real-time map of your disk space right in your terminal. They define theirselfs like this :

Ncdu is a disk usage analyzer with a text-mode user interface. It is designed to find space hogs on a remote server where you don’t have an entire graphical setup available, but it is a useful tool even on regular desktop systems. Ncdu aims to be fast, simple, easy to use, and should be able to run on any POSIX-like system.

To start hunting from your system's root directory (/), you'll need to install it first if you don't have it:

sudo apt install ncdu
sudo ncdu /

Once running, you can navigate folders like you're browsing files, instantly seeing which directories (like /var/log or a big ~/Downloads folder) are the heaviest.

Manual Hunting for Mega Files

If you prefer a direct listing of massive files (over 50MB) without the interactive interface, the find command is the best tool. This is particularly useful when accessing a server via SSH.

sudo find / -size +50M -type f -exec du -h {} \; | sort -n

2. APT : For Packages and Dependencies

The safest place to start cleaning is always with your package manager, APT, because it actually understands the structure of your system.

Removing Orphaned Dependencies

When you uninstall an app, sometimes its dependencies (packages it needed for installation) get left behind. These are called orphaned packages.

The autoremove command is brilliant because it finds these packages and safely removes them, making this command your first and most essential step for regular maintenance,.

sudo apt autoremove

Clearing Out the Downloaded Junk

Every time you install something, APT downloads the .deb file and put it away in a cache (/var/cache/apt/archives/). While handy for offline installs, this cache often just sits there taking up space for ever.

clean: This removes all downloaded package files. It frees up space but means you can't easily reinstall a package version offline,.
autoclean: This is the slightly gentler cousin; it only removes package files that are old and can no longer be downloaded, making them completely useless.

sudo apt clean

Purge (Handle with Care!)

If you want an application and its configuration files completely erased (like, gone forever, including files in /etc), you use purge. This is more aggressive than a standard remove.

Important Note: Only use purge if you are absolutely sure you never need those configurations again, especially for core system utilities. When i want to use Purge, always double check everything :)))

3. The Kernel :

Every time Ubuntu updates its kernel (the core of the OS), it typically keeps the old ones around as a backup—just in case the new one causes trouble. This is smart, but if you've done several updates, these kernels pile up, consuming gigabytes of space in /boot. For example, Kernel of Ubuntu 24 is around 1.5GB. Wowww

Always keep the currently running kernel plus at least one or two older, known working kernels.

Listing Your Kernels

First, let's see what you have installed. Look for the packages starting with linux-image and linux-headers,:

dpkg --list | egrep -i --color 'linux-image|linux-headers'

And check which one is currently running (don't delete this one!):

uname -r

How to Remove Them

While autoremove sometimes catches old kernels, the dedicated script purge-old-kernels is far more reliable and efficient for this specific task. You usually get this utility by installing the byobu package:

Install the Tool (if needed):
```
sudo apt install byobu
```
Run the Purge: (This example keeps the latest two kernels, removing all older ones)
```
sudo purge-old-kernels --keep 2
```

4. Calming Down Storage Filler, The Logs

Log files, usually tucked away in /var/log/, record everything your system does. They are vital for troubleshooting, but they grow continuously and, if unchecked, can strain your server resources and memory.

The Automated Log Boss: Logrotate

Luckily, Linux has a built-in superhero named Logrotate. This utility is pre-installed on Ubuntu and runs automatically (usually daily via a cron job or systemd timer).

Logrotate ensures logs are managed by either renaming or compressing files before they get too large, and it removes or archives the oldest logs to free up space,,. For example, logrotate often compresses files using gzip and limits the number of historical logs kept (like keeping only four weeks' worth of backlogs).

The Safe Manual Fix: Truncation

If you find a huge log file (like syslog) that's rapidly filling up because of a system bug, DO NOT delete it with rm,. If a program is actively writing to a log file, deleting it won't free up space until that program closes the file, which might not happen until reboot,.

The safe trick is to truncate (empty) the file while keeping the file itself intact:

# Example for the main system log
sudo truncate -s 0 /var/log/syslog

Systemd Journal Logs

For logs managed by systemd (which is standard on modern Ubuntu), you can use journalctl to limit their size (e.g., to a maximum of 300 megabytes),:

sudo journalctl --vacuum-size=300M

5. Home Cleanup

Finally, let's look in your personal space—your home directory (~).

The Cache (~/.cache/): Applications store temporary files and caches here, which can pile up,. It is generally safe to delete the *contents* of this folder, though expect some apps (like web browsers) to load slightly slower the first time afterward.
```
rm -rf ~/.cache/*
```
The Forgotten Folder (~/Downloads): This is the most common culprit for digital hoarding,. Use the file manager or terminal to check its size and delete large, forgotten ISOs or installer packages.
The Command Line Trash: If you use the graphical desktop environment, files you delete go to the Trash Bin (~/.local/share/Trash/). Make sure it's truly empty!
```
rm -rf ~/.local/share/Trash/*
```

🛠️ Terminal Command Cheat Sheet

Here are the key commands That i used for my Ubuntu system cleanup. Remember to use sudo where necessary and review any deletions before confirming! And as Michael Jackson said: Remember to always think twice.

Category	Goal	Command to Run
Analysis	Find Disk Hogs (Install & Run Interactive Tool)	`sudo apt install ncdu` then `sudo ncdu /`
Package Cleanup	Remove Unused Dependencies	`sudo apt autoremove --purge`
Package Cleanup	Clear Downloaded Package Cache	`sudo apt clean`
Kernel Cleanup	Install Kernel Management Tool	`sudo apt install byobu`
Kernel Cleanup	Remove Old Kernels (Keeps 2 latest versions)	`sudo purge-old-kernels --keep 2`
Log Management	Limit Systemd Journal Logs (e.g., 300M max)	`sudo journalctl --vacuum-size=300M`
Log Management	Safely Empty Large Active Log File	`sudo truncate -s 0 /var/log/syslog`
User Cleanup	Clear Application/Browser Caches	`rm -rf ~/.cache/*`
User Cleanup	Empty the Trash Bin	`rm -rf ~/.local/share/Trash/*`

I will appreciate if you see my other blog post Here.

DIY GPS Tracking with Arduino, SIM800L and Ublox Neo-6M

Payam Hoseini — Tue, 20 May 2025 14:49:26 +0000

After learning how to use sim800l module in my previous project, I decided to create a GPS tracker using the Arduino platform. This project combines a SIM800L module for communication and a Ublox Neo-6M GPS module for location tracking with help of satellites. Making this device is also easy as previous project, just instead of using led, i use a GPS module to get the location and a little changes in the sketch. I measured the current consumption of the device under load and its around 50mAh for sim800l module and 100mAh for gps module. In standby mode, it consumes around 20mAh. With a regular battery(18650 Battery 2500mAh), this device last for around 5 days without charging. As you may now, these kind of devices used in cars or similar places that they has another source of power that help this device battery to charge(Alternators). This device needs a lot of improvement specially in security aspects, but it is a good start for you to learn how to use sim800l module, Ublox GPS module and Arduino platform. This is also a practical DIY device that you may use it in your car or bike.

Features

Get GPS coordinates by sending an SMS command ("GPS") to the device
Receive a reply with latitude, longitude, satellite count, altitude, speed, and a Google Maps link
Works with standard Arduino boards (tested on Uno/Nano)
Includes sample wiring diagrams and photos

Ublox Neo-6M

The Ublox Neo-6M GPS module works by connecting to multiple satellites orbiting the Earth. It listens for signals from at least four satellites, each broadcasting precise timing and location data. By calculating the time it takes for these signals to reach the module, the Neo-6M determines its own position (latitude, longitude, and altitude) with high accuracy. The more satellites it connects to, the more reliable and accurate the location data becomes. This satellite-based triangulation allows the module to provide real-time navigation and tracking information, which it then sends to your microcontroller via a serial interface. For best results, the module should have a clear view of the sky to maximize satellite connections and minimize signal interference.

Hardware Required

Arduino Uno, Nano, or compatible board
SIM800L GSM module
Ublox Neo-6M GPS module
SIM card with SMS capability
Jumper wires and breadboard or PCB
Power supply (ensure enough current for SIM800L)

Hardware Pinout

SIM800L

Ublox Neo-6M

Circuit Wiring

Wiring Diagram

This is wiring diagram which i make it in Fritzing. Please consider that i used a 18650 battery for SIM800l (as it is sensitive to power for working stable) and 5V pin of Arduino for GPS module.

My Wiring

This is my circuit, pardon me if it's don't look nice. As this device is in experimental phase, i used usb cable to power up Arduino Uno but in production, we can use our battery with a regulator to increase it to 5 volt.

Sketch

This is the sketch that i uploaded to Arduino board. Please attention that this is a starting point for making a GPS tracking system and needs a lot of improvement but don't worry, this device do it's job fine ;)

#include <SoftwareSerial.h>
#include <AltSoftSerial.h>
#include <TinyGPS++.h>

#define SIM800_RX_PIN 2
#define SIM800_TX_PIN 3

SoftwareSerial sim800(SIM800_TX_PIN, SIM800_RX_PIN);
AltSoftSerial gpsSerial;
TinyGPSPlus gps;

String sim800Buffer = "";
float latitude = 0.0;
float longitude = 0.0;
bool gpsDataValid = false;
unsigned long lastGpsDebugTime = 0;

void setup() {
  Serial.begin(9600);
  sim800.begin(9600);
  gpsSerial.begin(9600);
  delay(2000);

  Serial.println("Initializing SIM800L and GPS...");
  sendATCommand("AT", 1000);
  sendATCommand("AT+CMGF=1", 1000); // Text mode
  sendATCommand("AT+CNMI=1,2,0,0,0", 1000); // New message indications
  Serial.println("SIM800L and GPS Ready");
}

void loop() {
  // GPS Processing
  while (gpsSerial.available()) {
    char c = gpsSerial.read();
    gps.encode(c);
    if (gps.location.isValid()) {
      latitude = gps.location.lat();
      longitude = gps.location.lng();
      gpsDataValid = true;
    }
  }

  // Periodic debug output
  if (millis() - lastGpsDebugTime > 5000) {
    lastGpsDebugTime = millis();
    Serial.print("GPS Satellites: ");
    Serial.println(gps.satellites.value());
    Serial.print("GPS Data Valid: ");
    Serial.println(gpsDataValid ? "Yes" : "No");
    if (gpsDataValid) {
      Serial.print("Location: ");
      Serial.print(latitude, 6);
      Serial.print(", ");
      Serial.println(longitude, 6);
    }
  }

  // Read SIM800 data into buffer
  while (sim800.available()) {
    char c = sim800.read();
    sim800Buffer += c;
  }

  // Process SMS only when both header and content are present
  if (sim800Buffer.indexOf("+CMT:") != -1 && sim800Buffer.indexOf("\r\n", sim800Buffer.indexOf("+CMT:") + 6) != -1) {
    int headerEnd = sim800Buffer.indexOf("\r\n", sim800Buffer.indexOf("+CMT:") + 6);
    int msgStart = headerEnd + 2;
    int msgEnd = sim800Buffer.indexOf("\r\n", msgStart); // end of message text

    if (msgEnd != -1) {
      String header = sim800Buffer.substring(0, headerEnd);
      String sender = extractPhoneNumber(header);
      String msg = sim800Buffer.substring(msgStart, msgEnd);
      msg.trim();

      Serial.println("\n--- Incoming SMS ---");
      Serial.println("Sender: " + sender);
      Serial.println("Message: " + msg);

      if (msg.length() > 0 && (msg.indexOf("GPS") != -1 || msg.indexOf("gps") != -1)) {
        sendGPSLocation(sender);
      } else if (msg.length() > 0) {
        sendSMS(sender, "Send 'GPS' to receive location.");
      }

      sim800Buffer = ""; // clear buffer after processing
    }
  }

  // Manual test from Serial
  if (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');
    if (cmd.startsWith("SEND:")) {
      String num = cmd.substring(5);
      sendGPSLocation(num);
    } else {
      sim800.println(cmd);
    }
  }
}

String extractPhoneNumber(String header) {
  int firstQuote = header.indexOf('"');
  int secondQuote = header.indexOf('"', firstQuote + 1);
  if (firstQuote != -1 && secondQuote != -1) {
    return header.substring(firstQuote + 1, secondQuote);
  }
  return "";
}

void sendGPSLocation(String number) {
  String msg;

  if (gpsDataValid) {
    msg = "Location: " + String(latitude, 6) + ", " + String(longitude, 6);
    msg += "\nSatellites: " + String(gps.satellites.value());

    if (gps.altitude.isValid()) {
      msg += "\nAltitude: " + String(gps.altitude.meters(), 1) + " m";
    }

    if (gps.speed.isValid()) {
      msg += "\nSpeed: " + String(gps.speed.kmph(), 1) + " km/h";
    }

    if (gps.date.isValid() && gps.time.isValid()) {
      char dateTimeBuffer[30];
      sprintf(dateTimeBuffer, "\nTime: %02d:%02d, %02d-%02d-%04d",
              gps.time.hour(), gps.time.minute(),
              gps.date.day(), gps.date.month(), gps.date.year());
      msg += dateTimeBuffer;
    }

    msg += "\nhttps://maps.google.com/?q=" + String(latitude, 6) + "," + String(longitude, 6);
  } else {
    msg = "GPS not ready. Try again later.";
  }

  sendSMS(number, msg);
}


void sendSMS(String number, String message) {
  gpsSerial.end();
  delay(500);

  sim800.println("AT+CMGF=1");
  delay(1000);
  sim800.print("AT+CMGS=\"");
  sim800.print(number);
  sim800.println("\"");
  delay(1000);
  sim800.print(message);
  delay(500);
  sim800.write(26); // CTRL+Z
  delay(5000);

  Serial.println("SMS sent!");
  gpsSerial.begin(9600);
}

void sendATCommand(String cmd, int delayMs) {
  sim800.println(cmd);
  delay(delayMs);
  while (sim800.available()) {
    Serial.write(sim800.read());
  }
}

How this device Works

Power up the device with all modules connected as per the wiring diagram.
Send an SMS with the text GPS to the SIM card number in the SIM800L.
The device replies with the current GPS location and a Google Maps link.
You can also monitor serial output for debugging.

Current Usage

SIM800L

This is current usage of SIM800L while it's Ready for SMS :

While receiving SMS, maybe for a second, it goes up to around 120mAh and comes back to 50mAh.

Ublox Neo-6M and Arduino UNO

This is current usage for both Arduino UNO and Ublox Neo-6M while they are working :

As you see, it's around 0.11A which is 110mAh.
Consider that these numbers are for these modules when they are completely ON and Ready. All of these modules has standby mode which decrease their usage a lot.

Output Samples

First i connected this device to my laptop and check serial in Arduino IDE and this is device output :

After that i connected Arduino to a power bank and send a SMS to check it's functionality. I also send a wrong format of SMS to check device response.

Libraries Used

Notes

Make sure your SIM card has SMS credits and is unlocked.
The SIM800L is sensitive to power supply quality; use a stable 4V power source.
GPS fix may take a few minutes outdoors.

License

This project is open-source and free.

📧 Contact

Payam Hoseini - p.hoseini.ch@gmail.com
WebSite: [https://payamdev.com]

Project Link: https://github.com/payamhsn/Iot-ArduinoGpsTracker

If you have any ideas or improvement please comment it for me.
Made with ❤️ by Payam Hoseini.

DIY Local Wireless Control System With ESP8266 And Relay - No Internet Required

Payam Hoseini — Mon, 19 May 2025 17:56:56 +0000

I think this is one of the most important projects if you are interested in iot. This project connects an ESP8266 (D1 Mini) to a 5-pin relay module, creating a web server that hosts a control interface. I select ESP8266 for this project because of its WIFI and I used D1 mini because it is one of the best ESP8266 variant, it's compact and powerful enough and has many pins.
You can toggle the relay on/off from any device on your local network by accessing the ESP8266's IP address in a web browser. This is a simple and effective solution for controlling devices remotely using a web interface.
I use a transistor(2n2222) and a diod(1n4007) because my relay is 5 volt and d1 mini pins has around 3 volt output and i use transistor to be able to use 5 volt pin of d1 mini to trigger relay coil. ( If you have 3V relays, You only need to connect D1 mini and relay together )

✨ Features

🌐 Web-based control interface
💡 Real-time status updates
🔄 Automatic status refresh
📱 Mobile-friendly responsive design
🔌 Control any device connected to the relay
🏠 Works on your local network (no internet required)

🛠️ Hardware Requirements

ESP8266 D1 Mini (or any ESP8266-based board)
5V Relay Module
NPN Transistor (e.g., 2N2222)
1kΩ Resistor
Jumper Wires
Micro USB Cable
Power Supply (for the relay if needed)

📊 Circuit Diagram

My Wiring

🔧 Setup Instructions

Parts Pinout

5V Relay

2N2222 Transistor

1N4007 Diode

Hardware Setup

Connect the D1 pin of the ESP8266 to the base of the NPN transistor through a 1kΩ resistor
Connect the collector of the transistor to the control pin of the relay module
Connect the emitter of the transistor to ground
Connect the VCC of the relay module to the 5V output of the ESP8266 (or external power supply for larger relays)
Connect the GND of the relay module to the GND of the ESP8266

Sketch

Here is the sketch that you need to upload to your ESP8266 board :
( If you dont know how to upload this sketch to your board, After sketch there is a simple guide to install Arduino IDE and required packages for uploading it )

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ArduinoJson.h>

// WiFi credentials
const char* ssid = "YourWifiSSID";      // Replace with your WiFi name
const char* password = "YourWifiPassword";  // Replace with your WiFi password

// Pin definitions
const int relayPin = D1;  // D1 pin connected to transistor base via resistor

// Web server on port 80
ESP8266WebServer server(80);

// LED state
bool ledState = false;

void setup() {
  // Initialize serial communication
  Serial.begin(115200);

  // Set relay pin as output
  pinMode(relayPin, OUTPUT);

  // Initially turn off the relay
  digitalWrite(relayPin, LOW);

  // Connect to WiFi
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("Connected to WiFi. IP address: ");
  Serial.println(WiFi.localIP());

  // Define server routes
  server.on("/", handleRoot);
  server.on("/toggle", handleToggle);
  server.on("/status", handleStatus);
  server.onNotFound(handleNotFound);

  // Start the server
  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient();
}

// Handle root page
void handleRoot() {
  String html = R"(
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>LED Control</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            margin: 0;
            padding: 0;
            display: flex;
            justify-content: center;
            align-items: center;
            min-height: 100vh;
            background-color: #f5f5f5;
        }
        .container {
            background-color: white;
            border-radius: 10px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
            padding: 30px;
            text-align: center;
            max-width: 400px;
            width: 100%;
        }
        h1 {
            color: #333;
            margin-bottom: 30px;
        }
        .status {
            margin: 20px 0;
            font-size: 18px;
        }
        .switch {
            position: relative;
            display: inline-block;
            width: 60px;
            height: 34px;
            margin: 20px 0;
        }
        .switch input {
            opacity: 0;
            width: 0;
            height: 0;
        }
        .slider {
            position: absolute;
            cursor: pointer;
            top: 0;
            left: 0;
            right: 0;
            bottom: 0;
            background-color: #ccc;
            transition: .4s;
            border-radius: 34px;
        }
        .slider:before {
            position: absolute;
            content: "";
            height: 26px;
            width: 26px;
            left: 4px;
            bottom: 4px;
            background-color: white;
            transition: .4s;
            border-radius: 50%;
        }
        input:checked + .slider {
            background-color: #2196F3;
        }
        input:checked + .slider:before {
            transform: translateX(26px);
        }
        .led-icon {
            font-size: 48px;
            margin: 20px 0;
            transition: color 0.3s;
        }
        .led-off {
            color: #ccc;
        }
        .led-on {
            color: #ffcc00;
            text-shadow: 0 0 10px #ffcc00;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>LED Control Panel</h1>

        <div class="led-icon" id="ledIcon">💡</div>

        <div class="status">
            LED Status: <span id="ledStatus">OFF</span>
        </div>

        <label class="switch">
            <input type="checkbox" id="toggleSwitch">
            <span class="slider"></span>
        </label>

        <div>
            <p>IP Address: )" + WiFi.localIP().toString() + R"(</p>
        </div>
    </div>

    <script>
        const toggleSwitch = document.getElementById('toggleSwitch');
        const ledStatus = document.getElementById('ledStatus');
        const ledIcon = document.getElementById('ledIcon');

        // Get initial state
        fetchStatus();

        // Toggle switch event
        toggleSwitch.addEventListener('change', function() {
            fetch('/toggle')
            .then(response => response.json())
            .then(data => {
                updateUI(data.state);
            })
            .catch(error => console.error('Error:', error));
        });

        // Fetch current status
        function fetchStatus() {
            fetch('/status')
            .then(response => response.json())
            .then(data => {
                updateUI(data.state);
            })
            .catch(error => console.error('Error:', error));
        }

        // Update UI based on state
        function updateUI(state) {
            toggleSwitch.checked = state;
            ledStatus.textContent = state ? 'ON' : 'OFF';
            if (state) {
                ledIcon.classList.add('led-on');
                ledIcon.classList.remove('led-off');
            } else {
                ledIcon.classList.add('led-off');
                ledIcon.classList.remove('led-on');
            }
        }

        // Refresh status every 5 seconds
        setInterval(fetchStatus, 5000);
    </script>
</body>
</html>
  )";

  server.send(200, "text/html", html);
}

// Handle toggle request
void handleToggle() {
  ledState = !ledState;
  digitalWrite(relayPin, ledState ? HIGH : LOW);

  DynamicJsonDocument doc(64);
  doc["state"] = ledState;

  String response;
  serializeJson(doc, response);
  server.send(200, "application/json", response);
}

// Handle status request
void handleStatus() {
  DynamicJsonDocument doc(64);
  doc["state"] = ledState;

  String response;
  serializeJson(doc, response);
  server.send(200, "application/json", response);
}

// Handle 404 Not Found
void handleNotFound() {
  server.send(404, "text/plain", "Not Found");
}

Software Setup

Install the Arduino IDE from arduino.cc
Add ESP8266 board support:
- Open Arduino IDE
- Go to File > Preferences
- Add http://arduino.esp8266.com/stable/package_esp8266com_index.json to Additional Boards Manager URLs
- Go to Tools > Board > Boards Manager
- Search for ESP8266 and install
Install required libraries:
- Go to Sketch > Include Library > Manage Libraries
- Search for and install:
  - ESP8266WiFi
  - ESP8266WebServer
  - ArduinoJson
Open the sketch.ino file in Arduino IDE
Update the WiFi credentials:

   const char* ssid = "YourWifiSSID";      // Replace with your WiFi name
   const char* password = "YourWifiPassword";  // Replace with your WiFi password

Select your board (Tools > Board > ESP8266 Boards > LOLIN(WEMOS) D1 R2 & mini)
Select the correct port (Tools > Port)
Upload the sketch to your ESP8266

🚀 Usage

Power on your ESP8266
The device will connect to your WiFi network
Check the Serial Monitor (115200 baud) to see the assigned IP address
Open a web browser on any device connected to the same network
Enter the IP address in the address bar
Use the toggle switch on the web interface to control the relay

Sample of LED Control Panel

🔍 Troubleshooting

ESP8266 not connecting to WiFi: Double-check your WiFi credentials in the code
Relay not switching: Verify your wiring connections and ensure the transistor is properly connected
Cannot access web interface: Make sure your device is connected to the same network as the ESP8266
Relay switching erratically: Check for proper grounding and consider adding a flyback diode if not already included in your relay module

If there is any unknown problems, don't hesitate to contact me.

🛡️ Safety Warnings

This project involves working with electricity which can be dangerous
Never connect the relay to mains voltage without proper knowledge and safety precautions
Always disconnect power before making any changes to the circuit
Consider using an optocoupler for additional safety when working with higher voltages

📧 Contact

Payam Hoseini - p.hoseini.ch@gmail.com
WebSite: [https://payamdev.com]

Project Link: https://github.com/payamhsn/Iot-ESP8266andRelay

I wrote most of this blog post by myself and use chatgpt for some parts.
Made with ❤️ by [Payam Hoseini]

A Simple Guide To SIM800L: Control Your IoT Projects From Anywhere

Payam Hoseini — Mon, 19 May 2025 14:24:33 +0000

I think Sim800l is one of most valuable modules in IOT because in conditions that you don't have internet or WIFI, you can use it only with a sim card. Also its so cheap and it is so easy to run and use. In my experiments i found it so easy to start working and it only needs a good power source. based on data sheet it needs between 3.4 to 4.2 volt, but i found around 4.1 volt is good and it will has a stable connection without any problems. When you power up Sim800l, if you see led on module blinks every 1 seconds it mean connection has problem and i found in most of cases its because of power supply. when it blinks every 3 seconds, its ok and connected. I use a 18650 battery which has around 4.2 volt when it is fully charged. You can also use Li-Po batteries.
One of other benefits of Sim800l is its power usage which is very low and make it a good choice for portable devices. In sleep mode it only use 1 mAh and when it is under load for receiving SMS, it uses around 50 mAh. I calculated for a normal usage with a 5000 mAh battery, it last around 2 weeks.
In this blog at first we just power up Sim800l and show received SMS in terminal, next we add a feature to send back a confirmation SMS as a SMS arrived and in last step we control a simple led with a command that we will send it through our SMS. This project is a starting point for using Sim800l and in future i am going to make other projects with it and replace this simple led with other things like GPS module to make a Tracker Device.

Project Overview

This repository contains a step-by-step implementation of SMS-based control using the SIM800L GSM module. The project is divided into three main parts:

Basic SMS Reception - Setting up the SIM800L to receive and display SMS messages in the serial monitor
LED Control via SMS - Extending the basic setup to control an LED by sending "ON" or "OFF" text messages
SMS Reception and Confirmation - Like first part but it will sends back a confirmation SMS that your SMS delivered.

Perfect for IoT enthusiasts looking to add remote control capabilities to their projects without relying on WiFi or Bluetooth.

Hardware Requirements

Arduino UNO or compatible board
SIM800L GSM/GPRS module
SIM card with SMS capability (and some credit)
LED
220Ω resistor
Breadboard and jumper wires
Power supply (The SIM800L typically needs 3.7-4.2V)

SIM800l Pinout

Wiring Connections

SIM800L Pin	Arduino Pin
RX	D2
TX	D3
VCC	3.7-4.2V external supply
GND	GND

For the LED control project:

Connect LED anode (longer leg) to Arduino pin D8
Connect LED cathode (shorter leg) to a 220Ω resistor
Connect the other end of the resistor to GND

Wiring Connections Diagram Without LED

Wiring Connections Diagram With LED

My Wiring Connection (Sorry if it's not so nice)

Software Setup

Install the Arduino IDE if you haven't already
No additional libraries are required for this project
Upload the appropriate sketch to your Arduino:
- withoutLED.ino for basic SMS reception
- WithLED.ino for LED control via SMS
- WithoutLED&SendBackConfirm.ino for SMS reception and confirmation.

Project Progression

Part 1: Basic SMS Reception

The first sketch demonstrates how to:

Initialize the SIM800L module
Configure it to receive SMS messages
Display incoming messages in the serial monitor

This provides a foundation for understanding how to communicate with the SIM800L module.
Sketch:

#include <SoftwareSerial.h>

#define SIM800_RX_PIN 2
#define SIM800_TX_PIN 3
#define SIM800_RST_PIN 4  // Optional, can be used to reset the module

SoftwareSerial sim800(SIM800_TX_PIN, SIM800_RX_PIN); // RX, TX for Arduino

void setup() {
  Serial.begin(9600);
  sim800.begin(9600);
  delay(1000);

  Serial.println("Initializing SIM800L...");
  sim800.println("AT");
  delay(1000);
  sim800.println("AT+CMGF=1"); // Set SMS text mode
  delay(1000);
  sim800.println("AT+CNMI=1,2,0,0,0"); // Auto show SMS
  delay(1000);
}

void loop() {
  if (sim800.available()) {
    Serial.write(sim800.read());
  }
  if (Serial.available()) {
    sim800.write(Serial.read());
  }
}

Part 2: Adding SMS Confirmation

Building on the first part, this sketch adds:

Module sends back a confirmation that our SMS has been successfully received. Sketch:

#include <SoftwareSerial.h>

#define SIM800_RX_PIN 2
#define SIM800_TX_PIN 3
#define SIM800_RST_PIN 4  // Optional, can be used to reset the module

SoftwareSerial sim800(SIM800_TX_PIN, SIM800_RX_PIN); // RX, TX for Arduino

String incomingData = "";
bool messageReceived = false;
String senderNumber = "";

void setup() {
  Serial.begin(9600);
  sim800.begin(9600);
  delay(1000);

  Serial.println("Initializing SIM800L...");

  // Reset module if needed
  // pinMode(SIM800_RST_PIN, OUTPUT);
  // digitalWrite(SIM800_RST_PIN, LOW);
  // delay(1000);
  // digitalWrite(SIM800_RST_PIN, HIGH);
  // delay(3000);

  // Initialize module
  sendATCommand("AT", 1000);
  sendATCommand("AT+CMGF=1", 1000); // Set SMS text mode
  sendATCommand("AT+CNMI=1,2,0,0,0", 1000); // Configure SMS notification

  Serial.println("SIM800L Ready");
}

void loop() {
  // Check for incoming data from SIM800L
  while (sim800.available()) {
    char c = sim800.read();
    incomingData += c;
    Serial.write(c); // Echo to serial monitor
    delay(10);
  }

  // Process complete messages
  if (incomingData.length() > 0) {
    // Check if it's an SMS message notification
    if (incomingData.indexOf("+CMT:") != -1) {
      // Extract sender phone number
      int phoneStartIndex = incomingData.indexOf("+CMT: \"") + 7;
      int phoneEndIndex = incomingData.indexOf("\"", phoneStartIndex);

      if (phoneStartIndex > 7 && phoneEndIndex != -1) {
        senderNumber = incomingData.substring(phoneStartIndex, phoneEndIndex);
        Serial.print("Sender number: ");
        Serial.println(senderNumber);

        // Send reply SMS
        sendSMS(senderNumber, "Your SMS has been received. Thank you!");
      }
    }

    // Clear the buffer after processing
    incomingData = "";
  }

  // Handle commands from Serial monitor
  if (Serial.available()) {
    sim800.write(Serial.read());
  }
}

// Function to send AT commands
void sendATCommand(String command, int timeout) {
  sim800.println(command);
  delay(timeout);
  while (sim800.available()) {
    Serial.write(sim800.read());
  }
}

// Function to send SMS
void sendSMS(String number, String message) {
  Serial.println("Sending SMS reply...");

  sim800.println("AT+CMGF=1"); // Set SMS text mode
  delay(500);

  sim800.print("AT+CMGS=\"");
  sim800.print(number);
  sim800.println("\"");
  delay(500);

  sim800.print(message);
  delay(500);
  sim800.write(26); // ASCII code for CTRL+Z to send message

  delay(3000); // Wait for message to be sent

  Serial.println("SMS sent!");
}

Part 3: LED Control via SMS

Building on the first part, this sketch adds:

LED control functionality
SMS command parsing
Feedback through the serial monitor

Send "ON" or "OFF" in an SMS to the SIM card number to control the LED remotely.
Sketch:

#include <SoftwareSerial.h>

#define SIM800_RX_PIN 2
#define SIM800_TX_PIN 3
#define SIM800_RST_PIN 4  // Optional, not used here
#define LED_PIN 8        // Connect an LED to this pin

SoftwareSerial sim800(SIM800_TX_PIN, SIM800_RX_PIN); // RX, TX for Arduino

String incomingData = ""; // To hold incoming data from SIM800

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW); // Turn off LED initially

  Serial.begin(9600);
  sim800.begin(9600);
  delay(1000);

  Serial.println("Initializing SIM800L...");
  sim800.println("AT");
  delay(1000);
  sim800.println("AT+CMGF=1"); // Set SMS text mode
  delay(1000);
  sim800.println("AT+CNMI=1,2,0,0,0"); // Show SMS directly
  delay(1000);
}

void loop() {
  while (sim800.available()) {
    char c = sim800.read();
    Serial.write(c);
    incomingData += c;

    // Check for end of SMS
    if (c == '\n') {
      incomingData.trim(); // Remove extra spaces/newlines

      if (incomingData.indexOf("ON") != -1) {
        digitalWrite(LED_PIN, HIGH);
        Serial.println("LED turned ON");
      }
      else if (incomingData.indexOf("OFF") != -1) {
        digitalWrite(LED_PIN, LOW);
        Serial.println("LED turned OFF");
      }

      incomingData = ""; // Clear buffer for next message
    }
  }

  // Optional: forward Serial input to SIM800 for debugging
  while (Serial.available()) {
    sim800.write(Serial.read());
  }
}

Troubleshooting Tips

Power Issues: The SIM800L is sensitive to power fluctuations. Use a dedicated power supply capable of handling current spikes.
Network Registration: Make sure the SIM card is activated and has good signal strength.
AT Commands: If you're having trouble, try sending basic AT commands through the serial monitor to test communication.
Baud Rate: Ensure both the Arduino and SIM800L are communicating at the same baud rate (9600 in this project).

👉 You can find the full source code here:
GitHub Repo: payamhsn/Iot-Sim800l-Starter

At the end, i think this module is so valuable, because with this module and a relay which is a low cost setup, you can connect to any device with any voltage, from a Lamp to an Air condition systems and control them from anywhere that you are.
Thanks a lot for reading my blog. I wrote everything by myself and a little help of AI in making tables and some content. Love & Respect

LM35 vs BMP180: Comparing two budget temperature sensors

Payam Hoseini — Mon, 19 May 2025 11:43:56 +0000

A project comparing temperature accuracy between an LM35 analog sensor and a BMP180 barometric sensor, with pressure/altitude measurements.

Early Conclusion:

LM35 is more accurate for temperature.
BMP180 is not accurate as LM35 is, but provides pressure/altitude measurements. I've also tested DHT11 sensor previously and i can tell you that LM35 is so better and more accurate than DHT11, but if you want humidity beside temperature and price is not matter for your project, DHT22 is a better choice.

👉 You can find the full source code here:

GitHub Repo: payamhsn/Iot-LM35-vs-BMP180-Temp

🚀 Project Overview

This project compares:

LM35 (analog temperature sensor)
BMP180 (digital barometric sensor for temperature, pressure, and altitude)

Key Findings:

The LM35 is more accurate for temperature (~24.44°C vs room thermometer: 24°C).
The BMP180 reads slightly higher (~26.10°C) due to internal heat but provides useful pressure/altitude data.

🔍 How the Sensors Work

LM35 Temperature Sensor

Principle: Linear analog output (10mV/°C).
Accuracy: ±0.5°C at 25°C.
No calibration needed – directly outputs Celsius.
Formula: Temp (°C) = (ADC Reading × 500) / 1023
Pros: Simple, low-cost, reliable.
Cons: Only measures temperature.

BMP180 Barometric Sensor

Measures:
Temperature (°C)
Pressure (hPa)
Altitude (meters, derived from pressure)
Interface: I²C (SDA: A4, SCL: A5 on Arduino Uno).
How it calculates altitude: Altitude = 44330 × (1 − (P/P₀)^(1/5.255)) Where:
P = Measured pressure
P₀ = Sea-level pressure (1013.25 hPa default)
Pros: Multi-functional (pressure/altitude).
Cons: Temperature may drift due to internal heat.

🔧 Hardware Setup

BMP180 Pinout

LM35 Pinout

Wiring Diagram

Sensor	Arduino Uno Pin
LM35	A0 (Analog)
BMP180	I²C (SDA:A4, SCL:A5)

Circuit Setup:

LM35:
VCC → 5V
GND → GND
OUT → A0
BMP180:
VCC → 3.3V or 5V
GND → GND
SCL → A5
SDA → A4

My Wiring

💻 Code Explanation

The Arduino code:

Reads LM35 (analog voltage → temperature).
Reads BMP180 (temperature, pressure, altitude).
Calculates the difference between the two sensors.
Prints data to Serial Monitor every 10 seconds.

Key Libraries:

Wire.h (I²C communication)
Adafruit_BMP085.h (BMP180 sensor driver)

📊 Serial Monitor Output

Sensor Data:
LM35 Temperature: 24.44 °C
BMP180 Temperature: 26.10 °C
Temperature Difference (BMP-LM35): 1.66 °C
BMP180 Pressure: 879.85 hPa
BMP180 Altitude: 1174.28 meters

🔎 Observations & Analysis

Temperature Difference (1.66°C):
- BMP180 tends to read higher due to internal heat from pressure sensing.
- LM35 is more reliable for ambient temperature.
Pressure & Altitude:
- Lower pressure (879.85 hPa) indicates higher altitude (1174m).
- Useful for weather tracking or elevation-based projects.

After hours of running LM35, i found that its get more and more accurate comparing to my other pro sensor.

I wrote most of this blog by myself and a little help of AI. Thanks!