Posts made by AndrewDJohnson

BME 680 and M5 Cardputer Environmental Monitoring System

See: https://github.com/AndrewDJohnson/BME680Environmental-MonitorM5Cardputer
See: https://halfin-halfout.blogspot.com/2025/12/bme-680-and-m5-cardputer-environmental.html

This software is for the M5 Cardputer (original, but should work on the "advanced" model) and is an environmental monitoring system, saving data to an SD card and displaying it nicely on a webpage.

It uses the BME 680 sensor, connected via the I2C for remote environmental monitoring. The cardputer is set up as a Webserver so that current readings can be seen on a webpage – as shown below.

See: https://www.youtube.com/watch?v=Ygyj-1DjHoc

Instructions:

1. Edit the config.ini file to include Wi-Fi network SSID and Password

2. Copy this file and the 2 HTML files to the root of the SD card and insert into Cardputer

3. Install/Burn the firmware (.bin) file

Overview

This software project is unfinished, but all the main features work well and survive a 24 hour soak test. I hope others can build on it! The code is weakly commented, but I hope it is readable.

Readings of pressure, temp and humidity are taken every minute (frequency not currently configurable) and saved in memory and to a CSV file, stored on the SD card, if one is present. The file is named based on the current date and a new CSV file is created at midnight.

On the home page, you can click the "Data and Charts" button which will allow you to view the last 24 hours of data and adjust the viewing start and end times for a nice graphical display.

Any CSV files saved on the SD card can be downloaded to your local machine.

Another page allows you to configure operational parameters for high and low alarms for temperature, pressure and humidity. An alarm sound is played from a WAV file through the cardputer's speaker and an indication of the alarm is given on the home page.

The Cardputer's display can show each of the environmental values in turn when you press any key, along with the device's IP address on the network, once it is connected. The local time is determined by connecting to an NTP server.

The code is built from various examples given on the M5Stack website and forums as well as some other places.

The cardputer software uses 2 HTML files from the root folder of the SD card –

"index.html" and "charts without data.html"

These have placeholders for various bits of data such that the cardputer software fills them in with the relevant data. The chart data stored in memory is sent as a JavaScript array so that the web page, when rendered, shows all the chart data. The chart display code was written by ChatGPT and modified a little to produce the relevant display, with start and end time zoom sliders!

I hope someone uses it to monitor their greenhouse or something!

Of course, you can set up port forwarding on your router and keep an eye on your greenhouse remotely!

Enjoy!

Andrew Johnson - ad.johnson@ntlworld.com

Dec 2025

https://github.com/AndrewDJohnson/M5CardPuterIntervalometer

[I would like to know how to make this available in M5Burner!]

Recently, I was out walking and some heavy rain/storm clouds could be seen approaching. For a while, I had been meaning to try and do a time lapse sequence, using a Canon SX740 or Nikon P900 camera – as photographing clouds and storms can produce interesting or even spectacular results!

Unfortunately, the SX740 has no time lapse feature, although it may be possible to use something like CHDK to enable this. (I used a similar method when I had a Canon SX50, which I sometimes regret that I sold).

Anyway, the Nikon P900 has a timelapse feature built in and it’s accessed through the “SCENE” mode/menu option. However, this has certain limitations because you can only run the time lapse for a set number of minutes, with a set period for the time lapse. Also, the results are not always saved at the camera’s maximum resolution of 16MP.

A forum post I read noted this problem, and a response to the Original Poster suggested a solution was to use an Arduino device and circuit to send an IR pulse to the camera, mimicking the camera’s IR remote, to take photos. The Arduino device mentioned was an ESP32 microcontroller - and the circuit was shown constructed on a bread board. This seemed rather unwieldy, to say the least. At this point I’d realised that a recent purchase – about which I’ve been meaning the write a blog entry – not only had an ESP32 microcontroller, it also had a built-in IR LED. This is the excellent and versatile M5Cardputer!

I thought that I should be able to directly use the Arduino Sketch from the circuit example, with only one modification. All I needed to do was change the Pin number of the IR LED. That is, in the M5Cardputer, the IR LED is connected to pin 44 of the ESP32.

I loaded the code into the Arduino IDE and compiled it and downloaded it to the Cardputer… it worked straight away!

The Cardputer is well-suited to the role of IR Camera remote control – being battery powered and pocketable! All that needed to be added was some code to time the repetition of pulses and then offer some options to the user.

IR versus Bluetooth Control

Of course, one could view IR remote control as “old hat” now – as newer cameras can be controlled by Apps and either a BlueTooth or WiFi connection, providing easier functionality and, for example, video/image previews on the remote device (i.e. Smart Phone or Tablet). The Carpduter is also equipped with WiFi and Bluetooth, so could, in theory, be used to control a camera with these methods. One such project has been built for a Canon Camera, using an Arduino Board.

Support for Different Makes of Camera

In my mind, the popular brands of digital camera are Canon, Nikon and Sony – but there are, of course, several other manufacturers – Olympus, Pentax and Minolta being some. I wondered if anyone had made Arduino-based remote controls for them… After more research, I ended up finding some code called MD_multiCameraIrControl. However, this included a lot of code to control other camera features – like zoom, so was more complicated than needed. A simpler version of this code at multiCameraIrControl contained IR pulse timings for other cameras, all in one file. These were added to my code.

Additional Features

I needed to add 2 user prompts – to enter the frequency of photo taking (e.g. every 3 seconds) and the overall duration of the timelapse (e.g. 10 minutes).

Finally, it was obvious that I should allow the cardputer to be used like a “normal” remote control – with a press of any key on the keyboard causing a pulse to be sent to take a photo.

Hence, when the software runs, the user can select between using manual remote control and the intervalometer. In each case, there is an abort option so that the menu reappears and the mode of control can be changed once more.

Using the Code/Firmware

The code can be downloaded from Github – both as firmware binary (.bin) and the INO/Sketch file. To write the code onto the Cardputer’s flash memory, you will need to use M5Burner. Run the software and choose “Export firmware” and then point this at the bin file you downloaded!

Practicalities / Physicalities

So, now we have the electronics and what not all working, how can we actually use the Cardputer easily when the camera is taking the photos for the timelapse? It could be rather tiring standing there and holding it for half-an-hour!

The Cardputer has magnets in the case and so, for example, it should stick to something like a radiator or a fridge door… but we’re not likely to find either of those things on a mountain top… so it might be possible to attach it to the leg of a camera tripod? You need to ensure that the camera’s IR sensor can “see” the IR emissions from the M5 Cardputer. Perhaps you can put the Cardputer on a camping chair or table? Another option is to use an elastic band wrapped around the camera lens and the Cardputer to make sure it is pointing in the right direction. You might need to use a piece of card between the Cardputer and the camera lens to stop it scratching the outside of the case of the lens. Another alternative might be to use some sort of Velcro strap to fasten the Cardputer to the camera lens.

In testing, the Cardputer’s battery life seem to be several hours so it should easily last long enough to do some very long time lapses. It is much more likely that your digital camera battery will run out before the M5 Cardputer’s battery does!

One final note is that setting timelapse value of 1 second on the Cardputer may not produce good results, because the camera may not be able to set the auto focus and exposure in such a short time – it depends on the camera and the mode in which it is set

Happy Timelapsing – or remote controlling!

Hi Everyone!

I have been having fun with the m5Cardputer, but am trying to create an INI file for Config settings.

I want to use the mINI file class by metaYeti:

https://github.com/metayeti/mINI

So I've started with this code:

  mINI::INIFile file("myfile.ini");
  mINI::INIStructure ini;
  //file.read(ini);
   ini["section"]["key"] = "value adj"; 
   file.generate(ini);
   Serial.printf ("Ini section is %s\n",ini.get("section").get("key").c_str());
  //file.write(ini); 
  Serial.printf ("Tried to write INI to SD card.\n");

This all compiles and runs - but of course, it doesn't do anything. What baffles me is where the INI file would be created - as there is no path or filesystem set in the example above. I have a feeling I need to do something with a filestream class or something - and somehow make this stream connect with the SD filesystem object or something.

The object is clearly being created - because I can print out the value I set (as shown above).

So can anyone tell me how this can be actually linked to an actual inifile stored in an actual folder!?!

Thanks!