Hardware components | ||||||
 |
| × | 1 | |||
From monitoring microclimates for a garden to gathering data for a school project, a custom weather station is a perfect introduction to the world of physical computing. In this guide, I'll show you how I built my own powerful weather monitoring system by connecting the Lark Weather Station to a LattePanda IOTA single-board computer via UART. We'll also use Python to collect and plot the data; all neatly housed in a custom 3D-printed enclosure from JUSTWAY.
🧱 The Core ComponentsThis project brings together three key pieces of technology, each chosen for its power and ease of use.
1. LattePanda IOTA: The Intelligent BrainThe LattePanda IOTA is a remarkable single-board computer. Inside its tiny 88 x 70 mm frame is a modern Intel Processor N150, a quad-core chip that can reach up to 3.60 GHz. This is a significant jump from older SBCs, providing more than enough power to handle everything from data logging to running graphical interfaces. It's available with either 8 GB or 16 GB of fast LPDDR5 RAM with error correction (ECC) and 64 GB or 128 GB of built-in eMMC storage.
What truly makes the IOTA special, though, is its secret weapon: a co-processor. LattePanda integrated the Raspberry Pi RP2040 dual-core Arm Cortex-M0+ microcontroller directly onto the board.
This allows for real-time handling of GPIO pins, motors, and sensors, making it incredibly responsive for data acquisition. Plus, with support for Windows 11 and Ubuntu Linux, you can develop in whatever environment you're most comfortable with.
Lark Weather Station: The Data GathererThe Lark Weather Station is an all-in-one educational toolkit. In a compact, portable design, it integrates sensors for wind speed, wind direction, temperature, humidity, and air pressure. Its built-in real-time clock (RTC) and a small USB flash drive (appearing as a 16M USB disk) allow it to operate as a standalone datalogger, or you can connect it to a computer to export data in CSV format for analysis in spreadsheets.
It supports two communication modes: I2C and the one we'll use, UART. Real-time data is output directly, including physical units like °C for temperature or hPa for pressure, which makes it incredibly easy to work with in code.
JUSTWAY 3D-Printed Enclosure: The Protective ShellA custom-made weather station demands a custom-made home. To protect all my hardware, I turned to JUSTWAY, a rapid prototyping and on-demand manufacturing service.
They specialize in high-quality 3D printing, capable of producing parts in over 100 different materials using technologies like FDM, SLA, SLS, MJF, and even SLM for metal.
Their online platform is incredibly straightforward—you simply upload your design files, choose your material and finish, and get an instant quote.
The result is a professional-grade enclosure that not only looks great but also provides essential protection for the electronics, giving the entire project a clean, polished, and finished look.
UART is the perfect choice for this application: it's simple to set up, reliable, and uses minimal pins. We're connecting the Lark Weather Station to the LattePanda IOTA. The IOTA's GPIO header, powered by the RP2040 co-processor, provides accessible UART pins for the connection.
Before we wire, we need to tell the Lark Weather Station to use UART. Connect it to your computer via its USB port, open the Config.txt file on the drive that appears, and change the first line from I2C to UART.
Once the configuration is saved, you can wire the two devices:
- Connect the Lark's
TX(Transmit) pin to the IOTA'sRX(Receive) pin. - Connect the Lark's
RXpin to the IOTA'sTXpin. - Connect the Ground (
GND) pins together.
With the hardware connected, we can turn to the software. The official driver library for Arduino provides an excellent reference for the command structure.
In Python, you can use a library like pyserial to read the data stream. The code is straightforward: you open the serial port (e.g., /dev/ttyS0 on Linux or COM3 on Windows), set the baud rate to 115200, and then read the lines of text being sent by the Lark.
Here's a Arduino snippet to get you started:
#include "DFRobot_LarkWeatherStation.h"
#include <SoftwareSerial.h>
SoftwareSerial mySerial(/*rx =*/5, /*tx =*/4);
DFRobot_LarkWeatherStation_UART atm(&mySerial);
void setup(void){
Serial.begin(115200);
mySerial.begin(115200);
delay(1000);
while(atm.begin()!= 0){
Serial.println("init error");
delay(1000);
}
Serial.println("init success");
}
void loop(void){
Serial.println(atm.getTimeStamp());
Serial.print(atm.getValue("Speed").toFloat());
Serial.println(atm.getUnit("Speed"));
Serial.println(atm.getValue("Dir"));
Serial.print(atm.getValue("Temp").toFloat());
Serial.println(atm.getUnit("Temp"));
Serial.print(atm.getValue("Humi").toFloat());
Serial.println(atm.getUnit("Humi"));
Serial.print(atm.getValue("Pressure").toFloat());
Serial.println(atm.getUnit("Pressure"));
Serial.println("----------------------------");
delay(1000);
}This basic script will display the raw data, which should look similar to the following example, printed once every second
19:04:38.765 -> ----------------------------
19:04:40.451 -> 2026_05_29_19:04:04
19:04:40.498 -> 0.40m/s
19:04:40.638 -> SE
19:04:40.779 -> 31.75C
19:04:40.921 -> 60.77%RH
19:04:41.108 -> 955.98hPa
19:04:41.203 -> ----------------------------With the data flowing, the real fun begins.
This is where the LattePanda IOTA's processing power shines. We'll build a Python script that logs the data into a structured CSV file and then creates a live-updating graphical dashboard using the powerful matplotlib library. Real-time graphs are perfect for comparing temperature and humidity trends or correlating wind speed with air pressure changes over a day.
import tkinter as tk
from tkinter import ttk
import serial, json, os
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from datetime import datetime
# --- Serial Connection ---
def connect_serial(port="COM6", baud=115200):
try:
ser = serial.Serial(port, baudrate=baud, timeout=1)
print(f"Connected to {port}")
return ser
except Exception as e:
print(f"Failed to connect: {e}")
return None
class WeatherDashboard:
def __init__(self, root, ser):
self.root = root
self.ser = ser
self.root.title("🌤 LARK Weather Station - Coimbatore")
self.root.geometry("1200x800")
self.root.configure(bg="#1e272e")
# Style
style = ttk.Style()
style.theme_use("clam")
style.configure("TLabel", background="#1e272e", foreground="white", font=("Arial", 14))
# CSV log
self.log_file = "weather_log.csv"
if not os.path.exists(self.log_file):
pd.DataFrame(columns=["timestamp","temperature","humidity","pressure","speed","direction"]).to_csv(self.log_file, index=False)
# Variables
self.temp_var = tk.StringVar(value="0.0°C")
self.humidity_var = tk.StringVar(value="0.0%")
self.pressure_var = tk.StringVar(value="0.0 hPa")
self.wind_speed_var = tk.StringVar(value="0.0 m/s")
self.wind_dir_var = tk.StringVar(value="N/A")
self.last_updated_var = tk.StringVar(value="Last updated: --:--:--")
# Header
header = tk.Label(root, text="🌤 LARK Weather Station Dashboard",
font=("Arial", 22, "bold"), bg="#0fbcf9", fg="white", pady=10)
header.pack(fill=tk.X)
# Metrics frame
metrics_frame = tk.Frame(root, bg="#1e272e")
metrics_frame.pack(fill=tk.X, pady=10)
self.create_metric(metrics_frame, "🌡 Temperature", self.temp_var, "#ff9f43", 0)
self.create_metric(metrics_frame, "💧 Humidity", self.humidity_var, "#48dbfb", 1)
self.create_metric(metrics_frame, "🌍 Pressure", self.pressure_var, "#1dd1a1", 2)
self.create_metric(metrics_frame, "🌬 Wind Speed", self.wind_speed_var, "#ff6b6b", 3)
self.create_metric(metrics_frame, "🧭 Wind Direction", self.wind_dir_var, "#f368e0", 4)
tk.Label(root, textvariable=self.last_updated_var,
font=("Arial", 14), bg="#1e272e", fg="white").pack(pady=10)
# Graphs
self.fig, self.axs = plt.subplots(2, 2, figsize=(10,6))
self.fig.patch.set_facecolor("#1e272e")
self.canvas = FigureCanvasTkAgg(self.fig, master=root)
self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
# Terminal section
terminal_frame = tk.LabelFrame(root, text="📟 Real-time JSON Stream",
font=("Arial", 14, "bold"), bg="#1e272e", fg="white")
terminal_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
self.terminal = tk.Text(terminal_frame, height=10, bg="#000000", fg="#00ff00",
font=("Consolas", 12), wrap="none")
self.terminal.pack(fill=tk.BOTH, expand=True)
# History
self.history = {"temperature":[], "humidity":[], "pressure":[], "speed":[]}
self.update_data()
def create_metric(self, parent, title, var, color, col):
frame = tk.LabelFrame(parent, text=title, font=("Arial", 14, "bold"),
bg="#1e272e", fg="white", padx=10, pady=10)
frame.grid(row=0, column=col, padx=10, pady=10)
tk.Label(frame, textvariable=var, font=("Arial", 24, "bold"),
bg="#1e272e", fg=color).pack(expand=True)
def update_data(self):
if self.ser and self.ser.in_waiting > 0:
line = self.ser.readline().decode("utf-8", errors="ignore").strip()
if line:
# Show raw JSON in terminal
self.terminal.insert(tk.END, line + "\n")
self.terminal.see(tk.END)
try:
data = json.loads(line)
# Update GUI
self.temp_var.set(f"{data['temperature']} {data['temp_unit']}")
self.humidity_var.set(f"{data['humidity']} {data['humi_unit']}")
self.pressure_var.set(f"{data['pressure']} {data['pressure_unit']}")
self.wind_speed_var.set(f"{data['speed']} {data['speed_unit']}")
self.wind_dir_var.set(data['direction'])
self.last_updated_var.set(f"Last updated: {datetime.now().strftime('%H:%M:%S')}")
# Log
entry = {
"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"temperature": data["temperature"],
"humidity": data["humidity"],
"pressure": data["pressure"],
"speed": data["speed"],
"direction": data["direction"]
}
pd.DataFrame([entry]).to_csv(self.log_file, mode="a", header=False, index=False)
# History
self.history["temperature"].append(data["temperature"])
self.history["humidity"].append(data["humidity"])
self.history["pressure"].append(data["pressure"])
self.history["speed"].append(data["speed"])
self.update_graphs()
except json.JSONDecodeError:
print("Invalid JSON:", line)
self.root.after(1000, self.update_data)
def update_graphs(self):
for ax in self.axs.flat:
ax.clear()
ax.set_facecolor("#1e272e")
ax.tick_params(colors="white", labelcolor="white")
ax.grid(True, linestyle="--", alpha=0.5)
if len(self.history["temperature"]) > 1:
x = range(len(self.history["temperature"]))
self.axs[0,0].plot(x, self.history["temperature"], color="#ff9f43", linewidth=2, antialiased=True)
self.axs[0,0].set_title("Temperature Trend", color="white")
self.axs[0,1].plot(x, self.history["humidity"], color="#48dbfb", linewidth=2, antialiased=True)
self.axs[0,1].set_title("Humidity Trend", color="white")
self.axs[1,0].plot(x, self.history["pressure"], color="#1dd1a1", linewidth=2, antialiased=True)
self.axs[1,0].set_title("Pressure Trend", color="white")
self.axs[1,1].plot(x, self.history["speed"], color="#ff6b6b", linewidth=2, antialiased=True)
self.axs[1,1].set_title("Wind Speed Trend", color="white")
self.fig.tight_layout()
self.canvas.draw()
self.fig.savefig("weather_snapshot.png")
# --- Run ---
if __name__ == "__main__":
ser = connect_serial("COM6", 115200)
root = tk.Tk()
app = WeatherDashboard(root, ser)
root.mainloop()The script can also save the graphs as images for later use in project documentation.
With the hardware and software working, it's time to find a safe home for your creation. After designing a simple enclosure in your favorite CAD software, you need a reliable way to manufacture it. This is where JUSTWAY excels.
My experience with their service was seamless. I uploaded my 3D model in a standard STL file, selected my material (a durable matte black PLA), and received an instant quote. Within a short time, I had a perfectly printed case in my hands. The fit and finish were exceptional—no sanding, no filing, no post-processing required. JUSTWAY's team even flagged a minor tolerance issue in my design before printing and suggested a correction, which saved me a lot of time and material.
Their services are a game-changer for makers, offering:
- Rapid Prototyping and Fast Turnaround: The entire process, from upload to product at your door, is incredibly fast.
- High Accuracy and Professional Finish: Their advanced printers produce parts with excellent detail and a clean finish, indistinguishable from injection-molded parts in many cases.
- Maker-Friendly Experience: The web platform has an intuitive, user-friendly interface. You get an instant quote, and an expert team is on hand to ensure your design is print-ready.
Whether you're a hobbyist working on a weekend project or a startup developing a new product, JUSTWAY provides the precision and professionalism needed to bring your ideas to life.
🎯 The Final BuildBuilding this weather station is an incredibly rewarding project. It's a fantastic demonstration of how modern SBCs like the LattePanda IOTA can be paired with robust sensors like the Lark Weather Station to gather real-world data. The Python integration adds a powerful layer for analysis and visualization, and the whole system can be given a professional, polished look with a custom 3D-printed enclosure from JUSTWAY. It's a complete journey from concept to a finished, functional product.
Are you working on a weather station or a similar data-logging project? I'd love to hear about your build—share your experiences and questions in the comments below
Comments