ATLAS

Ultra-Fast Thermal Imager: 12.5Hz C++ Performance with Medical Detection

Demo video of my thermal imaging module achieving 8Hz sensor/12.5Hz display refresh rates (fall short with all the math in the background however very quick) - a complete rewrite from CircuitPython to C++. While CircuitPython was too slow for the frame rates I needed, the main driver for C++ was integration with my Talky voice interface system, which is C++ only.

Technical Achievements:

• Custom display driver: I couldn't get existing SSD1325 drivers to work properly and needed a fast version with true 4-bit grayscale support (0-15 levels), so I wrote my own
• Performance optimizations: Implemented lookup tables for 20x faster temperature conversion, sparse sampling algorithms, and anti-ghosting filters to handle the high refresh rates
• Silky smooth imaging: The combination of optimizations delivers fluid thermal visualization with excellent contrast

Medical Mode Intelligence: The system starts in standard thermal imaging, then auto-switches to medical mode after 30 seconds. In medical mode, it performs human skin detection and applies a 1.5°C offset to estimate core body temperature. This enables real-time classification of hypothermia, normal temperature, and various fever levels (low, moderate, high, critical).

C++ Integration Benefits: The C++ rewrite solved both the performance bottleneck and enables seamless integration with the Talky voice system. The low-level optimizations deliver the fluid performance you see in the demo.

This thermal module will be a key component in the complete Tricorder build, providing both standard imaging and medical-grade temperature screening.

Here's the thing: I really didn't want a separate chip for speech synthesis, and true TTS would be overkill for what I'm building. This uses an Arduino C++ library modified for the Pico, based on the original work by Peter Knight. It's honestly the coolest thing ever.

I spent about 8 hours on this - not really on the conversion itself, but because I initially tried (and failed) to create a phoneme-based true text-to-speech program for the Pico 2. After struggling with that approach, I stumbled upon Peter's library and thought "Perfect! Why shouldn't I have 1980s-style robotic voice on my 2025-era tricorder?"

I created a fun demo to show it off and will be posting the code to the open source GitHub. It has many words pre-loaded and does a nice little demo with the correct vintage lookup tables.

The Integration Challenge Here's the interesting part: I have the thermal imaging module working, but it's in CircuitPython while this Talkie code is C++ only. So I'll be doing what I needed to do anyway - converting all the code from CircuitPython to C++. This should make for a more stable device with higher performance as well.

Once that module is converted, I'll have a medical mode for the imager that will tell you exactly what temperature it sees (in Fahrenheit) and whether there's cause for concern. Yes - a real-life talking medical thermal scanning module.

Smart Voice Alerts I'm planning to expand the speech to other sensor data, but I'm limiting most voice alerts to real concerns like:

• "High level of radiation detected"
• "Storm approaching in 30 minutes, seek shelter"
• "One hour from sunset, time to make base camp"

The idea is ATLAS can stay in my backpack continuously scanning and only speak up when something important happens. I don't want it to be an annoying chatterbox.

Here's the demo of the talking code: Talkie_Med_Demo https://github.com/thedocdoc/AI-Field-Analyzer/tree/main

When testing ATLAS's medical thermal sensors, I needed reliable test subjects. Enter Walker, my big boned 27-pound French Bulldog who became my most cooperative beta tester, assuming every piece of technology pointed at him will eventually dispense treats.

Why Dogs Work for Medical Sensor Testing

Consistent Baselines: Dogs maintain steady core temps (38-39°C), perfect for calibrating thermal accuracy.

Real-World Movement: Unlike static human tests, Walker moves naturally while providing the added challenge of sudden "I'm going to investigate that interesting smell" mid-measurement redirections.

Fur Interface Testing: Measuring through fur validates readings through various surface materials - more forgiving than human hair but more challenging than bare skin.

Always Available: Walker never refuses a test session, mostly because he's convinced all technology is treat-adjacent.

The Species Calibration Discovery

Walker's perfectly normal 38.2°C triggered ATLAS's human fever alerts with impressive authority: "FEVER DETECTED - SEEK MEDICAL ATTENTION" to a completely healthy dog more concerned about pocket treats than his apparent medical emergency.

This demonstrated why medical devices need species-specific calibration. My tricorder proved somewhat judgmental about non-human physiology, turning a healthy Frenchie into a "fever patient." Walker showed admirable restraint by not seeking medical attention as instructed, instead continuing his rigorous testing regimen of lying on cool hardwood floors.

Walker: Science Hero

Through his tireless dedication to advancing portable medical technology, Walker has earned the distinguished title of Science Hero. His contributions to thermal imaging research, GPS anti-spoofing validation, and cross-species medical device testing have positioned him as a pioneer in the field. Few French Bulldogs can claim their thermal signature helped advance the future of environmental monitoring technology.

Research Benefits

Testing on a subject whose only feedback mechanisms are ear positioning, head tilts, and strategic repositioning taught me to design more intuitive sensing methods. Plus, demonstrating cross-species compatibility positions Walker as a pioneer in medical technology validation.

His post-testing recovery protocol involves complete hardwood floor sprawling until normal energy levels return (2-3 hours, depending on treat quality).

Walker may not understand thermal imaging specs, but he's contributed valuable data while maintaining his reputation as the most scientifically accomplished French Bulldog. Good science sometimes comes in furry packages that occasionally snore during data collection.

Walker was appropriately compensated and continues to eye the thermal sensor with what appears to be professional skepticism.

Latest field module just came together and it's pretty solid.

Added thermal imaging capability to the ATLAS system, real-time display, proper decimal temperature readings, CSV data capture, and some custom font work to make everything actually readable on the small screen.

This one was a grind, lots of custom code, hardware tweaks, and plenty of "why won't this buffer render correctly" debugging sessions.

What it does:

• Dual modes, with a medical screening mode: core body temp estimation, fever/hypothermia alerts
• Live 32x24 thermal imaging with display upscaling
• Real-time temperature stats (min/max/avg/center) with actual decimal precision
• Dual capture methods: physical button + REPL commands
• CSV export for data analysis
• Custom font implementation (Hyundai LED 6pt) with hybrid decimal rendering

On the source: This one's staying closed. It's been pretty R&D intensive and honestly, I'm keeping this module proprietary for now.

Happy to discuss the technical approach though—sensor integration, display optimization, UI design choices, whatever. Just not sharing the implementation.

More modules in the works. 

P.S. If you're working on something similar and want to compare notes, feel free to reach out. Always down to talk through the technical challenges.

Went ahead and got a detailed flow chart of the device

https://claude.ai/public/artifacts/a3a5fad0-66f7-4efc-97db-3304e1724863

and also took the most recent video.

Alright, friends. I’m winding down my public posting on ATLAS because I’m taking it into commercial territory (gotta pay the bills and fund version 3.0, right?). But I hate when cool projects vanish with nothing left for people to learn from, so here’s the deal:

I’ll be posting the current design files and a full block diagram for anyone who wants to build their own, learn, or just poke around under the hood. I want ATLAS to keep helping people—whether you’re an explorer, a hacker, or just someone who likes breaking things to see how they work. I will likely post a few more times on hardware/software. If someone is legit trying to build one I'm more than happy to steer you or answer any questions. 

https://github.com/thedocdoc/AI-Field-Analyzer/tree/main

Major Case Refinements:

After several iterations, my multi-sensor field device is really starting to take shape. This latest revision addresses ergonomics, component mounting, and adds some exciting new features.

Case Improvements:

I've made significant improvements to the case design. (v5?) The back now features diagonal grip stripes that provide much better handling. I increased the overall dimensions by about 10mm to accommodate new components, and tightened up the case tolerances significantly - no more rattling parts.

New Features Coming Together:

I've integrated the magnetic anemometer mounting, (wind sensor, will need to drill them out) designed for three cups connected to a bearing system with a 3x3x3mm magnet. The front panel now has a proper power LED and mounted switch, plus I've carved out dedicated space for a radiation sensor. (Menu. up, down, left, right, and enter)

The keypad layout shows the foundation for my menu system - just waiting on component availability to complete it.

AI-Powered Object Recognition:

I've added two spots for 5mm super-bright LEDs that will illuminate a 5MP camera running offline AI object recognition. The system can identify rocks, bugs, trees, and other objects entirely locally.

Vision: All-in-One Field Device:

I'm evolving this beyond weather monitoring into a comprehensive field instrument. My plans include a BNO085 9-axis IMU for compass functionality and anomaly detection, creating a navigation device with weather prediction and scientific measurement all rolled into one.

Still Major Work Ahead:

The display shows working sensor data, but I still have significant electronics development remaining:

• Custom Pico 2 PCB
• Custom sensor PCB
• BNO085 integration
• Anemometer completion
• Full keypad population

The case refinement is a big step forward, but I've still got plenty of work to get everything integrated properly.

Below the screen shows a rotating triangle in the top left that is a activity indicator that it is running. Nest you see CO2 and VOC readings, the temperature fusion readings and humidity. Also pressure at the bottom you will se the time based on satellite atomic clock and the GPS next to indicates that the IND or INDOORS as it recognizes it is indoor and adjust sensor polling  to reduce battery drain . After that the TF is temp fusion so 2 temp sensors. 

I realized the weather prediction model I was using wasn’t cutting it, it just looked at raw sensor trends and didn’t have any real context. Now, I’ve worked out a better way that’s still totally doable on a handheld device.

Here’s the new plan:
Instead of guessing based only on sensors, I’m building a folder of JSON or CSV files covering 3–5 years of weather data for all major US cities (plus a few international spots), including sunrise and sunset times. The handheld uses GPS to figure out where you are and picks the nearest city’s file. Then it compares live sensor readings to real historical patterns for your region and season, so if conditions match “classic cold front” or “afternoon thunderstorm,” it can actually say so, not just guess from the numbers.

Having sunrise and sunset in the mix is a game-changer too. The device will know exactly when it should be light or dark at your location, so it can spot clouds or weird events more reliably. If it’s supposed to be bright and it’s not, you know there’s real cloud cover or something interesting going on.

Another big plus:
It now gives you sunrise and sunset times accurate to 1-2 minutes, anywhere on Earth, based on GPS math. For expeditions and camping, that means you always know how much daylight you have left, no surprises when you need to set up camp or plan your day.

Why this is better:

• Storm warnings use real weather patterns, not just thresholds, accuracy goes way up.

• Fewer false alarms, smarter use of the light sensor.

• Works fully off-grid... no cell service needed, ever.

• Easy to update: just drop new pattern files onto the SD card for more cities.

Sample Code Snippets

Find the closest city:

def find_nearest_city(lat, lon, city_db):
    return min(city_db, key=lambda c: (lat-c['lat'])**2 + (lon-c['lon'])**2)


# Example usage:
city_db = [
    {'name': 'St. Louis', 'lat': 38.6270, 'lon': -90.1994},
    {'name': 'Chicago', 'lat': 41.8781, 'lon': -87.6298},
    # ... more cities ...
]
current_lat, current_lon = 38.62, -90.21
nearest = find_nearest_city(current_lat, current_lon, city_db)

 Get sunrise/sunset for your spot:

solar = SunriseSunsetCalculator()
solar.set_location(current_lat, current_lon, timezone_offset)
solar_times = solar.get_current_solar_times()
print(f"Sunrise: {solar_times['sunrise']}, Sunset: {solar_times['sunset']}")

So with just a handheld, you get real pattern-based storm warnings, context-aware daylight info, and pro-grade predictions—completely offline.

It’s basically a field meteorologist in your pocket.

As of today, the AI Field Analyzer finally fits inside its case. This marks the first full hardware integration milestone: all core sensors are live, the display is working, GPS is fused and parsed in real time, and the device is now portable and testable in real-world environments. That said, the case is still temporary. Most modules are loosely fitted, and I’ll need to create custom PCBs and proper mounts to secure things long-term. But this is a key checkpoint.. it’s no longer a dev board taped to a battery. It’s becoming a proper field tool.

I’ve also migrated everything to the Raspberry Pi Pico 2, (what a pain in the axx!!) which gave me extra RAM and CPU headroom needed to implement GPS anti-spoofing/jamming, altitude fusion, environmental logic, and a full diagnostic framework (ish).

One of the biggest challenges in this update was tuning the location detection logic. Getting the right balance between CO₂ levels, lux, humidity, and GPS speed wasn’t as straightforward as it sounds. Early versions constantly flipped between states, especially indoors near windows or while driving. I had to weight each sensor’s influence carefully and add sticky state logic for VEHICLE mode to prevent false switches when stopping at lights or losing signal momentarily.

Not everything is online yet: the SD card was lost during testing, so logging is offline until I add a new breakout. The Geiger radiation sensor is also shelved for now... it works, but it needs a dedicated co-processor to handle accurate pulse timing without overloading the main loop.

Bad News...

The AI Coral board and 5MP camera will have to wait, while I miniaturize the sensor and main PICO2 board. I also may need to resort to a Li-poly battery. I'm not happy about that, as I was trying to reduce fire risk.

v2.5 Feature Highlights:

• GPS over I²C with real-time NMEA parsing

• Anti-spoofing logic using satellite quality, HDOP, fix type, and motion behavior

• Pressure fusion to validate GPS altitude using BMP390

• Jam detection via GPS silence combined with stable sensor input

• Major logic re-written for (INDOOR, OUTDOOR, CAVE, VEHICLE) with weight tuning and more

• Sticky vehicle mode for stop-and-go travel accuracy

• Temperature fusion using BMP390 and SCD41 for stable ambient readings

• Sensor health monitoring, timeouts, and adaptive polling

• Fully enclosed (temporary) case milestone (I have some work to go) 

• SD logging temporarily offline (the swap to the Pico 2 required me to get a SD card SPI reader breakout)

• Radiation detection on hold pending co-processor integration

v2.5 code will be posted soon as I have some final cleanup to do.

For the integration, I 3D printed a sensor mounting plate and made a custom low profile PICO2 main board. 

ATLAS v1.9 - GPS Integration & Location Intelligence

Rebranding to ATLAS: I've been calling this project the "AI Field Analyzer" but let's be honest - ATLAS (Advanced Tactical Location Aware Sensor) sounds way cooler and actually describes what it does. Plus, like the mythological Atlas holding up the world, this thing carries all your environmental awareness on its shoulders.

Well, I got tired of my ATLAS not knowing where it was, so I taught it some location awareness using clever sensor fusion. Next upgrade will be adding a SparkFun GPS Breakout - NEO-M9N (parts on order), but for now it's pretty smart at figuring out if you're in a cave, your car, or standing in a field using what it already has.

Key v1.9 Upgrades:

• Location Detection: Uses light levels and sensor patterns to determine environment (GPS upgrade coming soon)
• Enhanced Weather Prediction: Storm probability calculations with arrival timing (because "might rain" isn't useful, "70% chance in 2 hours" is)
• Location-Aware Sensor Polling: Automatically adjusts update rates based on detected environment
• 8-Screen Display System: Added dedicated weather and location screens
• Memory Optimization: Fixed the display hanging issues and scrolling problems
• Enhanced Error Handling: Because field equipment that crashes is useless equipment

Location Intelligence - The Cool Part:

The ATLAS now automatically detects whether you're OUTDOOR (bright light = 8+ simulated satellites), INDOOR (moderate light = 2 satellites), VEHICLE (based on sensor patterns), or CAVE (dark = 0 satellites). Here's where it gets smart - when outdoors, it focuses on weather sensors for storm prediction. Move indoors? Shifts focus to air quality monitoring. The system adapts automatically, giving you exactly the environmental intelligence you need for your current situation.

The Fog Detection Discovery: Had a cool "aha!" moment when the device was screaming about fog after a heavy rain - high humidity, low light, all the classic fog indicators. But I was standing outside and could see perfectly fine. Turns out the lux sensor was the key - real fog blocks light significantly, but post-rain high humidity without the light reduction isn't actually fog. Now the system uses sensor fusion between humidity, temperature, and actual light levels to distinguish between "fog conditions" and "actual fog." Sometimes the best discoveries happen when your device disagrees with your assumptions and you realize it's teaching you something new about the environment.

The result? Intelligent power management and relevant data prioritization without manually switching modes. Once I get the real GPS module integrated, this will be even more accurate, but the current sensor-fusion approach works surprisingly well.

Plus, the weather prediction system provides localized forecasting based on your detected environment. It's telling you "STORM INCOMING: 75% probability in 1-3 hours" based on multi-sensor atmospheric analysis.

Code Architecture: Split the codebase into modular components - sensor_manager.py handles all the hardware interfacing and data collection, display_manager.py manages the 8-screen UI and user interface, weather_manager.py handles the storm prediction algorithms, and main.py coordinates everything and runs the main operational loop. Clean separation makes the code way easier to maintain and debug when you're iterating this fast.

Code is on GitHub as always - if you want to build your own ATLAS, everything's there. Still spending every penny on prototypes, but hey, the future isn't coming fast enough, so I'm building it myself.

https://github.com/thedocdoc/AI-Field-Analyzer/tree/main