Published July 21, 2026 © MIT

Tamed (Modern Java in the Wild)

Tamed: a Particle P2 reads your environment, Java 26 decides what to do about it — real-time alerts before conditions turn on you.

AdvancedWork in progressOver 7 days40

Things used in this project

Hardware components

Particle Photon 2

USB Cable, USB Type C Plug

Seeed Studio Temp&Humi&Barometer Sensor (BME280)

Seeed Studio Grove - I2C UV Sensor (VEML6070)

ElectroPeak 0.96" OLED 64x128 Display Module

ProtoCentral Electronics ProtoCentral Pulse Oximeter & Heart Rate Sensor based on MAX30100

Software apps and online services

Microsoft Visual Studio Code Extension for Arduino

Particle Build Web IDE

solidworks

KiCad

Java 26

Hand tools and fabrication machines

Soldering iron (generic)

Solder Flux, Soldering

3D Printer (generic)

Laser cutter (generic)

Story

Why I chose a health solution

Health was the natural fit once I thought about what Tamed actually does. It's not managing a task or automating something at home — it's watching conditions while I'm out in them and telling me what to do about my own body before it becomes a problem. Heat, UV, humidity, all the stuff that creeps up on you outdoors without you noticing until you're already behind on it. That's a health problem, not a hobby or a home one.

The category description backs this up too — it's about quality of life during physical activity in the wild, which is exactly the space Tamed lives in.

Why this project fits the category

The alerts Tamed gives are things like "hydrate now" and "reapply sunscreen soon" — decision support aimed at my body, not at a task or a pastime. A hobby solution enhances something I'm doing for fun. A home solution solves a lifestyle problem while I'm sitting still. Tamed's whole job is to keep me okay while I'm moving through the wild, so health is the category that actually describes what it does, instead of me stretching the project to fit somewhere else.

Why I built Tamed

I spend a lot of time outside — hiking, working with plants, just being out in conditions I don't always think about until they've already gotten to me. Heat creeps up. UV builds without you noticing. By the time you feel it, you're already behind.

I didn't want another app that shows me a number and expects me to do the math myself. I wanted something that watches the wild for me and just tells me what to do about it — before it becomes a problem instead of after.

So I built a sensor pod on a Particle P2 that reads the environment in real time, streaming straight into a Java 26 app with zero cloud, zero network dependency — just a wire and some logic, running right there on my machine. Java 26's virtual threads and pattern matching aren't just buzzwords here, they're doing the actual work: reading a live stream of data and turning it into a plain-language heads-up the instant conditions cross a line.

That's the whole idea behind the name. The wild doesn't get less wild — I just get a little more prepared for it. Tamed.

Tamed — build plan

So the idea is: P2 reads sensors, talks to my Mac over USB serial, Java 26 does the thinking, JavaFX shows it on screen. No cloud, no LoRaWAN, just a wire and some logic.

First, bench setup. Wire the BME280 and VEML6075 to the P2 on I2C — SDA/SCL shared bus, different addresses so they don't collide. Power off 3V3, ground shared. If I keep the OLED from the last build, it goes on the same bus too, three devices total. Before writing anything real, flash quick throwaway firmware just to confirm I2C sees both sensors. Skipping this always costs me more time later than it saves now, so do it first.

Firmware. Get the P2 reading temp, humidity, and UV on a loop every second or two, and spit it out over Serial as one line: TEMP:24.3,HUM:41.2,UV:3.1. Mirror it to the OLED if I've got it wired. Test this with a plain serial monitor before Java touches it at all — I want clean lines scrolling by, because that exact format is the contract Java's going to parse against.

Prove the pipe in Java. Set up the Maven project, jSerialComm + JavaFX, Java 26 target. Write just the serial reader first — nothing else — and print raw lines to console. Plug in the P2, watch real numbers show up. That's the whole architecture validated end to end: sensor → firmware → USB → Java. Everything after this is just building on solid ground. Wrap each line into a SensorReading record, and run the listener on a virtual thread so it's not blocking the UI thread later.

The actual brains. This is what makes it more than a fancy serial monitor. Build ConditionScorer — sealed interface or enum for risk level (safe/caution/alert), pattern matching for switch to turn reading ranges into plain-language messages like "UV rising, reapply sunscreen soon" or "humidity dropping fast." Keep a small rolling window of recent readings so I can flag trends, not just static thresholds — trends read way better in a demo.

Dashboard, last. Once data and logic both work, build the JavaFX UI — live labels for each reading, a status banner that changes color based on risk level, maybe a line chart if I have time since it looks polished for basically no extra effort. Bind updates through Platform.runLater() since they're coming off a virtual thread.

Polish. Sync the OLED with the dashboard so there's two visible outputs during the demo. Write a short live demo script — plug in, watch it read, then trigger a threshold on purpose (breathe on the sensor or whatever) so judges see an alert fire live instead of just hearing about it. Drop a README calling out the Java 26 features explicitly — records, pattern matching, virtual threads — since that's what judges are scanning for.

If there's time left over: add the pulse sensor for a health angle, or get BLE working as a fallback. If I'm behind, that's the first stuff to cut — the core pipeline is the actual entry

Schematics

Code

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jamie</groupId>
    <artifactId>tamed</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>26</maven.compiler.source>
        <maven.compiler.target>26</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <javafx.version>26</javafx.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-controls</artifactId>
            <version>${javafx.version}</version>
        </dependency>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-fxml</artifactId>
            <version>${javafx.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fazecast</groupId>
            <artifactId>jSerialComm</artifactId>
            <version>2.11.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.openjfx</groupId>
                <artifactId>javafx-maven-plugin</artifactId>
                <version>0.0.8</version>
                <configuration>
                    <mainClass>com.jamie.tamed.App</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

package com.jamie.tamed.ui;

import com.jamie.tamed.model.ConditionScorer;
import com.jamie.tamed.model.ConditionScorer.Assessment;
import com.jamie.tamed.model.RiskLevel;
import com.jamie.tamed.model.SensorReading;
import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Region;
import javafx.scene.layout.VBox;

public class DashboardController {

    @FXML private Label connectionLabel;
    @FXML private VBox statusBanner;
    @FXML private Label statusTitle;
    @FXML private Label statusMessage;
    @FXML private Label tempLabel;
    @FXML private Label humidityLabel;
    @FXML private Label uvLabel;
    @FXML private HBox trendBars;

    private final ConditionScorer scorer = new ConditionScorer();

    @FXML
    public void initialize() {
        // Placeholder trend bars until real history is wired in
        for (int i = 0; i < 6; i++) {
            trendBars.getChildren().add(makeBar(20));
        }
    }

    public void setConnected(String portName) {
        Platform.runLater(() -> connectionLabel.setText("connected — " + portName));
    }

    // Called from the serial-reading virtual thread — always hop to the FX thread
    public void onReading(SensorReading reading) {
        Assessment assessment = scorer.score(reading);

        Platform.runLater(() -> {
            tempLabel.setText(String.format("%.1f°c", reading.tempC()));
            humidityLabel.setText(String.format("%.1f%%", reading.humidityPct()));
            uvLabel.setText(String.format("%.1f", reading.uvIndex()));

            applyRiskStyle(assessment.level());
            statusTitle.setText(assessment.level().label());
            statusMessage.setText(assessment.message());

            pushTrendBar(reading.uvIndex());
        });
    }

    private void applyRiskStyle(RiskLevel level) {
        String bg = switch (level) {
            case SAFE -> "#EAF3DE";
            case CAUTION -> "#FAECE7";
            case ALERT -> "#FCEBEB";
        };
        statusBanner.setStyle("-fx-background-color: " + bg + "; -fx-background-radius: 12; -fx-padding: 16;");
    }

    private void pushTrendBar(double uvIndex) {
        trendBars.getChildren().remove(0);
        double heightPx = Math.min(80, Math.max(8, uvIndex * 10));
        trendBars.getChildren().add(makeBar(heightPx));
    }

    private Region makeBar(double heightPx) {
        Region bar = new Region();
        bar.setPrefHeight(heightPx);
        bar.setStyle("-fx-background-color: #D85A30; -fx-background-radius: 2;");
        HBox.setHgrow(bar, javafx.scene.layout.Priority.ALWAYS);
        return bar;
    }
}

// tamed.ino
// Particle P2 firmware for the Tamed sensor pod.
// Reads temp/humidity (BME280) and UV index (VEML6075) over I2C,
// then streams one line per reading over USB serial in the format:
//   TEMP:24.3,HUM:41.2,UV:3.1
// The Java 26 app on the other end owns all decision logic — this
// firmware's only job is to read sensors and get the numbers out.

#include "Particle.h"
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <Adafruit_VEML6075.h>

// Optional on-device readout — comment out if you're not wiring up the OLED
#define USE_OLED
#ifdef USE_OLED
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);
#endif

SYSTEM_MODE(SEMI_AUTOMATIC);
SYSTEM_THREAD(ENABLED);

Adafruit_BME280 bme;
Adafruit_VEML6075 uv = Adafruit_VEML6075();

const unsigned long READ_INTERVAL_MS = 2000;
unsigned long lastReadMillis = 0;

void setup() {
    Serial.begin(9600);
    Wire.begin();

    if (!bme.begin(0x76)) {
        // Some breakouts default to 0x77 instead — try that if this fails
        Serial.println("ERR:BME280_NOT_FOUND");
    }

    if (!uv.begin()) {
        Serial.println("ERR:VEML6075_NOT_FOUND");
    }

#ifdef USE_OLED
    if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
        Serial.println("ERR:OLED_NOT_FOUND");
    } else {
        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(0, 0);
        display.println("tamed booting...");
        display.display();
    }
#endif
}

void loop() {
    unsigned long now = millis();
    if (now - lastReadMillis < READ_INTERVAL_MS) {
        return;
    }
    lastReadMillis = now;

    float tempC = bme.readTemperature();
    float humidityPct = bme.readHumidity();
    float uvIndex = uv.readUVI();

    // Serial payload — this exact format is the contract the Java side parses
    Serial.printlnf("TEMP:%.1f,HUM:%.1f,UV:%.1f", tempC, humidityPct, uvIndex);

#ifdef USE_OLED
    display.clearDisplay();
    display.setCursor(0, 0);
    display.printlnf("temp: %.1f C", tempC);
    display.printlnf("hum:  %.1f %%", humidityPct);
    display.printlnf("uv:   %.1f", uvIndex);
    display.display();
#endif
}

package com.jamie.tamed.model;

import java.time.Instant;

// One line off the wire, e.g. "TEMP:24.3,HUM:41.2,UV:3.1"
public record SensorReading(double tempC, double humidityPct, double uvIndex, Instant timestamp) {

    public static SensorReading parse(String line) {
        double temp = 0, hum = 0, uv = 0;
        for (String part : line.trim().split(",")) {
            String[] kv = part.split(":");
            if (kv.length != 2) continue;
            double value = Double.parseDouble(kv[1]);
            switch (kv[0]) {
                case "TEMP" -> temp = value;
                case "HUM" -> hum = value;
                case "UV" -> uv = value;
                default -> { /* ignore unknown fields */ }
            }
        }
        return new SensorReading(temp, hum, uv, Instant.now());
    }
}

package com.jamie.tamed.model;

import java.util.ArrayDeque;
import java.util.Deque;

// Keeps a rolling window of readings and turns the latest one into a RiskLevel + message.
// Thresholds below are placeholders — tune them once real sensor data is flowing.
public class ConditionScorer {

    private static final int WINDOW_SIZE = 10;
    private final Deque<SensorReading> recent = new ArrayDeque<>();

    public record Assessment(RiskLevel level, String message) {}

    public Assessment score(SensorReading reading) {
        recent.addLast(reading);
        if (recent.size() > WINDOW_SIZE) recent.removeFirst();

        RiskLevel level = switch (reading) {
            case SensorReading r when r.uvIndex() >= 6 -> RiskLevel.ALERT;
            case SensorReading r when r.uvIndex() >= 3 -> RiskLevel.CAUTION;
            case SensorReading r when r.tempC() >= 32 -> RiskLevel.ALERT;
            default -> RiskLevel.SAFE;
        };

        String message = switch (level) {
            case ALERT -> "UV or heat is high — seek shade and hydrate now";
            case CAUTION -> "UV rising — reapply sunscreen in about 15 min";
            case SAFE -> level.defaultMessage();
        };

        return new Assessment(level, message);
    }
}

package com.jamie.tamed.model;

public enum RiskLevel {
    SAFE("safe", "Conditions look good"),
    CAUTION("caution", "Worth keeping an eye on"),
    ALERT("alert", "Take action now");

    private final String label;
    private final String defaultMessage;

    RiskLevel(String label, String defaultMessage) {
        this.label = label;
        this.defaultMessage = defaultMessage;
    }

    public String label() {
        return label;
    }

    public String defaultMessage() {
        return defaultMessage;
    }
}

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.Insets?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.BorderPane?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.HBox?>
<?import javafx.scene.layout.Region?>
<?import javafx.scene.layout.VBox?>

<BorderPane xmlns="http://javafx.com/javafx"
            xmlns:fx="http://javafx.com/fxml"
            fx:controller="com.jamie.tamed.ui.DashboardController"
            style="-fx-background-color: white; -fx-padding: 20;">

    <top>
        <HBox alignment="CENTER_LEFT" spacing="8">
            <Label text="tamed" style="-fx-font-size: 18px; -fx-font-weight: bold;"/>
            <Region HBox.hgrow="ALWAYS"/>
            <Label fx:id="connectionLabel" text="connecting..." style="-fx-text-fill: gray;"/>
        </HBox>
    </top>

    <center>
        <VBox spacing="16">
            <padding>
                <Insets top="16"/>
            </padding>

            <!-- Status banner -->
            <VBox fx:id="statusBanner" spacing="4"
                  style="-fx-background-color: #FAECE7; -fx-background-radius: 12; -fx-padding: 16;">
                <Label fx:id="statusTitle" text="safe" style="-fx-font-size: 16px; -fx-font-weight: bold;"/>
                <Label fx:id="statusMessage" text="Waiting for readings..." style="-fx-font-size: 14px;"/>
            </VBox>

            <!-- Sensor readout cards -->
            <HBox spacing="12">
                <VBox styleClass="metric-card" style="-fx-background-color: #F1EFE8; -fx-background-radius: 8; -fx-padding: 16;" HBox.hgrow="ALWAYS">
                    <Label text="temp" style="-fx-text-fill: gray; -fx-font-size: 13px;"/>
                    <Label fx:id="tempLabel" text="--°c" style="-fx-font-size: 24px; -fx-font-weight: bold;"/>
                </VBox>
                <VBox style="-fx-background-color: #F1EFE8; -fx-background-radius: 8; -fx-padding: 16;" HBox.hgrow="ALWAYS">
                    <Label text="humidity" style="-fx-text-fill: gray; -fx-font-size: 13px;"/>
                    <Label fx:id="humidityLabel" text="--%" style="-fx-font-size: 24px; -fx-font-weight: bold;"/>
                </VBox>
                <VBox style="-fx-background-color: #F1EFE8; -fx-background-radius: 8; -fx-padding: 16;" HBox.hgrow="ALWAYS">
                    <Label text="uv index" style="-fx-text-fill: gray; -fx-font-size: 13px;"/>
                    <Label fx:id="uvLabel" text="--" style="-fx-font-size: 24px; -fx-font-weight: bold;"/>
                </VBox>
            </HBox>

            <!-- Trend area — swap for a real LineChart once data is flowing -->
            <VBox style="-fx-background-color: white; -fx-border-color: #ddd; -fx-border-radius: 12; -fx-background-radius: 12; -fx-padding: 16;">
                <Label text="last 5 minutes" style="-fx-text-fill: gray; -fx-font-size: 13px;"/>
                <HBox fx:id="trendBars" spacing="6" style="-fx-padding: 12 0 0 0;"/>
            </VBox>
        </VBox>
    </center>

</BorderPane>

package com.jamie.tamed.serial;

import com.fazecast.jSerialComm.SerialPort;
import com.jamie.tamed.model.SensorReading;
import com.jamie.tamed.ui.DashboardController;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class SerialReader {

    private static final int BAUD_RATE = 9600;

    private final DashboardController controller;
    private volatile boolean running = true;

    public SerialReader(DashboardController controller) {
        this.controller = controller;
    }

    // Prints available ports so you can find the right one — run this once to check.
    public static void listPorts() {
        for (SerialPort port : SerialPort.getCommPorts()) {
            System.out.println(port.getSystemPortName() + " — " + port.getDescriptivePortName());
        }
    }

    // Starts listening on a virtual thread; call once from App after the FXML loads.
    public void start(String portName) {
        Thread.ofVirtual().name("serial-reader").start(() -> readLoop(portName));
    }

    public void stop() {
        running = false;
    }

    private void readLoop(String portName) {
        SerialPort port = SerialPort.getCommPort(portName);
        port.setBaudRate(BAUD_RATE);
        port.setComPortTimeouts(SerialPort.TIMEOUT_READ_BLOCKING, 0, 0);

        if (!port.openPort()) {
            System.err.println("Could not open port: " + portName);
            return;
        }

        controller.setConnected(portName);

        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(port.getInputStream(), StandardCharsets.UTF_8))) {

            String line;
            while (running && (line = reader.readLine()) != null) {
                if (line.isBlank()) continue;
                try {
                    SensorReading reading = SensorReading.parse(line);
                    controller.onReading(reading);
                } catch (NumberFormatException e) {
                    // Malformed line off the wire — skip it rather than crashing the reader
                    System.err.println("Skipped bad line: " + line);
                }
            }
        } catch (IOException e) {
            System.err.println("Serial read error: " + e.getMessage());
        } finally {
            port.closePort();
        }
    }
}

package com.jamie.tamed;

import com.jamie.tamed.serial.SerialReader;
import com.jamie.tamed.ui.DashboardController;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class App extends Application {

    // Change this to match your P2's port. Run SerialReader.listPorts() from main()
    // below to find it — on macOS it looks like /dev/tty.usbmodemXXXX.
    private static final String PORT_NAME = "/dev/tty.usbmodem1101";

    @Override
    public void start(Stage stage) throws Exception {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/dashboard.fxml"));
        Parent root = loader.load();
        DashboardController controller = loader.getController();

        Scene scene = new Scene(root, 720, 480);
        stage.setTitle("tamed");
        stage.setScene(scene);
        stage.show();

        SerialReader serialReader = new SerialReader(controller);
        serialReader.start(PORT_NAME);
    }

    public static void main(String[] args) {
        // Uncomment to print available ports instead of launching the UI:
        // SerialReader.listPorts();
        launch(args);
    }
}

Credits

Jamie Dowden-Duarte

13 projects • 81 followers

Tamed (Modern Java in the Wild)

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Why I built Tamed

Tamed — build plan

Custom parts and enclosures

design breakdown

enclosure

Schematics

Schematic

Fritzing Circuit

Credits

Code

Pom

DashboardController

Tamedsensorpod

particle photon2 firmware

Sensorreading

ConditionScorer

Risklevel

Dashboard

Serialreader

App

Credits

Jamie Dowden-Duarte

Comments

Embed the widget on your own site

Tamed (Modern Java in the Wild)

Tamed (Modern Java in the Wild)

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Why I built Tamed

Tamed — build plan

Custom parts and enclosures

design breakdown

enclosure

Schematics

Schematic

Fritzing Circuit

Credits

Code

Pom

DashboardController

Tamedsensorpod

particle photon2 firmware

Sensorreading

ConditionScorer

Risklevel

Dashboard

Serialreader

App

Credits

Jamie Dowden-Duarte

Comments

Related channels and tags