Forem: asim-builds

Building a Dumb Sensor Simulator in C (That Taught Me How I Took Python For Granted)

asim-builds — Mon, 14 Jul 2025 13:45:12 +0000

Ever since I have build hobby projects using Arduino, I have been fascinated by how embedded systems process real-world data in real time. Since I was interested in embedded systems, I picked up C and started to read theory. But learning by reading was just boring to me and most of the concepts went straight to my head. So I decided to do something practical: Do a mini project that I can talk about. So I decided to create a "sensor simulator". Here is my journey of the mini project, what I learned at each step, what was hard, and where I am taking it next!!

Phase 1: Basic Dumb Simulator

The first step was to simulate reading sensor data from a CSV file.
So I did the following:

Read sensor values from a CSV file.
Scaled the values to reflect real-world readings.
Stored the values in an array.
Calculated basic stats: average, min, max, and sum.
Printed alerts if any values crossed defined thresholds.

Key Learnings:

Basic file handling in C (using fopen, fscanf, etc.).
Using arrays and practicing both indexing and pointer arithmetic.
Implementing structs to represent sensor data and thresholds.

The hardest part here was switching from indexing (arr[i]) to pure pointer arithmetic (*(arr + i)). At first, it felt unintuitive, but after forcing myself to do it, I got a much better understanding of how memory works in C.

Phase 2: Real-Time Data Processing

Next, I wanted to make the simulator feel "alive" by processing data in real time. Here is what I did:

Implemented a loop that reads values every second (using sleep).
Continuously updated alerts and recalculated stats.
Allowed the user to change threshold values at runtime.

Key Learnings:

Simulating real-time behavior taught me about timing, delays, and how to keep a loop responsive.
Using structs to pass around stats instead of using many global variables.
Starting to modularize the code into functions and (later) separate files.

The biggest challenge here was avoiding to write everything in the main function. I had to force myself to split code into smaller, manageable chunks.

Phase 3: Control Logic & Event Simulation

The final phase was about making the simulator act like a simple control system. Here is what I did:

Added control outputs based on sensor data (e.g., turn on a "fan", "heater", or an "LED" — printed to console for now).
Added a switch-case menu for the user to choose between simulation, stats, or updating thresholds.

*What's next? *
While I was working through pointers, index arithmetic, and splitting code into multiple functions in C, I couldn’t help but think about how much easier all of this felt in Python.

When I was first learning Python, I thought lists, dictionaries, and their methods were hard. But now, I realize I hadn’t even scratched the surface.

Example:

In Python, to add an element to an existing list, I can simply do this:
my_list.append(42)

In C, I have to manually manage memory and handle resizing:

if (size == capacity) {
    capacity *= 2;
    arr = realloc(arr, capacity * sizeof(int));
}
arr[size++] = 42;

Working in C made me appreciate how many things Python quietly takes care of for us — dynamic arrays (lists), memory management, high-level abstractions.

This also led me to question something important:

Do I actually love embedded systems and low-level coding, or was it just the excitement of hobby projects (where I didn’t have to think too deeply about memory and pointers) that I enjoyed?

I think it’s good to ask this question now rather than blindly keep "learning C" just because it sounds cool or "hardcore."

So, my plan is to go one step further: I’ll dive head first into programming actual hardware (like microcontrollers), and see if I truly enjoy embedded systems when I get to interact with real-world components.

This isn’t just about syntax anymore — it’s about finding out what kind of work excites me most, what kind of bugs I can tolerate, and what challenges keep me coming back instead of burning me out.

I built a File Sharing App in Python (with Auto Discovery + Drag & Drop). Here is what I learned.

asim-builds — Sat, 07 Jun 2025 04:24:57 +0000

Hi everyone! 👋
I recently completed a weekend project: a Python-based file sharing app that works over local networks. I built it to deepen my understanding of networking and have a bit of fun with Python and its libraries (sockets). This post is a quick walkthrough of my project, what it can do, how I built it and what I learned in the process.

What the App Does
Here's a breakdown of the features:

Graphical Interface (Tkinter) -> Has one tab for sender and one tab for receiver.
Sender Side -> The sender side has the following features: Auto-discovers hosts on the local network, manual ip entry if preferred, port selection, drag and drop support, manual file browsing, and file integrity check using hash verification.
Receiver Side -> The receiver side has the following features: Choose listening port, selecting folder to save received files and start/stop receiving buttons.

This project uses socket, threading, tkinterdnd2, and a few other standard Python libraries - no external dependencies.

Why I built it?
Honestly? I had a free weekend and an immense desire to finally do something with Python and networking — not just read about it. In the past, I’d spend hours going through tutorials, blog posts, or watching videos, but I rarely built anything concrete. I’d get stuck in the cycle of consuming information without ever putting it into practice. I’ve had many project ideas over the years — cool concepts and fun challenges I wanted to build. But more often than not, the GitHub repos ended up empty or abandoned. Why? Because I got stuck in perfectionism. I wanted to do everything myself, from designing to coding to testing, without asking for help or using any shortcuts. I thought that was the only “right” way to learn and grow. But this mindset became a huge barrier.
It held me back from actually finishing projects and sharing my work. Instead of progress, I got stuck in endless tweaking, doubting, and self-criticism.

This time, I wanted to break that habit. I decided: No overthinking. No waiting for the "perfect" idea. Just build something practical that works.

I’ve always enjoyed working with Python — not because I want to be a full-time developer again, but because it’s flexible, elegant, and fun. I also wanted to understand how real-world networking worked under the hood — sockets, broadcasting, file streams, ports — all those concepts that I’d read about but never truly internalized.

So I picked a challenge that would combine both: a local file-sharing app. It was a perfect blend of GUI work, sockets, and system-level communication — and it gave me a tangible reason to dive into networking from a hands-on perspective.

It wasn’t always smooth sailing — I ran into weird VM issues, firewall rules, and networking quirks — but that was the whole point: to learn by doing. And I’m glad I did

What I learned?

Broadcasting can be tricky with VMs. I tested the code with my laptop and VM and learned that doesn't always work between VMs and host machines. I solved it by using custom broadcast ip (192.168.1.255) as a fallback mechanism.
Not everything works magically. It might work in test environment but when experimenting in real world, some things break, some policies are enforced and so on.
Using GitHub copilot helped speed things up, but I still had to debug, refactor, and stitch logic together across files.
To divide the apps into modules. Every project I did before had all the code in a single main.py file but this time I decided to break things up. I especially did this because there was one of my specific personal project whose debugging became a nightmare to me because all the code was piled into a single file.

🔗GitHub Repository
You can check out the full code here:

asim-builds / File-Share

A simple file share project using python

📁 Python File Share

A simple yet powerful peer-to-peer file sharing app built in Python! Works across devices on the same network.

Supports:

✅ One-to-one file transfers
✅ Auto host discovery
✅ Drag & Drop interface
✅ Multiple file transfers
✅ Transfer progress tracking
✅ File integrity check using SHA-256

🎯 Features

📤 Sender Tab
- Select files via file browser or drag & drop
- Enter host manually or use Auto Discover
- Custom destination filename
- Configurable port
📥 Receiver Tab
- Choose save location
- Start/Stop receiving with one click
- Set listening port
🔍 Host Discovery
- Scan and list available hosts on the network
📊 Transfer Progress
- Real-time file transfer status and logs
🔐 Integrity Check
- Uses SHA-256 to verify the file was transferred without corruption
📁 Multi-file Support
- Send multiple files in one go (automatically zipped)

📸 Screenshots

🚀 Getting Started

✅ Requirements

Python 3.7+
Cross-platform (Windows/Linux/macOS)
No internet connection required (runs…

View on GitHub

🧠Final Thoughts
I used to be scared of sharing my work - afraid of being judged, being seen or that my project wasn't good enough. But you know what? I had fun, I learned a lot and I am allowed to enjoy small victories even if its small. That's what matters. If you're learning Python or want to explore socket programming, I hope this inspires you to build something small and meaningful.
Let me know what you think - I'd love your feedback.

Photo Credits: Photo by Rubaitul Azad on Unsplash