The Navier-Stokes controversy and why zero data retention matters  

This entry was posted in Computers and tagged ai legal on by

Tristan Buckmaster (NYU) and Levent Alpöge (a researcher at Anthropic) spent almost a year working in secret on the fluid equations related to the Navier-Stokes Millennium Prize problem. They used AI models as research assistants and fed their unpublished drafts to OpenAI’s Codex to formalize their proofs in Lean. On September 8, after rumors on X that Anthropic had solved two Millennium problems, OpenAI announced that its internal model had proven Navier-Stokes blowup in an 88-hour run with around 10,000 agents. That was twelve hours after Buckmaster published his statement saying their progress had been passed to OpenAI, and that the OpenAI proof followed the same research path they had been pursuing. OpenAI first said it “cannot rule out that de-identified data derived from their usage of our products helped improve our models”. After an investigation it said his recent Codex prompts “could not have influenced the system in any way”.

I am not going to judge the credit dispute. The part that affects everyone is the privacy one. Buckmaster used a consumer-facing product with the training opt-out settings disabled, but his data still existed on OpenAI’s servers, kept for abuse monitoring (up to 30 days by default). The opt-out is a promise about future use. Zero data retention is the technical guarantee that your data is not kept at all. With a Zero Data Retention (ZDR) API agreement, prompts and outputs are not stored after processing and are not accessible to provider personnel, so there is nothing to leak, nothing to sweep into a training pipeline, and nothing to review when your data becomes interesting. Both Anthropic and OpenAI offer ZDR, but not by default: you have to request it, and some features are incompatible with it.

My take: most companies should simply ban the usage of non-ZDR AI APIs for anything sensitive. A privacy policy did not protect Buckmaster, and it will not protect your code either. The only control that works is not leaving the data on the provider’s servers in the first place: no ZDR, no access to company data. It is also the reason I chose Ollama Cloud for my own agent, Hermes. It connects to Ollama Cloud through their API with zero data retention, so my prompts and my data are not kept on their servers after each request. Local LLMs are not there yet for my daily work, so while that changes, this is the way I get capable models without giving up my data.

References: Buckmaster’s statement, the Wikipedia article on the priority controversy, Anthropic’s ZDR documentation, OpenAI’s ZDR announcement.

Redmi Headphones Neo  

This entry was posted in General and tagged amazon bluetooth music on by

I can’t use in-ear earphones anymore: all of them hurt my ears, so the over-ear format is a must for me.

I have just bought the Redmi Headphones Neo, Xiaomi’s budget over-ear Bluetooth headphones, for 40€ in Amazon. They usually sell for around 60€, so it was a good deal. I have always preferred wired headphones, but at 40€ they were cheap enough to take the chance.

Noise cancellation

The main reason for the purchase: my office is noisy. They have up to 42dB of adaptive Active Noise Cancellation, with three levels and an adaptive mode that adjusts automatically to the ambient noise.

The cancellation is good, filtering out the office chatter and the servers & AC hum, but it is not at the level of the 300€ Sony. For the price, it is great for working in a noisy office (or at home with a noisy daughter).

They also have a transparency mode that amplifies the outside sounds, so it is nice to go walking by the street hearing the traffic and the people around you.

The rest

  • The radio coverage is amazing: I can walk around all our huge office and they are still connected to the laptop.
  • Battery is enough for all the week
  • Dual-device connection, so they can stay connected to the laptop and the phone at the same time
  • Three microphones with noise reduction for calls
  • They weigh 263 grams, more than most over-ear headphones, noticeable after a full office day, though the protein leather cushions stay comfortable

Latency

As with every Bluetooth headphone there is audio latency, and they have no low-latency mode. For real-time audio applications I still need my wired Superlux HD681B.

Full specifications at Xiaomi. For 40€ they are a great deal, just don’t expect the silence of the 300€ flagship ones.

As an Amazon Associate I earn from qualifying purchases.

Hermes Agent  

This entry was posted in Computers and tagged ai on by

In the science fiction movies I watched as a kid, people talked to computers in natural language. Now it is real. Some months ago I wrote about Ollama. Since then, the way I use AI has changed completely: now almost everything goes through Hermes Agent.

Hermes is an open source personal AI agent from Nous Research. It runs on your own machine or server, you talk to it from Telegram (or other channels), and it has real tools: a terminal, a browser, file access, scheduled jobs. I run it in a Docker container on my home server, together with the rest of my self-hosted services. It connects to Ollama Cloud for the models: I am paying for the Ollama Cloud Pro subscription and using GLM 5.3 flash; before that I was on GLM 5.2.

It replaced my searches and my chatbots

I don’t open ChatGPT or Claude anymore. When I need something, I ask Hermes from Telegram or from its web interface, and many searches that went to Google now go to Hermes. It searches the web, reads the pages, and answers with sources.

It replaced my local AI tools

I was running Open WebUI in Docker as my local chat interface, and I also played with OpenClaw. Hermes replaced both for my daily use.

What it actually does for me

  • Web research: I set up the Firecrawl integration, so it can investigate on the web and extract content from pages that block plain fetching.
  • Email: it has access to my inbox. It can check for important messages, summarize long threads and draft replies.
  • Voice: you can talk to it instead of typing. It transcribes the voice messages you send it on Telegram, and it also has a push-to-talk mode where you hold a key, speak, and the transcript goes to Hermes as a message. It can speak its replies out loud too.
  • Financial advisor: it keeps track of my portfolio and does financial analysis of the stocks I am interested in, suggesting entry prices. It sends me a Telegram message when one hits its target.
  • Scheduled jobs: any of these can run on a schedule, alone, while I am doing something else.
  • WordPress: it manages my WordPress sites: publishing and editing posts directly from the chat.
  • Home Assistant: it is connected to my Home Assistant instance. It can query the sensors and control the devices: from the chat I can ask for the room temperatures, the CO2 level or the car battery, turn lights on and off, set the thermostat temperature, or send the lawnmower to mow.
  • Google Play Console: it is connected to my Google Play Console with a service account. From the chat I can say “Search the Google Play Console for the latest crashes in my app X and apply the fixes to the code”, and it fetches the crash reports and applies the fixes to the code of that app.
  • Code access: it has access to the code of my projects. When I ask it programming doubts, it writes example code to files, builds and runs them locally, and it can even download open source projects and test them on my server.

For coding I still use OpenCode

This is the honest part: Hermes has not replaced my coding agent. I am used to OpenCode, and it consumes fewer tokens per task. Hermes is my day-to-day assistant; when I sit down to write code, OpenCode is still my tool. They even run in the same Docker container on my home server, and Hermes can delegate some tasks to OpenCode, so the two work together.

Hermes Agent architecture diagram with its connected services

A growing toolbox of skills

Hermes manages its own skills. It creates new ones when it learns a new workflow and updates them as things change, so its abilities grow with use.

Another thing I am realizing is that lots of custom “AI applications” can simply be replaced with a Hermes instance. Instead of installing a new tool for every use case, you just ask your agent, and the skills it already has or the ones it creates along the way cover it.

Final thoughts

One practical tip: create a new Telegram session from time to time. Sessions keep growing as you chat, and the token consumption of each message gets bigger and bigger, so starting fresh keeps costs down.

Hermes is the first agent that stuck for me. The tradeoff is the same one I mentioned with OpenClaw: you are giving an agent access to your email, your files and your terminal, so be careful with the permissions you grant. But having one assistant that reads my email, watches my stocks, searches the web and lives in Telegram is very convenient.

Ollama: The easiest way to run local and cloud LLM models  

This entry was posted in Computers and tagged ai on by

I’ve tried many approaches to run local LLMs, and Ollama is hands-down the easiest way I’ve found to get started and actually use local models productively.

Installing Ollama is a one-line command:

curl -fsSL https://ollama.com/install.sh | sh

Running a model is also a one liner:

ollama run gemma3

It includes a local server service that can be managed with:

sudo systemctl start ollama
sudo systemctl stop ollama

https://docs.ollama.com/quickstart

Open WebUI

While you can use Ollama from the command line, I prefer the Open WebUI interface. It’s essentially ChatGPT-style interface but fully self-hosted, fully local, and beautifully designed.

If you have non-technical family members or want a quick chat interface, Open WebUI is perfect. It remembers conversation history, handles formatting beautifully, and feels like using a cloud service, except everything stays on your own hardware.

It can be easily run in a Docker container:

docker run -d --network=host -v open-webui:/app/backend/data -e OLLAMA_BASE_URL=http://127.0.0.1:11434 --name open-webui --restart always ghcr.io/open-webui/open-webui:main

https://github.com/open-webui/open-webui

Home Assistant integration

Here’s where Ollama gets really interesting for home automators: Home Assistant has official integration with Ollama. I’ve set up my Home Assistant to use an Ollama model as a conversation agent, part of the voice assistant controlling the devices in my home.

https://www.home-assistant.io/integrations/ollama/

Local LLMs are improving rapidly

My current favorite is now GLM-4.7-flash. On my mini PC with an integrated GPU, it generates amazing responses in about one minute. Models that were unusable six months ago are now competitive with far more expensive options.

Cloud LLMs with Ollama

Here’s what I didn’t realize: Ollama added cloud hosting in September, with the exact same interface as local models. Same API, same CLI, same simplicity, just running on their infrastructure. They offer:

  • Free tier: Great for evaluation and light use
  • $20/month tier: Reasonable for regular personal use
  • $100/month tier: For heavier workloads and teams

If you have a Raspberry Pi (or any modest device), the cloud option means you can run advanced models that would never fit in 2GB of RAM. The same ollama run command works across both local and cloud.

Enterprise-Grade privacy

Unlike other cloud LLM services, Ollama emphasizes enterprise-grade privacy. Your data isn’t used for training, and they offer compliance features that other services simply don’t have.

For me as a telecommunication engineer working with sensitive systems, this is a major advantage over alternatives like OpenAI or Anthropic.

Launching AI coding agents

Ollama can launch Claude Code, Codex or OpenCode, i.e.:

ollama launch claude --model qwen3-coder-next:cloud

Each of these works with any local model or cloud model.

OpenClaw integration

OpenClaw is the newest sensation in the AI agent world: https://openclaw.ai/

OpenClaw does not include a setup assistant for Ollama, and the config file is a bit tricky, but you can simply run:

ollama launch openclaw --model kimi-k2.5:cloud

Ollama generates the OpenClaw configuration and starts it.

I’m running OpenClaw in a Docker environment without access to my personal data, be careful, there are lots of security concerns.

https://openclaw.ai

The bottom line

Ollama is the easiest, most flexible, and most privacy-respecting way to run local and cloud LLMs today. The fact that it offers cloud options without forcing you to use them is amazing.

The downside: You do not have access to the top GPT or Opus closed models.

Installing Thingino on a Vanhua FJZ camera

This entry was posted in Computers on by

Two months ago my brother asked me: Which security IP camera should I buy? It seemed a simple question, but I needed some time to find a good solution.

I used a Yi Camera for several years, but their mobile app is overloaded with ads constantly pushing their cloud video storage services. I cannot recommend Yi or any other vendor whose business model relies on selling inexpensive cameras just to lock you into their cloud services. I also played with ESP-CAM (and a ESP32-S3-CAM), but the video quality is not enough (MJPEG, low framerate, no night vision…).

For devices as senstitive as cameras, I cannot trust closed firmware or Wi-Fi. Both are explotable security holes. I also can’t trust any camera vendor’s cloud service.

So my requirements were:

  • Open source firmware.
  • Ethernet only, no Wi-Fi.
  • Ceiling mount.
  • Power over Ethernet (PoE) to simplify the setup in the ceiling.
  • Night vision.
  • No vendor cloud service.
  • RTSP streams for self-hosted recording services (I use Frigate).
  • H.265 support to save storage, but I ended up using H.264 because Telegram doesn’t support H.265.
  • On camera motion detection.

It is quite hard to find cameras that clearly show their chipset in the listing. Finally I bought an inexpensive Vanhua FJZ OEM camera from Aliexpress.

After opening the camera, the board didn’t match the images of the Aliexpress listing, so I thought it was a scam, but the camera is OK, the listing is outdated.

Camera specs

  • Chipset: Ingenic T31X (should be enough for H.265 and basic motion detection)
  • Sensor: GC4653 5 MP (with the resolution for 5 MP the image is distorted, I willl use QHD 2560×1440, 3.6 MP)
  • Flash: 16 MB
  • Connectivity: Ethernet only
  • Power: PoE, 48 V
  • Storage: No SD card
  • Metal housing

Why switch firmware?

The camera shipped with an unreliable Chinese firmware. For example, viewing video through a browser required a plugin that didn’t work on Linux or Mac. So I decided to install Thingino (https://thingino.com/).

OpenIPC was another option, but Thingino seemed better maintained and feature-rich. However, Thingino isn’t perfect: There are bugs, and updates are frequent. Fixing bugs requires SSH access and manual edits.

Installing the firmware

Installing Thingino isn’t straightforward. You need to disassemble the camera and follow the steps in the Thingino wiki.

Some notes from my experience:

  • I had to make a pogo-pin connector for the serial port.
  • The camera has two serial ports. I lost a lot of time because I was trying to connect to the wrong one.
  • The bootloader is locked. There is a clever trick to access it, triggering an error by shorting two pins of the flash chip during the boot sequence, so it fails to read the kernel .
  • Firmware is uploaded via the serial port using ymodem (it is very slow, it reminded me of the BBS days).

The correct serial port and the pins to short during boot:

Accessing the camera

By default, the camera obtains an IP via DHCP.

  • Web interface: http://<camera_ip>
  • SSH: ssh root@<camera_ip> (default password: root, you’ll be prompted to change it on first login)

Configuring streams

In the web interface under Settings → Streamer/OSD, you can configure two streams:

  • Main: I’m using 2560×1440 30 FPS H.264 15000 kbps
  • Substream: For previews or motion detection. I set it to 640×360 10 FPS H.264 1000 kbps

Stream settings are saved in /etc/prudynt.json.

RTSP URLs:

  • Main: rtsp://thingino:thingino@<camera_ip>:554/ch0
  • Substream: rtsp://thingino:thingino@<camera_ip>:554/ch1

These streams can be used from recording apps like Frigate or tested from Linux using ffplay <stream_url>.

Motion detection

Motion detection is enabled from the web interface by clicking the person icon or from Services → Motion Guard. It was not working with the default settings because there were no secondary stream.

Thingino supports simple motion detection with rectangular zones defined in JSON. I think that the original chinese firmware had better detection options. But I will use Frigate for advanced detection options.

On motion detection Thingino has a lot of notification options:

  • Email
  • FTP
  • MQTT
  • Telegram
  • Webhooks
  • Ntfy.sh

Telegram is particularly useful as it sends notifications to the phone and can store video clips (for free!).

Some configuration quirks:

  • The file /etc/prudynt.json stores motion detection settings under a “motion” object.
  • The Send to Telegram option sometimes fails to save from the web UI. I needed to manually set "send2telegram": true.
  • Motion triggers the script /sbin/motion, which has a bug: it starts a video recording and calls /sbin/send2telegram, which tries to start another recording and fails. I needed to comment out the redundant recording call in /sbin/motion.

Publishing to Telegram

To enable Telegram notifications:

  1. Create a bot with @BotFather.
  2. Create a channel and make the bot an administrator.
  3. Enter the bot token and channel ID in the Thingino web interface: Tools → Send to Telegram.

By default, /sbin/motion tries to send a photo and video to Telegram. This did not work in this camera, and I needed to change the call to /sbin/send2telegram clip to send only the video.

Another drawback is that the Telegram app does not support playing H.265 videos, the main stream needs to be set to H.264.

Telegram bot

The bot can also respond to commands from authorized users to send live snapshots or video clips. Enable it in the web interface under Services → Telegram bot, and modify the wrong default actions to run binaries in /sbin/ instead of /usr/bin/.

Final thoughts

Installing Thingino on this camera is a rewarding but technical process. You gain better control and privacy, but it requires patience and careful troubleshooting. I will need another post to explain the Frigate setup.

2024

This entry was posted in General on by

It has been a year full of decisions—some very difficult, others quite simple.

I continue to learn what it means to be a father, and it’s proving to be as complicated as I had imagined.

I’m not active on social media, and after the collapse of Twitter, I’ve been trying to revive my activity here on the blog.

On the professional front, I made the decision to leave Netcentric, where I worked for the past five years. I had a great time there, and it was a tough decision, but an exciting new opportunity came my way. I left the AEM consultancy world to join Alén Space, a company focused on building satellites. I now work on their Mission Control System software. So, while I’m still pursuing my career as a Java developer, I’m also taking on a more managerial role, leading a developer team.

In another change, after seven years of working with a Mac, I’m back on Linux—and I’m very happy about it. I also replaced my old home lab Dell T3500 workhorse with a sleeker Minisforum UM890 Pro, and it’s been amazing. For my home office setup, I’ve also switched back to OpenWRT with a Xiaomi AX3000T (with WiFi 6). I had forgotten how easy it is to configure OpenWRT.

This has also been a great year for my home automation journey. I started the year by moving Home Assistant to a small and efficient Orange Pi 3B. I’m extremely happy with the combination of Home Assistant and ESPHome. Home Assistant has become an essential part of our daily routine, mainly for climate control and air quality monitoring.

On a personal note, we moved from an apartment in the city back to our country house. This means more commuting, but it also means more comfort and a better school for our little one. I was disappointed by Santiago de Compostela—it’s turning into a theme park focused solely on tourism.

Finally, I replaced my 20-year-old diesel car with an electric one. I would have switched sooner if I had known just how great and affordable electric cars are. I chose a Tesla primarily for its price-to-technology ratio. I’m not a fan of the brand or their CEO, but the car has made living in the country much cheaper.

Happy 2025!

Abusing Apple’s Find My network

This entry was posted in Computers and tagged android apple bluetooth docker on by

Some months ago Apple was running a commercial on Spanish TV about the iPhone’s privacy, mocking users with Android devices.

Probably, iPhone users do not know that it is really easy to physically track them.

Apple’s “Find My” network was launched in 2019 and the AirTag in 2021. The AirTag emits BLE beacons with a public key that, when received by another Apple device, are sent along with the location of the device that received them to Apple servers, encrypted with the AirTag public key. The information on the Apple servers needs to be decrypted with the AirTag’s private key.

However, when the AirTag location is updated, the owner of the AirTag also knows that there is an Apple device nearby.

In theory it’s required to have an iPhone/iPad/iPod to activate an AirTag, but it’s very easy to build an AirTag clone with ESP32.

The Macless Haystack project, based on the original OpenHaystack, provides:

  • The python utility to generate AirTag key pairs
  • The firmware to flash an ESP32-WROOM-32 and convert it to an AirTag clone
  • An Android app to check the location of your fake AirTags
  • Two Docker containers needed to retrieve the info from the Apple servers, they need to be accesible by the Android app

And, of course, I built my own one:

These ESP clones are much bigger than AirTags but they are ok to track cars, suitcases or bags. There is a PR to the Macless Haystack repo alowing to use an ESP32-C3 Supermini, that makes a smaller device with a better battery duration.

Google launched the “Find My Device” network in April 2024, and the tags supporting it (i.e. the Chippolo Point or the Pebblebee) are slowly reaching the market. But the default security option only shares the location information if there are other Android devices nearby. That is much better for the privacy of Android device owners, but much worse for the owners of the tags.

So, if you own an Android device, it is still better to use AirTag clones, abusing the lack of privacy of the Apple devices.

Back to OpenWrt

This entry was posted in Computers and tagged internet openwrt vpn on by

Some years ago, my network provider (O2 – Spain) installed a router for me (Mitrastar HGU GPT-2541GNAC) with much better specs than my old OpenWrt router (TP-Link TL-WDR4300). So, I ditched OpenWrt and started using the company’s router.

But the Mitrastar needed to be factory reset every 6 months because it had some problems with the DHCP in my network. Recently, I offloaded the DHCP to an OrangePi 3B, but now my home network was relying too much on the availability of this device. Also, the Mitrastar is starting to show its age without features like WiFi 6…

A couple of weeks ago I found on Aliexpress a new Xiaomi AX3000T router. It has an amazing set of specs:

  • 2 ARMv8 cores @ 1.3GHz (MediaTek MT7981B)
  • 128 MB ROM
  • 256 MB RAM
  • WiFi 6 (AX) in the 2.4 GHz and 5 GHz bands

And it’s compatible with the lastest snapshot of OpenWrt:

https://openwrt.org/inbox/toh/xiaomi/ax3000t

I was able to get it during the AliExpress ChoiceDay (this happens the first days of each month) for 26 EUR (including a 4 EUR coupon).

When it arrived, I found it a bit smaller than what I expected, and I liked its minimalist look. It has only one button for WPS (+ the reset pinhole), and one LED in the front panel (i.e. it does not have LEDs on the ethernet ports).

Everything was in Chinese, but it’s easy to read it using the Google Translate camera, only for the steps necessary to set up OpenWrt. I did a simple installation without the U-Boot boot loader.

So, I put again an OpenWrt router back in my home network moving the DHCP and WireGuard services to the router. I had forgotten the beauty and simplicity of OpenWrt.

I also tested adblock-lean and it works quite well on the router with big lists like https://oisd.nl/: It’s able to manage the 660K domains of both oisd big and osid nsfw lists. But at the moment I’ll continue using the Pi-hole on the OrangePi. I still need the OrangePi to run Home Assistant and the NAS.

CO2 sensor with LCD and ESP32-C3 Supermini

This entry was posted in Computers and tagged esp32 esphome iot on by

I wanted to add an LCD screen to my CO2 sensor, so I bought a white LCD 1602 with an I2C controller. The I2C controller needs to be soldered to the LCD, but my basic soldering skills were sufficient for the task.

I also wanted to place it in a box, so I purchased this plastic enclosure but I cannot recommend it. It required a lot of glue from a glue gun to install the LCD and the ESP. I also had to use the soldering iron to create space for the ESP and a hole for the USB connector. I installed the plastic buttons but they are only decorative.

I made room for the sensors inside the box, but finally left them outside because they are more precise that way.

The ESP32-WROOM-32 was too large for the enclosure, so I used a ESP32-C3 Supermini with an expansion board. This is a really amazing board with a 32-bit RISC-V 160MHz microcontroller, WiFi, Bluetooh, I2C and UART. It’s not as powerful as the ESP32-WROOM-32 with a dual core 32-bit Xtensa 240Mhz, but it’s more than capable to control the sensors and the LCD.

This is the ESPHome configuration, which includes a switch to control the LCD backlight and a clock synchronizing the time with Home Assistant:

esphome:
  name: co2sensor
  friendly_name: CO2 Sensor

esp32:
  board: esp32-c3-devkitm-1
  framework:
    type: arduino

logger:
  level: ERROR

api:
  password: ""

ota:
  platform: esphome
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 90s
  ap:
    ssid: ${friendly_name} Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

debug:

time:
  - platform: homeassistant
    id: homeassistant_time
    timezone: "Europe/Madrid"

uart:
  rx_pin: GPIO20
  tx_pin: GPIO21
  baud_rate: 9600

i2c:
  sda: GPIO8
  scl: GPIO9

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: "WiFi signal sensor"
    update_interval: 60s

  - platform: dht
    model: AM2302
    pin: GPIO10
    temperature:
      id: "dht22_temperature"
      name: "DHT22 Temperature"
    humidity:
      id: "dht22_humidity"
      name: "DHT22 Humidity"
    update_interval: 50s

  - platform: mhz19
    co2:
      id: "mhz19_co2"
      name: "MH-Z19 CO2"
    temperature:
      id: "mhz19_temperature"
      name: "MH-Z19 Temperature"
    update_interval: 60s
    automatic_baseline_calibration: false

display:
  - platform: lcd_pcf8574
    dimensions: 16x2
    address: 0x27
    update_interval: 1s
    lambda: |-
        auto time =  id(homeassistant_time).now();
        it.printf(11, 0, "%02d:%02d", time.hour, time.minute);
        it.printf(11, 1, "%02d/%02d", time.day_of_month, time.month);
        auto co2 = id(mhz19_co2).state;
        if (!isnan(co2)) {
          it.printf(0, 0, "%.0fppm", co2);
        }
        it.printf(0, 1, "%.1fC", id(dht22_temperature).state);
        it.printf(6, 1, "%.0f%%", id(dht22_humidity).state);

switch:
  - platform: gpio
    pin: GPIO7
    name: "LED Backlight"
    id: led_backlight
    restore_mode: ALWAYS_OFF

And the full BOM:

MH-Z19B CO2 sensor

This entry was posted in Computers and tagged esp32 esphome iot on by

To keep a healthy environment at home or at the workplace, one of the important things to control is the carbon dioxide (CO2) level.

It’s measured in ppm (parts per million), indicating how many parts of CO2 there are in one million parts of air. As a reference:

  • Less than 1000 ppm are healthy levels
  • Between 1000 ppm and 2000 ppm, we need to reduce the CO2 levels
  • Levels greater than 2000 ppm are associated with headaches, sleepiness, poor concentration, loss of attention…

To reduce the CO2 level, we need to ventilate the room. It can be manually done (opening the windows) or it can be automated with a ventilation system.

To measure it we need a proper CO2 sensor, and one of the most reliables sensors is the MH-Z19B. It is not cheap for the Aliexpress standards (it costs around 20 EUR), but other cheap sensors announced as “air quality” sensors or “eCO2” sensors are not really measuring the CO2 level (i.e. the MQ135).

I bought this MH-Z19B from Aliexpress and hooked it to an ESP32-WROOM-32 board. This board is going to be also purposed as a temperature and humidity sensor, so I also attached a DHT22 sensor. I bought this DHT22 sensor but it is not an original one, and the measures do not seem very correct, so I ordered again an original AM2302 (=DHT22). The MH-Z19B includes a temperature sensor, but it’s mainly used for calibration and it lacks precision, as it does not report decimals. I’m also using an expansion board to simplify the connections.

The ESP32-WROOM-32 on the expansion board connected to the MH-Z19B (gold) and to the DHT22 (red)
  • The jumper in the expansion board needs to be set to 5V (because both of these sensors need 5V).
  • Connected VCC and GND of both sensors to the expansion board
  • Connected the RX and TX of the MH-Z19B to the TX and RX (GPIO1 and GPIO3) of the ESP
  • Connected GPIO16 to the DAT of the DHT22

Finally, I installed ESPHome to the board with this configuration:

substitutions:
  devicename: co2sensor
  friendly_name: CO2 sensor

esphome:
  name: ${devicename}
  friendly_name: ${friendly_name}
  platform: ESP32
  board: nodemcu-32s

logger:

api:
  password: ""

ota:
  password: ""

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  reboot_timeout: 90s
  ap:
    ssid: ${friendly_name} Hotspot
    password: !secret wifi_password

captive_portal:

web_server:
  port: 80

debug:

time:
  - platform: homeassistant
    id: homeassistant_time

uart:
  rx_pin: GPIO3
  tx_pin: GPIO1
  baud_rate: 9600

sensor:
  - platform: uptime
    name: Uptime
    filters:
      - lambda: return x / 60.0;
    unit_of_measurement: minutes

  - platform: wifi_signal
    name: "WiFi signal sensor"
    update_interval: 60s

  - platform: dht
    model: DHT22
    pin: GPIO16
    temperature:
      id: "dht22_temperature"
      name: "DHT22 Temperature"
    humidity:
      id: "dht22_humidity"
      name: "DHT22 Humidity"
    update_interval: 60s

  - platform: mhz19
    co2:
      id: "mhz19_co2"
      name: "MH-Z19 CO2"
    temperature:
      id: "mhz19_temperature"
      name: "MH-Z19 Temperature"
    update_interval: 60s
    automatic_baseline_calibration: false

And It’s working nicely, this is the ESPHome web interface:

Keeping the CO2 levels under control is helping me create a healthier workplace environment and improve performance.