Scarey's Tech

GitHub - scarey/kitty-3000: Alternative code for running the Kitty 3000 as the original project seems unavailable. This project uses an Micropython on an ESP32 and Home Assistant to release and track treat counts.

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

Update 4/20/25: The latest version of micropython-mqtt has been restructured. Now grab mqtt_as/__init__.py and upload it to the same path on the ESP32. Tweak mqtt_local_example.py with your WiFi and MQTT broker settings and upload that as mqtt_local.py to the root of your ESP32.

This project's code

Alternative code for running the Kitty 3000 as the original project seems unavailable. This project uses an Micropython on an ESP32 and Home Assistant to release and track treat counts. - scarey/ki…

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

Copy all python files to the root of the ESP32. If you don't want the automatic Home Assistant device and entity creation you can get rid of ha.py and use an MQTT client instead.

Configuration

Static config (config.json)

The static config file contains config for the 4 stepper pin numbers, a dispenser number so you can have mutiple Kitty 3000's, and the number of treats it can hold (based on how many layers). Make necessary changes and copy to the root of the ESP32.

MQTT config

I made some configuration easier to change and it exists as a JSON document in the "esp32/kitty3000//config" topic. The "name" shows up in Home Assistant auto discovery device. The cheap steppers seem to need some tweaking as they get a little off over time. I've added "adjustment-angle" (how much to adjust) and "adjustment-freq" (number of treats to adjust after) and you can muck with those to calibrate yours.

{
  "name": "Doggy 3000 - Family room",
  "adjustment-angle": 2,
  "adjustment-freq": 6
}

"esp32/kitty3000//config" topic

Home Assistant

If you uploaded ha.py to your ESP32 then the code will use MQTT Discovery to create a device and entities.

Notifications

I didn't bother making any but you could notify yourself when the treat count gets low.

Smart Mousetrap

Stephen Carey — Sat, 18 May 2024 19:44:48 GMT

I got tired of hearing critters running around in my walls. Ordered some traps and quickly got tired of going into the attic every day to check them. I ended up adding small reed switches and magnets to the traps and wiring them to an ESP32. Now I just wait for the "A 🪤 went off! Another 🐁 bites the dust!" message, grab a Ziploc bag and head up to the attic hoping it was a merciful death.

🪤 Running tally 🪤 - 🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁🐁

Supplies

ESP32 Mini, ESP32 development board, or whatever ESP32 you prefer
Mousetraps
Small reed switches
Magnets - the tiny magnets that come with the reed switches didn't do a good job
Wire - the layout of your traps determines how much wire you'll need. See the Wiring section below.
Dupont connector kit - (optional)
Dupont Terminal Block (optional, handy for all the ground connections)
USB cable
USB wall charger
Hot glue gun
Multimeter (optional)

When you purchase through links on this site, I may earn an affiliate commission.

Wiring and Assembly

You need 2 wires between each trap and ESP32. Depending on the spread you might be better off having multiple ESP32s and shorter runs of wire. One wire from each trap needs to go to ground and the other to an input pin. Among others, pins 16 - 33 are safe to use.

The ends of the wires on the trap side are connected to the reed switch. Test the reed switch before connecting the wires as some are likely DOA. Hot glue the reed switch to the bottom of the trap opposite the teeth and hot glue the magnet above that on the part you press down. I used a multimeter while gluing the magnet to ensure it was in a good spot to trigger the reed switch.

Magnet and reed switch hot glued in place

Code

Getting Started With Micropython

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

OTA library (optional)

Micropython code to read updated code via MQTT and update the ESP32 filesystem - GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

GitHub - scarey/smart-mousetrap: Micropython code for monitoring mousetraps using ESP32.

If you want to be able to remotely update the code, grab ota.py and upload to the root of the ESP32. See this post for more details.

This project's code

Copy main.py to the root of the ESP32.

Micropython code for monitoring mousetraps using ESP32. - scarey/smart-mousetrap

Waterproof electronic box / enclosure by pbtec

Configuration

You just need to let the software know what pins the trap(s) are connected to via MQTT configuration data in the 'esp32/mousetrap/config' topic (set retain for the config). It looks something like:

{
  "activePins": [25,26,27]
}

Sample esp32/mousetrap/config

To use multiple ESP32s just change the BASE_TOPIC in the code for each to a unique value, e.g. 'esp32/mousetrap2'.

Notifications

When the trap is sprung an MQTT message with a comma separated list of all sprung trap pin numbers will be sent. Use Home Assistant automation or Node-RED etc to let you know traps went off. Home Assistant phone notifications work well and are free. Twilio costs a few bucks a month and let's you send text messages.

Notes

I've got an outlet near the air handler for the AC so I just power the ESP32s from that. If you have a light socket you could get a socket adapter to add an outlet there. If there's any interest I could look into running off a battery and going into deep sleep mode, etc, etc.

More Hot Tub Ideas

Stephen Carey — Sun, 05 Nov 2023 14:47:29 GMT

I've been working on a towel warmer for out by the hot tub. If it doesn't burn down my house I'll probably make a post about it. I am also looking into automatic dispensing of chlorine and boric acid though I wanted some feedback first.

Towel warmer

This is essentially an insulated box with a solid state relay controlling an electric heater to keep the box in a toasty temperature range. I need to play around and see what temps will work well but I've currently got the heater shutting off at 130°F...

Automatic chemical dispensing

I've been playing around with peristaltic pumps and they're pretty cool. I have cheap and easy access to 10% bleach and I guess I'll be dissolving boric acid powder into water. Would still need to occasionally manually add CYA and oxidizer, oh well.

When to add?

Only during the filter cycles? That way you wouldn't need automated pump control to ensure circulation.
For those with automated pump control I could publish when chemicals are being added and you could use Node-RED/HA automation to circulate when necessary.

How to prevent dispensing when the tub is in use?

Disable if the cover is open?

Freezing temps?

Boric acid and bleach freezing in winter? Additional circulator pump?
Or storing the chemicals in the tub cabinet? That would also protect them from the sun but would be more of a pain to access.

Hot Tub Monitor

Stephen Carey — Thu, 28 Sep 2023 14:00:38 GMT

When I got my hot tub last year and was looking into remote monitoring and control I could only find an old Hackaday post from 2015 but the old microcontroller was hard to source. I figured I'd rework it using tech from this decade so I could read the temperature, PH, and ORP in Home Assistant and not have to deal as much with test strips.

This uses an ESP32 and industrial PH and ORP sensors that seem to last for a year or so. You can get cheap replacement sensors from Aliexpress.com to make that less painful. I just replaced my PH sensor and have a new ORP sensor on order.

It takes readings every minute so you can watch the battle between chlorine and filthy kids in real-time. It also has a two-point PH calibration mode to help make re-calibration easier, a display so you can check the sensor data locally and check calibration status, water and air temperature sensors, and an option to monitor the cover state (opened/closed).

Supplies

ESP32 Mini, ESP32 development board, or whatever ESP32 you prefer
OLED Display - 0.96" 128x64
Assorted M2 and M4 nuts and bolts to mount box cover and display
Display on/off switch
Gravity: Analog Industrial pH Sensor / Meter Pro Kit V2
ORP Adapter
ORP Industrial Electrode or cheaper from Aliexpress.com (choose "ORP sensor BNC")
2x Temperature sensor
4.7k resistor
2x 0.5" grommets or similar for sealing around the temp sensor and power wires
pH Calibration Solution

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

The ESP32 and ORP Adapter need 5V, everything else is 3.3V.

Assembly

I mounted it under a shelf and run the probes into the tub near a filter.

The guts, calibration mode, and sensor data display

Project Box

It started life as this:

Stable and waterproof / watertight OpenSCAD customizer case / box / enclosure V6.1 by pbtec Edit December 2022: Updated Version 6.1 --> Seems Openscad has in certain circumstances problem with special characters (like ä) in comments…. Created new fixed version 6.1 (Nothing else has changed) Latest n…

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

And I tweaked it in OpenSCAN and then ran out of filament during the print. I used some electrical tape to seal the gap. But you should make sure you have enough and pause the print around layer 187 and drop M4 nuts in each of the corners. Toss in a desiccant packet to help with moisture. I glued a clear piece of plastic to the box over the screen to hopefully keep the water out and the shelf provides some protection.

HottubMonitorBox

HottubMonitorBox.stl

311 KB

ORP Adapter

Ensure the dip switch is set for ORP.

Sensors

I just put the PH, ORP, and water temp sensors up and over the side and into the tub near a filter. The air temp sensor should be somewhere out of the sun and away from other objects. Mine's hanging over one of the shelf supports.

Cover opened/closed sensor

I haven't hooked this up on my setup yet but adding support for it in the code was simple enough. I figured I'd glue or maybe sew some magnets into the flap of the cover and try to line up a reed switch near where the magnets should end up. The cover state gets sent along with all the other data. Then it's easy to add some alerts like the cover has been open for a long time or is open at bedtime, etc.

Code

Getting Started With Micropython

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

ssd1306 driver

Grab that from here and upload to the root of the ESP32.

OTA library (optional)

Micropython code to read updated code via MQTT and update the ESP32 filesystem - GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

GitHub - scarey/hot-tub-monitor: Micropython code for monitoring PH, ORP, and temperature of your hot tub using ESP32, Home Assistant, and InfluxDB2

If you want to be able to remotely update the code, grab ota.py and upload to the root of the ESP32. See this post for more details.

This project's code

Micropython code for monitoring PH, ORP, and temperature of your hot tub using ESP32, Home Assistant, and InfluxDB2 - GitHub - scarey/hot-tub-monitor: Micropython code for monitoring PH, ORP, and t…

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

Copy *.py to the root of the ESP32. If you don't want the automatic Home Assistant device and entity creation you can get rid of ha.py.

Configuration

When you have multiple temperature sensors using the 1-Wire protocol you need to know the serial numbers of each sensor so you know if it's the air or water temp sensor. The first time you run the code it will output the serial numbers of the sensors it sees and you add those to the MQTT configuration in the 'esp32/hottub/config' topic (set retain for the config). It looks something like:

{
  "ph_acid_calibration": 2032.44,
  "water_rom_reg_num": "2863c65704e13c56",
  "ph_neutral_calibration": 1500.0,
  "air_rom_reg_num": "28c3005704e13cb4",
  "temp_unit": "F"
}

Sample esp32/hottub/config

The calibration values above are a good starting point so use those and just update the 'rom_reg_num' values with what was output during startup. If you find you mixed them up you can just swap them and publish (don't forget retain) the config again.

Calibration

The two-point PH calibration process involves using PH 4.0 and PH 7.0 standard buffer solutions. The usual suggestion is to do this monthly.

Rinse the probe with distilled water, then absorb the residual water-drops with soft paper. Insert the pH probe into the standard buffer solution of 7.0 (we do the neutral readings first so the calibration process doesn't think the distilled water is the standard buffer solution)
Press the calibrate button in Home Assistant or publish '{"command": "calibrate"}' to 'esp32/hottub/command' but don't set retain.
The calibration process will begin within 1 minute and then you can see the progress on the display
Stir gently until the final neutral reading is taken
Rinse the probe again as in step 1 and insert into the 4.0 solution and stir gently until the final acid reading is taken
The previous MQTT config gets backed up to 'esp32/hottub/configbak' and the updated calibration values and the timestamp of the calibration are stored in 'esp32/hottub/config'.
Put the probe back in the hot tub and you're done.

Home Assistant

If you uploaded ha.py to your ESP32 then the code will use MQTT Discovery to create a device and entities for the 4 sensors, and calibrate button.

Notifications

I haven't bothered setting up any alerts yet but off the top of my head:

PH / ORP out of range
Cover open too long or at an unlikely time
Water temp too low or high
Calibration reminder using "last_calibration" in the config

Historical Data

If you'd like historical temp, PH and/or ORP data here's some InfluxDB config that will let you make dashboards similar to this. The data is all in MQTT so you can grab the data however you like and use your own visualization tools.

You can see when I added spa down and chlorine

[[outputs.influxdb_v2]]
  urls = ["http://:8086"]
  token = ""
  organization = ""
  bucket = "iot"

[[inputs.mqtt_consumer]]
  servers = ["mqtts://:"]
  topics = [
    "esp32/hottub/readings",
  ]
  qos = 0
  username = "telegraf"
  password = ""
  insecure_skip_verify = false
  data_format = "value"
  data_type = "string"
  topic_tag = ""
  [[inputs.mqtt_consumer.topic_parsing]]
    topic = "esp32/hottub/readings"
    tags = "source/_/_"
    measurement = "_/what/_"

  [[processors.starlark]]
     namepass = ["hottub"]
     script = "/scripts/hottub.star"

telegraf.conf example

You'll also need the Starlark processor script that parses the JSON payload. Save it to the "script" path in the telegraf config ("/scripts/hottub.star" for mine).

load("json.star", "json")
 
#{
#  "orp": 545.8052,
#  "air_temp": 64.3,
#  "cover_state": 1,
#  "ph": 6.931918,
#  "temp_error": "",
#  "water_temp": 90.80001
#} 
 
def apply(metric):
   j = json.decode(metric.fields.get("value"))
   metrics = []

   stow_metric = Metric("stow")
   stow_metric.fields["temp"] = float(j["air_temp"])
   stow_metric.tags["source"] = "esp32"

   new_metric = Metric("hottub")
   new_metric.fields["orp"] = float(j["orp"])
   new_metric.fields["water_temp"] = float(j["water_temp"])
   new_metric.fields["ph"] = float(j["ph"])
   stow_metric.tags["source"] = "esp32"

   metrics.append(stow_metric)
   metrics.append(new_metric)
  
   return metrics

hottub.star

Notes

Replacement probes from Aliexpress.com seem to work well and are pretty cheap (~$20 for PH, ~$40 for ORP). Make sure to choose the industrial probe with the BNC connector. They likely need to be replaced each year. My 14 month old ORP sensor is taking 2 days to settle its reading after a reboot though it's working well other than that. The PH sensor thought most everything was 6.9-7.0 after a year and needed replacement.
I couldn't find any temperature correction data on the sensor page but at hot tub temps there seems to be minimal correction needed. We've got the water temp available so it should be easy to add if we can figure that out in the future.

Simple ESP32 OTA Code updates via MQTT

Stephen Carey — Thu, 10 Aug 2023 13:25:41 GMT

This is a very basic system for remotely updating files on an ESP32 and optionally triggering a reboot. Lots of other projects do something similar and have more features but I wanted something lightweight that didn't depend on a web server. The device just needs to listen to an OTA topic and pass the message to the OTA module which will handle the filesystem updates and rebooting.

There are no fancy features here. No rolling back broken code if the updated code is so broken that it can no longer connect to MQTT. So you'll want to be careful and test your changes.

Any file can be updated not just python so can also update configuration text or JSON files, etc. If you're updating multiple python files you probably don't want to request a reboot until they are all updated.

How it works

We need some way to get the new code on the device. Since it seems most of my networked projects use MQTT I figured I'd use that to deliver the new code. No need for a separate web server. If we just put the contents of the new file into a topic then we wouldn't know what file we want to update and whether it should reboot after the new code was there.

Headers

We basically just need some metadata along with the file contents. I thought about putting the file contents in a field in a JSON document but there would be too many special characters that would be a pain to escape. Base64 encoding would also be a pain and make the content a good bit larger. In the end I just went with some header lines in a specific format (# OTA::) that let you pass arbitrary name/value pairs.

# OTA:file:main.py
# OTA:reboot:true
from machine import Pin
import time
...

MQTT code

The application code just needs to listen to an OTA topic of its choice and pass those messages to the code in this project. It will parse the headers, write the file, and maybe reboot.

    if topic == self.ota_topic:
        ota.process_ota_msg(msg_string)

Code

Getting Started With Micropython

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

This project's code

Micropython code to read updated code via MQTT and update the ESP32 filesystem - GitHub - scarey/simple-ota-updater: Micropython code to read updated code via MQTT and update the ESP32 filesystem

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

Copy main.py, ota.py, and mqtt_handler.py to the root of the ESP32. The example will blink the LED at 1 second intervals. Modify main.py to with any changes you want. Maybe change the "version" variable to 2 and "led_sleep_time" to 0.5 and publish the contents of main.py to esp32/otatest/ota. The new code should be written to main.py and the ESP32 rebooted. The LED should blink at 0.5 second intervals and esp32/otatest/version should be updated to 2. Cool.

Notes

Any other headers that might be handy?

Awning Control

Stephen Carey — Wed, 05 Jul 2023 17:21:53 GMT

My deck gets a lot of sun so I figured an awning might help with the glare and keep it cool enough let me and the doggies walk around without getting 3rd degree burns. I ordered a highly rated one off Amazon, installed it, and quickly got to witness how the wind threatens to tear it right off the house. After that I was almost afraid to use it...maybe I'd forget to close it and later find it and my fascia board in my neighbor's yard. Time for some technological help. My main goal was to automatically close the awning if it got too windy and that of course meant motorizing it. Fun!

The main features are:

Auto-close based on an accelerometer
MQTT to allow integration with Home Assistant or other front ends and monitoring systems
Automation (Node-RED) to automatically close it at night (maybe open in the morning if there's rain or sun in the forecast?).
No permanent modifications to the awning

Supplies

ESP32 Mini, ESP32 development board, or whatever ESP32 you prefer
24V high torque motor
BTS7960 high power motor driver
GY-521 - Accelerometer/Gyroscope
2x reed switches
8mm to 10mm shaft coupler
5/16" stainless eye screw (~8mm) depending on your awning
Awning - mine is 13'x8' though they also have 10'x8' and 12'x10' but you'd have to check if the opening mechanism is the same.
24V Waterproof power supply
Buck converter
Waterproof project box
Dielectric grease - optional but will help protect the reed switch contacts
Various wire - At least 15' of 4 conductor wire for the accelerometer, maybe 10' of 2 conductor wire for the reed switches, dupont wires for the motor controller, etc.
Motor mount and various hardware - I used some PVC board I had lying around but PT or stained wood would work too

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

Forgive my Fritzing skills. Right-click and open in new tab to see a larger version.

Assembly

I didn't want to permanently modify the awning so if I sell my house or something I can just revert things back to using the hooked rod. The eye the hooked rod goes through is riveted on so I needed to figure out a way for the motor to turn the eye. In the end I decided to make a hook that could be attached to the motor using a coupler. To make sure the grub screws in the coupler would hold I used some Loctite and also used my drill press and drilled dimples in the hook where the grub screws made contact. There is a good amount of pressure on the coupling especially when closing so drill in as far as you can and use longer screws to make the connection as solid as possible.

For the motor mount I used a scrap piece of PVC board I had laying around and drilled 3 holes for the bolts that secure the motor and one for the coupler.

The close reed switch was easy with the switch on the awning frame near the house and the magnet zip tied to an arm. The open reed switch I put at the elbow of the arm with a short extension since the arms don't make a straight line when fully opened.

The accelerometer I placed at the end of an arm. The code just adds up the XYZ acceleration so you don't need to worry about orientation. I initially didn't weatherproof the accelerometer at all and it lasted about 2 years. I've current got a poor man's setup with a Ziploc bag and desiccant pack and I'm curious to see how long that will last. Once that dies I'll try some marine epoxy or maybe just print a small enclosure.

Neat wiring is not my strong suit

Code

Getting Started With Micropython

MPU6050-ESP8266-MicroPython

GitHub - adamjezek98/MPU6050-ESP8266-MicroPython: Simple library for MPU6050 on ESP8266 with micropython

Simple library for MPU6050 on ESP8266 with micropython - GitHub - adamjezek98/MPU6050-ESP8266-MicroPython: Simple library for MPU6050 on ESP8266 with micropython

GitHubadamjezek98

https://github.com/adamjezek98/MPU6050-ESP8266-MicroPython

Grab mpu6050.py and upload that to your ESP32.

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/awning-control: Micropython code for controlling a motor to open/close an awning and automatically close it when it’s too windy.

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

This project's code

Micropython code for controlling a motor to open/close an awning and automatically close it when it's too windy. - GitHub - scarey/awning-control: Micropython code for controlling a motor to op…

Instructions on how to connect Alexa/Amazon Echo to Home Assistant.

Copy main.py and bts7960.py to the root of the ESP32.

Configuration

Publish your config (with retain) to the "esp32/awning/config" topic. "windThreshold" is the value the sum of the accelerometer changes needs to be above to trigger the close. Increase it if you think it's closing when it's not that windy or decrease it if it's getting blown around and not closing. You can check the value history in an MQTT client. The "sampleFrequency" is how ofter to check the wind readings. I've been using 3 seconds and it seems to work well.

{"windThreshold": 2400, "sampleFrequency": 3}

Home Assistant

I'm just using the MQTT Cover and sensor interfaces and default widgets to control things and see what the wind readings look like.

mqtt:
  cover:
  - unique_id: 'awning'
    name: "Deck awning"
    command_topic: "esp32/awning/set"
    state_topic: "esp32/awning/state"
    availability:
      - topic: "esp32/awning/availability"
    payload_open: "open"
    payload_close: "close"
    payload_stop: "stop"
    optimistic: false
  sensor:
  - unique_id: awningvib
    name: "Awning wind"
    state_topic: "esp32/awning/readings"
    unit_of_measurement: "XYZ sum"
    value_template: >-
      {%- set parts = value[1:-1].split(",") -%}
      {{ int(parts[0]) + int(parts[1]) + int(parts[2]) }}

Alexa

If you managed to configure Alexa for your Home Assistant then congrats! It's kind of a pain as seen here:

Amazon Alexa

Home AssistantHome Assistant

But once you have completed said suffering controlling your awning with Alexa is as simple as:

alexa:
  smart_home:
    locale: en-US
    endpoint: https://api.amazonalexa.com/v3/events
    filter:
      include_entities:
        - cover.deck_awning
    entity_config:
      cover.deck_awning:
        name: "Awning"

Notes

You need to be very careful while you're testing. If the close reed switch isn't working right the motor will keep trying to close and put a lot of strain on everything. If the open reed switch isn't working the spool will completely unwind and begin winding with the fabric on the underside of the spool which will stress the fabric against the middle roller. Be prepared to pull the plug while you're testing!
I've had the awning motorized for 3 years now. I just needed to replace the fabric and you can contact the seller on Amazon and it cost $45 shipped. Not bad.
The loop that the hooked pole goes through is riveted on but last year the rivet rusted off. If I had to do this again I'd probably try to couple the motor straight to the post where the loop was but I ended up just putting a nail through where the rivet was and keeping the loop. But it may be simplest to just remove the eye from the start.
I could add a rotary encoder and then exact positioning could be used, e.g. open the awning to 75%. Maybe magnets and hall effect sensors like in the Ultimate Garage Door Control.
9/7/23 - I just updated to Home Assistant 2023.9.0 and it didn't like how I was separating the acceleration values so I updated the config above to combine XYZ into a single number.

Temperature Controller

Stephen Carey — Sun, 11 Jun 2023 12:00:55 GMT

I used to brew at my neighbor's place and we'd ferment in his unfinished basement. We'd have trouble keeping the fermentation temperature up when it was cold out and we ended up putting a shop light underneath the fermenter to try warming things up. Obviously that wasn't a great solution and I ended up using an ESP8266, relay, and temperature probe to control the shop light. That was years ago and I thought it could use a refresh. Out with the shop light and in with a heating belt. I've added a separate relay for controlling a cooling system, support for fermentation temp schedules, adjustable temp differential, compressor delay, and all the fun data is available via MQTT. A controller with similar features goes for $75 and has no network connectivity.

This project requires dealing with AC wiring which is dangerous if you're not careful.

Supplies

ESP32 development board, ESP32 Mini, or whatever ESP32 you prefer
2x Single channel relay - I like these since they trigger high
Waterproof thermal probe - this kit comes with the 4.7k resistors you'll need
Thermowell - maybe something like that depending on what works for your fermenter
Fermentation heater - or something similar
Fermentation cooler - I figure a cooler full of ice water and a pump to circulate through the coil. Another option is a fridge
AC wall outlet and cover
14 gauge extension cord (or the cord from a power strip or dead UPS you might have lying around) 16 gauge would also work as long as you're not heating or cooling with something that uses lots of watts. Just don't forget later on when you decide a blow dryer might work really well...:)
Wire nuts

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

Assembly

A double gang old work box works well, provides strain relief, and has plenty of room for the ESP32, relays, and outlet. Take the 14 gauge extension cord and cut off the female end. You'll be left with the male end and the cut end with 3 wires, hot, neutral and ground. If you don't have any spare 14 gauge wire to use for pigtails you can cut some out of the extension cord. You'll need 4 short pieces (2 to split the hot so they can go to the C terminals on the relays, and 2 out of the relay NO to the outlet). A wire nut is a good way to connect the hot wire to the 2 pigtails. Strip about 6" of the outer insulation and push the 3 wires through a strain relief tab in the box until a little of the outer jacket enters the box. Wire the 3 wires to the outlet as show in the diagram above. Push the temp sensor wire through another strain relief tab on the opposite side of the box and connect it to the ESP32. Connect the relays to the ESP32. I guess you could use an AC/DC converter to power the ESP32 but I just ran a USB cable into the box and power it separately.

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/temp-control: Micropython code for heating/cooling control including temp schedules and compressor delay

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

datetime

Grab datetime.py and upload it to the root of the ESP32.

This project's code

Micropython code for heating/cooling control including temp schedules and compressor delay - GitHub - scarey/temp-control: Micropython code for heating/cooling control including temp schedules and…

How to tell direction of rotation using X2 hall effect sensors?

Configuration

config.py contains a constant where you define the base topic name. I'm using "esp32/conical5g" for this example. If you want to have more than one controller you would just give them different base topics.

Publish your config (with retain) to the "esp32/conical5g/config" topic. "lowTempLimit" controls when the heat relay will active and "highTempLimit" does the same for cooling. Keep them at least 1 degree apart to keep the heating and cooling from fighting. Add 0 or more "tempChanges" if you'd like the temp limits to auto adjust based on how many days after the "startTimeUTC" it is. The code uses NTP to make sure it knows the correct date and time.

{
  "startTimeUTC": "2023-05-31T12:00:00",
  "lowTempLimit": 64,
  "highTempLimit": 66,
  "minimumOffMins": 3,
  "tempChanges": [
    {
      "daysLater": 2,
      "tempChange": 2
    },
    {
      "daysLater": 3,
      "tempChange": 4
    }
  ]
}

esp32/conical5g/config

You can also tweak the config and publish at any point and the changes will immediately apply.

Home Assistant

I use some simple MQTT config so HA can display the current data.

Configuration

mqtt:
  sensor:
  - unique_id: ferm0temp
    state_topic: 'esp32/conical5g/status'
    name: '5 gallon fermenter temperature'
    unit_of_measurement: 'Â°F'
    value_template: "{{ value_json.currentTemp }}"
  - unique_id: 'ferm0heat'
    name: '5 gal fermenter heating'
    state_topic: 'esp32/conical5g/status'
    value_template: >-
      {% if value_json.heatOn == 0 %}Off
      {% elif value_json.heatOn == 1 %}On
      {% endif %}
  - unique_id: 'ferm0cool'
    name: '5 gal fermenter cooling'
    state_topic: 'esp32/conical5g/status'
    value_template: >-
      {% if value_json.coolOn == 0 %}Off
      {% elif value_json.coolOn == 1 %}On
      {% endif %}
  - unique_id: ferm0low
    state_topic: 'esp32/conical5g/status'
    name: '5 gallon fermenter low limit'
    unit_of_measurement: 'Â°F'
    value_template: "{{ value_json.lowTempLimit }}"
  - unique_id: ferm0high
    state_topic: 'esp32/conical5g/status'
    name: '5 gallon fermenter high limit'
    unit_of_measurement: 'Â°F'
    value_template: "{{ value_json.highTempLimit }}"

Notifications

There are lots of options here based on the 5 pieces of data that get published every minute. Whether the heating or cooling are active, the current limits, and the current temp are available.

Current temp is a certain number of degrees outside the limits
Heating and cooling are both on? That could be a bug in the code or messed up configuration.
Controller went offline (esp32/conical5g/availability topic)
Schedule changed the limits
Large change in the current temp

Node-RED is my favorite way to set these up but HA automations will work too.

Historical Data

Zabbix

This was from my old heat only setup. The top graph is the outside temp, the middle is the beer temp, and the bottom is calling for heat. My neighbor forgot to turn the shop light on until 6/9. After that the temp was very stable.

InfluxDB

For the upgrade setup I'm using Telegraf to import the 5 pieces of data into InfluxDB. Here's the Telegraf config:

[[outputs.influxdb_v2]]
  urls = ["http://:8086"]
  token = ""
  organization = ""
  bucket = "iot"

[[inputs.mqtt_consumer]]
  servers = ["mqtts://:"]
  topics = [
    "esp32/conical5g/status",
  ]
  qos = 0
  username = "telegraf"
  password = ""
  insecure_skip_verify = false
  data_format = "value"
  data_type = "string"
  topic_tag = ""
  [[inputs.mqtt_consumer.topic_parsing]]
    topic = "esp32/conical5g/status"
    tags = "source/_/_"
    measurement = "_/what/_"

  [[processors.starlark]]
     namepass = ["conical5g"]
     script = "/scripts/tempcontrol.star"

Sample telegraf configuration

You'll also need the Starlark processor script that parses the JSON payload. Save it to the "script" path in the telegraf config ("/scripts/tempcontrol.star" for mine).

load("json.star", "json")
 
def apply(metric):
   j = json.decode(metric.fields.get("value"))
   metrics = []

   new_metric = Metric("conical5g")
   new_metric.fields["temp"] = float(j["currentTemp"])
   new_metric.fields["low"] = float(j["lowTempLimit"])
   new_metric.fields["high"] = float(j["highTempLimit"])
   new_metric.fields["heating"] = int(j["heatOn"])
   new_metric.fields["cooling"] = int(j["coolOn"])
   new_metric.tags["unit"] = j["tempUnit"]
   metrics.append(new_metric)
  
   return metrics

Telegraf converts the JSON payload to the line protocol that InfluxDB likes. It looks something like this (measurement, tags, fields, timestamp):

conical5g,unit=F temp=73.7375,low=80,high=82,heating=1i,cooling=0i 1686452040495794428

InfluxDB

This was from the test setup on my couch and not connected to any heating/cooling. In the upper graph the orange is the current temp (my dog sat on the sensor and made that 90 degree spike) and the blue and purplish lines are the temp limits. The bottom graph shows when the cooling and heating are active.

Notes

Now I just need to do some brewing...

Ultimate Garage Door Control

Stephen Carey — Mon, 29 May 2023 20:31:10 GMT

I've had an Insteon Garage Door Control and Status kit for over a decade and I have never trusted it. It consists of an Insteon controllable relay and a single reed switch that could tell you if the door was closed. It would occasionally stop opening after about a quarter of the way and with the single reed switch the interface indicated everything was great even though the neighbor you were trying to remotely let in had to do some crawling. Integration with Alexa is done via my ISY994 (just discontinued) and when Alexa recently decided to ignore one of my doors I thought I should ~~waste~~ spend some time looking for a new solution.

After motorizing the awing over my deck and integrating it with Home Assistant's MQTT Cover interface I noticed it supported positioning so it could tell you exactly what percent open it was if you could somehow supply that info. I knew then I wanted to track whether the garage is opening/closing, what percent opened/closed it is, if it got stuck in the middle, and whether it's definitely fully opened or closed. And with many other ways of controlling things (car clickers, wall controls, outdoor keypad, safety sensors, and previously mentioned ISY control) I didn't want the code to assume it knew what was going on, just accurately report the current state of things.

I decided on a couple reed switches so I could tell for certain when it was fully open or fully closed and planned to measure the rotation of the sprocket (mine's chain driven though should similar for belt and might need some creative magnet placement for screw) with some magnets and hall effect sensors. A DIY rotary encoder I guess. From the direction of rotation we can determine whether the door is opening or closing and its position based on the rotation count. Toss in a relay, ESP32 and some micropython code and the next stop should be the Ultimate Garage Door Control.

See it in action below. Obviously a run-away scooter is no match for the Ultimate Garage Door Control...

0:00

/0:45

Home Assistant custom cards. No cats were harmed during the production of this video.

The rotation and position sensing could also be useful (perhaps more useful since you'd rarely want to open your garage 30%...) for control of other covers such as awnings, etc.

Supplies

ESP32 development board, ESP32 Mini, or whatever ESP32 you prefer (can handle up to 3 garage doors)
2x Reed Switches per door
2x Hall Effect Sensors per door
Small magnets - at least 2x per door depending on mounting (6x per door for me, 8x for quadrature encoding)
Single channel relay or Mini Relay Shield - 1x per door, though a 2 channel relay simplifies things for a 2 door setup
Extension wire - this is handy for the reed switches
CAT6 cable - optional, handy for 8x 23 gauge wires to a second door
Dupont wires

When you purchase through links on this site, I may earn an affiliate commission.

Which way is the door really moving?

Maybe new garage door controllers are smart let you know exactly what's going on but mine is dumb. Let's face it...with my only interface to the garage door being a button, all I can command it to do is "GO" and it decides based on its internal state what it should do. Here's what my Chamberlain Liftmaster Professional will do when you press the button:

Open if fully closed, close if fully opened (perfect)
Stop if it was opening, open if it was closing (interesting)
Close if it was stopped (makes sense after the above bullet)

I figured if I could detect the direction it was moving and whether it was fully opened, or fully closed I'd be in great shape to build some smart controls. Fully opened or closed? Pretty simple. Moving and in what direction? Hmmm. After some googling I found posts 9 and 17 here:

Not when the pulses don’t overlap. On both A edges the B input will be LOW. On both B edges the A input will be LOW. I can see how it might work if the pulses overlapped. The “rising” edge of A would have B LOW in one direction and B HIGH in the other. The “falling” edge would have the opposite…

Arduino Forumaltha

It was very helpful and offered 2 basic ways of figuring out direction of rotation. One way for each of my garage doors...lovely! Both ways involve 2 hall effect sensors with one way using timing and a single magnet, and the other using 2 magnets and precise positioning. If you think you can achieve the precise positioning for your setup then go with the quadrature encoding, otherwise the timing based method is perfectly good too. The config.json let's you specify which rotation algorithm you want per door.

There were some good comments on Hackaday about other ways to detect direction of movement using an Absolute Value Encoder or magnetic or inductive proximity switches though it's likely you'd have to update the rotation code.

Wiring

There's are good amount of wiring to be done...2 per reed switch, 3 per hall effect sensor, 5 per relay so 15 per door. 5 are ground, 3 are power, 5 are IO, and 2 for the garage opener relay.

Relay Wiring

On the relay you need wires from NO (normally open) and C (common). You'll have to find the contacts on the opener that will trigger the door. See assembly pics below for what mine looked like. If you can follow a wire from the wall buttons wherever that wire goes would be the terminals you want. For a proper connection you should pigtail the new relay wires to whatever wires are currently connected. I didn't bother with a latching relay since I figured the opener itself would lose power along with the relay. If you are worried about the relay accidentally triggering when the ESP32 loses power then feel free to tweak the code and get a latching relay instead. I just noticed the single channel relays I link to above let you set whether to trigger high or low and default to high. The trigger high won't have the problem of triggering when the ESP32 loses power but you'll have to change the code to initialize to low and the trigger code to set high then low.

Additional doors

The ESP32 has enough IO to handle 3 doors though the farther away they are the more you'll need to worry about wire gauge. Power-wise you can add a 5v source closer to the other doors, just make sure to run that ground back to the ESP32 as well. You can also put an ESP32 at each door and would just need to adjust the base topic name.

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/ultimate-garage-door-control: Micropython code for controlling your garage door including direction and position sensing.

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

This project's code

Micropython code for controlling your garage door including direction and position sensing. - GitHub - scarey/ultimate-garage-door-control: Micropython code for controlling your garage door includi…

Clip for garage door tracks by fantadler

Grab *.py and upload them to the root of the ESP32. Copy config.json.example to config.json and update the pin config if necessary and the "clockwiseOpen" and "quadrature" based on your installation. Upload the config.json to the root of the ESP32. To change the relay timing and the number of rotations it takes to fully open/close the door you publish a JSON document to the esp32/garage/config topic and code will reconfigure on the fly.

{
  "relay_ms": 500,
  "full_rotations": 21
}

Assembly

A lot of the assembly depends on your garage door setup. For the door reed switches I put the closed switch at the top center and the opened switch on the rail using a 3d printed rail bracket. You'll have to figure out what works best for your setup.

Recently bought a smart garage door opener that required a magnetic sensor to determine closed state. The magnetic sensor comes in pairs. One screwed into the garage door wood frame and the other taped to the door track. The double sided tape didn’t really work. Too many vibrations and it fell off a…

A gantry crane for loading and unloading train cars. The CAD drawings are of the latest version, which match the STL files. The pictures of the printed crane are of my first version. The main difference are improvements to the winch.

I was trying to figure out a good way of placing the hall effect sensors above the sprocket and my initial thought was something like helping hands. I don't remember how but I ended up finding this gantry crane for model trains and thought this could work!

Gantry Crane by nrandal

Hall Effect Sensor Case Wheel Speed Sensors by UCI_FSAE_3DPrinting

I modified the legs to be shorter and accept magnets to keep it solidly attached above the sprocket. I'll post that STL file below. I printed a carriage for each sensor and a small case to hold the sensor and taped that to the carriage.

Short gantry leg

short_gantry_leg.stl

29 KB

This case is used to enclose KY-003 hall effect sensors to be used as wheel speed sensors. The headers were removed from the board and wires were soldered on. A trigger wheel with magnets is attached to the hub on the inside of the upright and the wheel speed sensor is bonded to the upright itself w…

GitHub - marcelhoogantink/enhanced-shutter-card: A Enhanced Shutter Card for Home Assistant

A note of warning: It's a good idea to unplug the opener while working near the drive mechanism. My sprocket has a protective cover that I had to remove. You'll have to be extra careful now and in the future as the sprocket is more exposed than it would normally be.

Magnet positioning

Timing algorithm

With the timing based method you can place a single magnet (I double stack them for a stronger magnetic field and to allow the sensors to be farther from the sprocket) anywhere near the outer edge of the sprocket. You want to offset the hall effect sensors so they are closer to the edge of the sprocket. In general you want the magnet to trigger one sensor and then the second after about 90° rotation. The remaining 270° shouldn't trigger anything. Positioning isn't that important as long they don't trigger close to 180° apart.

Quadrature encoding algorithm

You need two magnets on opposite edges of the sprocket. Try to arrange them in a perfect line across the center of the sprocket. Place the hall effect sensors above them then push one magnet a little to one side. The goal is to make sure the sensors are triggering in the proper pattern A on, B on, A off, B off. You may need to adjust the magnets a little more until it works. And if you don't want to bother with such precision the Timing algorithm works just fine.

Home Assistant

MQTT Cover config

mqtt:
  cover:
  - unique_id: 'garage0'
    name: "Dads Garage"
    command_topic: "esp32/garage/0/set"
    position_topic: "esp32/garage/0/position"
    state_topic: "esp32/garage/0/state"
    availability:
      - topic: "esp32/garage/availability"
    payload_open: "open"
    payload_close: "close"
    payload_stop: "stop"
    optimistic: false

Custom Cover module

A Enhanced Shutter Card for Home Assistant. Contribute to marcelhoogantink/enhanced-shutter-card development by creating an account on GitHub.

GitHubmarcelhoogantink

The default cover card should work fine but this module is much cooler than that since we have exact position information and it can show exactly how much the door is open in real time. The card config looks something like this. You would need to tweak the state settings if your garage doesn't behave like mine.

type: custom:enhanced-shutter-card
entities:
  - entity: cover.dads_garage
    name: Dad's Garage
    buttons_position: left
    title_position: top
    stop_disabled_states:
      - open
      - closed
      - closing
    up_disabled_states:
      - open
      - opening
    down_disabled_states:
      - closed
      - closing
      - opening

Stopped state

The Home Assistant cover interface doesn't support the stopped state as an end state. It assumes stopped means that it finished whatever the last action was. For my garage door's behavior it would make more sense to have stopped as a real end state so I could disable up and stop actions when the door is stopped. As it is, it will show the stop and close buttons when it's stopped and pressing either will make the door close. Oh well, maybe I need to put in a request for a new Home Assistant cover feature.

Notification options

MQTT makes it easy to setup notification for whatever you want.

I've got some Node-RED automation that texts me if the garage doors are open at midnight. I should probably just change that to send a closed to the doors at midnight. The safety sensors should prevent squashing anyone.
You could also set up a rule to let you know if the door is open for more than a certain amount of time.
Simple opened/closed notifications if you are interested knowing every time there's a state change

Alexa

I guess I'd have to recommend the Home Assistant Cloud even though it's $65 a year. The DIY part of me is unhappy but the manual integration is not for the faint of heart. I did get things working and it helped that I have already developed some simple Alexa Skills. Here's the guide showing both options. If you're using something other than Home Assistant there might be simpler/cheaper integration.

Amazon Alexa

Instructions on how to connect Alexa/Amazon Echo to Home Assistant.

Home AssistantHome Assistant

alexa:
  smart_home:
    locale: en-US
    endpoint: https://api.amazonalexa.com/v3/events
    filter:
      include_entities:
        - cover.dads_garage
        - cover.moms_garage
    entity_config:
      cover.dads_garage:
        name: "Dads Garage"
      cover.moms_garage:
        name: "Moms Garage"

Notes

A LoRa based clicker for the car would be cool. The range on my normal car clicker is pretty poor.
I should integrate the rotation stuff with my awning controller.
Now that I'm exhausted from pressing garage buttons and telling Alexa to open and close the garage I'm thinking it would be cool if the door would auto-close once it detects the car left. And I guess auto-open when it gets back home. Some kind of proximity sensor in the car...how does the Bat Cave work anyway?

Time-lapse - Intervalometer

Stephen Carey — Sun, 30 Apr 2023 15:39:30 GMT

I guess one of the few good things about COVID is you find new stuff to do while you're stuck at home. I had previously taken some decent pics of a blood moon and while I was googling the best camera settings to use for that I came across stuff about star trail photography. It turns out the best way to get a good one is to take a lot of pics over time and stitch them all together. It's like time lapse photography except you take all the photos and combine them into one instead of making a movie or something out of all the individual pics.

And the best way to do that is with an intervalometer, which is basically an automated shutter release. Tell it to press the shutter button for 30 seconds and release...and repeat that 100 more times please. A little bit more googling and it turns out I just need to complete the circuit to the shutter release pin on my Canon DSLR camera...sounds like a piece of cake!

The tricky part is mainly what kind of interface you want to dial in your settings. How long to hold the shutter open, how much of a delay between pics, and how many pics to take? Battery life could be a concern depending on how long of a time lapse you have in mind. I just needed something that could last an hour or so to get star movement like you see above.

I'd guess the camera built into your phone wouldn't do a great job with these dark, long exposure pics. What we'll be building here is for SLR cameras with a manual shutter release option.

Disclaimer: I've tested this with my Canon 6D but you need to verify the pinouts for the camera you have!

Facing north

There's a cool looking dilapidated house from the 1800's(?) a little right of center at the bottom but it came out completely black. I think I'll try it again and shine a flashlight on it in a frame at the beginning of the time-lapse.

Supplies

I'm tempted to suggest some ESP32 dev board with a built in display but I'm just going to describe what I've already got working.

FireBeetle ESP32 - very good for low power consumption
KY-040 Rotary Encoder - For selection of config options
OLED Display - 0.96" 128x64 - Display config menu and status
Battery with JST connector - or something similar (the FireBeetle has built-in charging circuitry for a solar panel, etc.) You also need to be careful as sometimes the +/- the FireBeetle wants are swapped on the battery.
Optional - JST wires - I used these to make an adapter to switch the battery +/- instead of permanently rewiring the battery
Optional - LiPo battery charger - you can plug a USB cable into the FireBeetle and it will charge the attached battery. This will work if you want an external charger for whatever reason.
Optional - Solar panel - this is an option for a long timelapse session during the day
Shutter release - get a cheap one since we just want the camera connector. This works for my Canon camera. I would assume other camera manufacturers are similar but you'll need to figure out what pinouts are right for your brand/model.
Optocoupler - this provides a small measure of isolation between the ESP32 and the camera and could protect the camera in case of a short circuit.
Dupont wires
Multimeter - helpful for finding the correct shutter release wires
Soldering iron

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

ssd1306 driver

Grab that from here and upload to the root of the ESP32.

micropython-rotary

GitHub - miketeachman/micropython-rotary: MicroPython module to read a rotary encoder.

MicroPython module to read a rotary encoder. . Contribute to miketeachman/micropython-rotary development by creating an account on GitHub.

GitHubmiketeachman

Grab rotary.py and rotary_irq_esp.py and upload them to the ESP32.

GitHub - sgall17a/encodermenu: Simple GUI menu for micropython using a rotary encoder and basic display.

Simple GUI menu for micropython using a rotary encoder and basic display. - GitHub - sgall17a/encodermenu: Simple GUI menu for micropython using a rotary encoder and basic display.

GitHubsgall17a

For reference only. The configuration isn't well decoupled so I've included a modified copy in my repo below.

This project's code

GitHub - scarey/time-lapse: Micropython code for taking time-lapse photos with your SLR

Micropython code for taking time-lapse photos with your SLR - GitHub - scarey/time-lapse: Micropython code for taking time-lapse photos with your SLR

Star Trails Photography in 7 SIMPLE Steps [2023]

Grab main.py and encoder_menu.py and upload them to the root of the ESP32.

Assembly

Cut the shutter release cable a few inches below the controls. I figured having that few inches would make it easier to re-use the controls for some other project.
Find your camera's shutter release pinouts. You need to determine the ground and shutter pins. A lot of info can be found here: https://web.archive.org/web/20250216001855/http://doc-diy.net/photo/eos_wired_remote/
Figure out which wires are shutter and ground in the shutter release cable you cut. The multimeter comes in handy here along with a staple or some other thin piece of metal to poke into the small holes in the shutter release connector.
Solder the optocoupler (orient so the small dot in the corner is at the top left) :
- pin 1 (top left) - to IO25 on the FireBeetle.
- pin 2 (bottom left) - to ground on the FireBeetle.
- pin 3 (bottom right) - to ground wire of shutter release cable
- pin 4 (top right) - to shutter release wire of shutter release cable
Connect the OLED display and rotary encoder as shown in the wiring diagram.

Camera Settings

A great reference is:

In this guide, you’ll learn star trails photography in 7 simple steps. See what’s working in 2023 for: Camera settings Equipment Shooting locations And more Scroll down & get started... Table of Contents Click on the section of your choice or scroll down & rea

Dave Morrow Photography

The intervalometer settings I use are 100 pictures, 30 second exposure, 1 second delay in between and the camera set to:

Shutter speed: Manual/Bulb
Aperture: 2.8 if no moonlight, 5.6 if some moonlight
ISO: 300
Manual focus - infinity works well for me though there are devices like this to help with accurate focus. See below.

Bahtinov Mask for astro-photography by adibadro

Perfect for astro-photography! If your camera has a long lens, enough pixels and you enjoy the night sky, this is for you! Based on a 58mm Canon lens cap. Should fit any camera lens by resizing it in the XY plane. Easy to use: place it on the lens point towards a bright object manually focus for the…

StarStaX – Markus Enzweiler

Software

I liked this free software that can stitch the individual photos together. I used Blending Mode -> Gap Filling but feel free to play around with the settings.

Mail's Here!

Stephen Carey — Mon, 24 Apr 2023 00:54:50 GMT

I can't see my mailbox from my house so I thought it might be nice to get a notification when it opens. Initially I had an ESP32 connecting over WiFi but it had poor signal strength and I wanted to try LoRa and it's working well. I added a solar panel and rechargable battery and use deep sleep mode and it's been running itself for months. I'm using Micropython, MQTT, Node-RED, and Twilio.

Supplies

Lora Dev Boards

You need one board to transmit and another to receive. If you already have a LoRa Gateway (I don't) then you would only need 1 dev board. You also need to make sure you get a board that uses the frequencies allowed in your country. See here for what frequencies are allowed in what countries.

Make sure to attach the LoRa antenna before powering up! Not having the antenna connected can damage the LoRa chip.

For the US and others this board does 868 or 915MHz:

2x ESP32 Development Board SX1262 868 915MHz LoRaWAN

See some other frequency options can be found here:

2x WiFi LoRa 32 (V3)

Common components

Reed switch
3.7V 1100mAh Lithium Rechargeable Battery Micro JST 1.25 or the LoRa boards come with a JST 1.25 wire connector you could attach to some other rechargable battery like an 18650 but you should get something with built-in charge protection.
Optional Solar panel
Soldering iron - The dev board comes without the header pins soldered. The solar panel would also need some wire soldered on.

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

The Heltec dev board is pretty cool with the integrated display and battery charging though the documentation was lacking. For the V3 board even the pinout diagram was incorrect but hopefully they'll fix it soon. I looked through the Meshtastic firmware code to find the correct ports for the display and SX1262 LoRa module.

Only the sender board near the mailbox needs any wiring. The receiver board simply relays anything it gets from the transmitter to MQTT.

The only required wiring is for the reed switch. One wire from the reed switch normally open goes to pin 6 and the other wire to ground.

The solar panel I wired into 5V and ground.

Code

I made the receiver code generic and it will pass whatever LoRa messages it receives to a default MQTT topic or if the message contains a "source" field it will use that as the sub topic. I figure some future project might need long range wireless and I wanted to be able to re-use the same receiver.

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

micropySX126X

GitHub - ehong-tl/micropySX126X: Semtech SX126X LoRa driver for Micropython and CircuitPython.

Semtech SX126X LoRa driver for Micropython and CircuitPython. - GitHub - ehong-tl/micropySX126X: Semtech SX126X LoRa driver for Micropython and CircuitPython.

GitHubehong-tl

Grab sx1262.py, sx126x.py, and _sx126x.py, make the changes sx126x.py described below, and upload them to the root of the ESP32 without the subdirs.

6c6
<     from machine import SPI, Pin
---
>     from machine import SoftSPI, Pin
44c44
<               self.spi = SPI(spi_bus, mode=SPI.MASTER, baudrate=2000000, pins=(clk, mosi, miso))        # Pycom variant uPy
---
>               self.spi = SoftSPI(spi_bus, mode=SPI.MASTER, baudrate=2000000, pins=(clk, mosi, miso))        # Pycom variant uPy
46c46
<               self.spi = SPI(spi_bus, baudrate=2000000, sck=Pin(clk), mosi=Pin(mosi), miso=Pin(miso))   # Generic variant uPy
---
>               self.spi = SoftSPI(baudrate=2000000, sck=Pin(clk), mosi=Pin(mosi), miso=Pin(miso))   # Generic variant uPy

Receiver only: micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/mail-is-here: Micropython code for sending notifications when your mailbox opens.

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

config['server'] = ''

config['ssid'] = ''
config['wifi_pw'] = ''
config['ssl'] = 
config['port'] = 
config['user'] = ''
config['password'] = ''

Sample mqtt_local.py updates.

Receiver only: ssd1306 driver

Grab that from here and upload to the root of the ESP32.

This project's code

Micropython code for sending notifications when your mailbox opens. - GitHub - scarey/mail-is-here: Micropython code for sending notifications when your mailbox opens.

Heltec WiFi LoRa 32 (V3) minimal case, more room for antenna cable by mrtamer

Grab jram.py and either sender or receiver main.py and upload them to the root of the ESP32.

Mounting

Figure out a good spot for the reed switch. I put the magnet on the left side of the lid near the hinge and the switch nearby on the body.
Stuff the ESP32 and battery in a small project box. I used double sided tape and mounted the box under the mailbox.
I 3D printed some bits and pieces to mount the solar panel behind the mailbox.

I slightly modified the great original design to fit the 10cm antenna cable better to the enclosure.

Waterproof electronic box / enclosure by pbtec

Cute case for the receiver

Well there’s still folding and stuff left but getting notified when the washer/dryer cycle finished was one of my first projects and is a big hit with the wife. An accelerometer detects when motion has ceased and sends a notification. I’m using micropython with an ESP32, MQTT, Home Assistant,

I used this near the mailbox

Notifications

See my Laundry's Done post for some notification options.

Laundry’s Done!

Scarey's TechStephen Carey

I use Node-RED to keep track of how many times the mailbox has opened each day and send a different message to different recipients. I included my kids in the hopes that they might actually be helpful and get the mail some days but they seemed to ignore them along with all my other texts. I included my neighbors on the first open of the day and they did appreciate that.

And one day I didn't get a package I was expecting via USPS and noticed that they said it was delivered 1 minute before I got my notification. I pinged my neighbor and sure enough he got it. Just a happy benefit of knowing when your mailbox opens.

Here's what my Node-RED flow looks like. Let me know if it could be improved...I'm not yet an expert:

Download the flow here:

Here's what the texts look like:

Notes

Feel free to tweak what's on the display and/or add display for the sender. I figured I would just stuff it somewhere out of sight though it's handy for initial debugging.

Ultrasonic Home Heating Oil Gauge

Stephen Carey — Wed, 12 Apr 2023 02:50:41 GMT

An ultrasonic sensor sends a sound pulse that bounces off the oil and returns to the sensor. The amount of time that it takes can be measured and based on the speed of sound you can figure out the distance. Neat. It's nothing as grand as the pic above, I'm just measuring the levels in my 275 gallon tank at home. I once caught the oil guy filling my tank and he was impressed when I guessed within 2 gallons of his fill reading.

I'm using micropython with an ESP32, MQTT, and Zabbix to keep historical data though I recently switched to InfluxDB.

Supplies

ESP32 Mini
HC-SR04 Ultrasonic Sensor
OLED Display - 0.91 Inch I2C SSD1306 (Optional, could be added later w/o much trouble)
Soldering iron
Dupont wires
Rubber packing sheet (1/16" - holds and seals the ultrasonic sensor)
PVC parts: male threaded adapter (bottom), cleanout adapter (top) for whatever size your tank needs. Mine was 2".
PVC Cement
Pipe Thread Sealant

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - rsc1975/micropython-hcsr04: Micropython driver for ultrasonic sensor HC-SR04

Grab mqtt_as/mqtt_as.py and mqtt_as/mqtt_local.py and upload them to the root of the ESP32 without the subdirs. We'll need to tweak mqtt_local.py with your WiFi and MQTT broker settings.

config['server'] = ''

config['ssid'] = ''
config['wifi_pw'] = ''
config['ssl'] = 
config['port'] = 
config['user'] = ''
config['password'] = ''

Sample mqtt_local.py updates.

micropython-hcsr04

Micropython driver for ultrasonic sensor HC-SR04. Contribute to rsc1975/micropython-hcsr04 development by creating an account on GitHub.

GitHubrsc1975

Grab hcsr04.py and upload it.

micropython-ssd1306 (optional if not using display)

GitHub - stlehmann/micropython-ssd1306: A fork of the driver for SSD1306 displays to make it installable via upip

A fork of the driver for SSD1306 displays to make it installable via upip - GitHub - stlehmann/micropython-ssd1306: A fork of the driver for SSD1306 displays to make it installable via upip

GitHubstlehmann

Grab ssd1306.py and upload it.

micropython-nano-gui (optional if not using display)

GitHub - peterhinch/micropython-nano-gui: A lightweight MicroPython GUI library for display drivers based on framebuf class

A lightweight MicroPython GUI library for display drivers based on framebuf class - GitHub - peterhinch/micropython-nano-gui: A lightweight MicroPython GUI library for display drivers based on fram…

GitHub - scarey/heating-oil-gauge: Micropython code for reading home heating oil levels with an ultrasonic sensor.

Grab drivers/boolpalette.py and gui/core/writer.py and upload them to the root of your ESP32 without the subdirs.

This project's code

Micropython code for reading home heating oil levels with an ultrasonic sensor. - GitHub - scarey/heating-oil-gauge: Micropython code for reading home heating oil levels with an ultrasonic sensor.

Scarey's TechStephen Carey

Historical Data

I have a old Zabbix server which has a couple years of oil data but I'm moving to InfluxDB and Telegraf for new projects. In the images above you can see a sample of each.

A dashboard with the outside temperature, thermostat call history, and oil tank levels can be very interesting to look at. Or maybe after your teenager just took a 45 minute shower you can take a peek at how much that just cost 🤦.

[[outputs.influxdb_v2]]
  urls = ["http://:8086"]
  token = ""
  organization = ""
  bucket = "iot"

[[inputs.mqtt_consumer]]
  servers = ["mqtts://:"]
  topics = [
    "esp32/oil/gallons",
  ]
  qos = 0
  username = "telegraf"
  password = ""
  insecure_skip_verify = false
  data_format = "value"
  data_type = "float"
  topic_tag = ""

[[inputs.mqtt_consumer.topic_parsing]]
  topic = "esp32/oil/gallons"
  tags = "source/_/field"
  measurement = "_/measurement/_"
  fields = "_/_/gallons"
  [[processors.pivot]]
    tag_key = "field"
    value_key = "value"

Sample telegraf configuration

Notifications

See my Laundry's Done post for some notification options.

Laundry’s Done!

An obvious notification would be when your tank meets some low level threshold and it's time to order a fill. A fun one could be a fill notification maybe using InfluxDB to detect a large increase over a short time. Or a more frightening large decrease over a short time!

Assembly

PVC

The ultrasonic sensor is mounted face down on a rubber disc with the transmitter and receiver pushed through holes in the disc. The rubber disc is inserted into the lower adapter and the cleanout adapter is cemented on top to form the enclosure. The ESP32 will be inside the cleanout and the whole thing will be screwed into an available spot in the top of the tank. The top plug will allow easy access to the ESP32 and the rubber disc isolates the oil from the majority of the electronics. Mine's been running non-stop for more than 3 years now.

Use the inside of the wide end of the lower adapter as a template (probably about 2.375") and cut a circle out of the rubber sheet. The goal is to have a rubber disc that can fit nicely inside the lower adapter.
Using the ultrasonic sensor as a template, center it on the newly cut rubber disc and mark a circle for the transmitter and one for the receiver. Cut those circles and insert the sensor into the holes. To give yourself more room you could change out the sensor pins so they point straight out the back of the sensor.
Connect your dupont wires to the sensor and insert the disc into the lower adapter as far down as it will go. Maybe use some thread sealant around the edge of the rubber disc if it isn't making a good seal.
Cement the cleanout adapter to the upper side of the lower adapter. I added some duct tape around the 2 pieces for some added elegance.
Drill a hole below the threads of the cleanout adapter so you can run the power wiring. I made a hole big enough to fit a micro USB cable through.
Remove a plug from the top of the oil tank, put some pipe thread sealant around the threads of the lower adapter of the enclosure and screw it on the tank.
Estimate how far the ultrasonic sensor is from the top of the inside of the tank and save that number for SENSOR_OFFSET in main.py.

Display mount (optional if not using display)

Figure out which side you want the power wiring to exit and drill another hole where you'd like the display.
You can 3D print the display mount that I modified if you like or come up with some other mount. You can grab it below.

OLED Oil

OLED display mount with a curved base that will be pretty flush with PVC column.

OLED-Oil.stl

59 KB

Notes

My tank is an upright 275 gallon tank that's pretty common for residential use in the US. The inches_to_gallons.py contains a dictionary of oil height in 0.1 inch increments to the number of gallons of oil that represents. If you're tank is different you'll have to create your own dictionary and also tweak MAX_INCHES in main.py which is used to detect bad readings. And of course rename stuff if you're using cm and liters, etc. You also don't need to go that crazy with the precision as long as you round the measurement to a value in the inches_to_gallons dictionary.
I've included some code to detect readings that seem off and do a retry. That seems to work well for my setup but you could change that to averaging multiple readings or whatever you think would work better.

Laundry's Done!

Stephen Carey — Mon, 03 Apr 2023 01:47:53 GMT

Well there's still folding and stuff left but getting notified when the washer/dryer cycle finished was one of my first projects and is a big hit with the wife. An accelerometer detects when motion has ceased and sends a notification. I'm using micropython with an ESP32, MQTT, Home Assistant, and Twilio to send text messages but you can adapt any or all of those to suit your needs.

Cute huh?

Supplies

GY-521 - Accelerometer/Gyroscope
ESP32 Mini - Perfect small package to mount the GY-521 on
Soldering iron
Double sided tape

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

There are no actual wires per se... Solder one of the female pin headers to the ESP32 Mini row that has VCC/GND. Then break off a 4 pin strip of male headers and solder that to VCC<->SDA on the GY-521 (make sure the pins are oriented properly so the GY-521 will hang above the ESP32). Then insert the GY-521 onto the ESP32 Mini making sure you've lined up VCC/GND and you'll end up with SCL on IO16 and SDA on IO17. That's it!

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

MPU6050-ESP8266-MicroPython

GitHub - adamjezek98/MPU6050-ESP8266-MicroPython: Simple library for MPU6050 on ESP8266 with micropython

Simple library for MPU6050 on ESP8266 with micropython - GitHub - adamjezek98/MPU6050-ESP8266-MicroPython: Simple library for MPU6050 on ESP8266 with micropython

GitHubadamjezek98

https://github.com/adamjezek98/MPU6050-ESP8266-MicroPython

Grab mpu6050.py and upload that to your ESP32.

micropython-mqtt

GitHub - peterhinch/micropython-mqtt: A ‘resilient’ asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets.

A 'resilient' asynchronous MQTT driver. Plus a means of using an ESP8266 to bring MQTT to non-networked targets. - GitHub - peterhinch/micropython-mqtt: A 'resilient' asynchronous M…

GitHub - scarey/laundry-is-done

Grab mqtt_as/mqtt_as.py and upload that to your ESP32. Grab mqtt_as/mqtt_local.py but we'll need to tweak that with your WiFi and MQTT broker settings.

config['server'] = ''

config['ssid'] = ''
config['wifi_pw'] = ''
config['ssl'] = 
config['port'] = 
config['user'] = ''
config['password'] = ''

Sample mqtt_local.py updates.

This project's code

Contribute to scarey/laundry-is-done development by creating an account on GitHub.

GitHub - v923z/micropython-ulab: a numpy-like fast vector module for micropython, circuitpython, and their derivatives

Grab main.py and upload it to the root of your ESP32.

Update 06/25/23: Publish configuration to esp32/washer/config with retain set. You need to tweak the "sensitivity" based on your washer/dryer and lower it if it thinks it's done too early. Increase it if it never thinks it's done. You can also increase the "maxIdlePeriods" if necessary (it's the number of samples in a row that need to be less than the "sensitivity" to be considered all done).

{
  "sensitivity": 100,
  "sampleSecs": 10,
  "maxIdlePeriods": 6
}

esp32/washer/config

Home Assistant

MQTT Integration

I have a Mosquitto MQTT broker running and integrated with HA. For the interface I just added a text field to show the last acceleration values to make fine-tuning easier and a switch to enable the monitoring.

mqtt:
  sensor:
  - unique_id: dryervib
    name: "Dryer vibration"
    unit_of_measurement: "XYZ sum"
    value_template: >-
      {%- set parts = value[1:-1].split(",") -%}
      {{ int(parts[0]) + int(parts[1]) + int(parts[2]) }}
    state_topic: "esp32/washer/readings/1"

  switch:
  - unique_id: dryermon
    name: "Dryer monitor"
    state_topic: "esp32/washer/active/1"
    command_topic: "esp32/washer/active/1/set"
    availability:
    - topic: "esp32/washer/status"
    payload_on: "on"
    payload_off: "off"
    optimistic: false

Home Assistant configuration.yaml

Android Home Assistant app

Notification

I use Twilio to send texts when motion has ceased. It has good integration with Home Assistant and you can use a simple HA Automation or I prefer Node-Red.

Notes

You may need to tune the sensitivity and/or the number of idle periods if you find it is notifying before the cycle is done or never notifies.
If desired, separate accelerometers could be used for independent sensing of washer and dryer. I haven't tried it but for the GY-521 I linked to it says connecting VCC to AD0 will change the address of the second module so they can both be used at the same time.
MQTT is my preferred way to have the ESP32 communicate. You could have the ESP32 handle everything by maybe adding a physical button to start monitoring and directly make a request to Twilio or your wireless carrier to send a notification.
9/7/23 - I just updated to Home Assistant 2023.9.0 and it didn't like how I was separating the acceleration values so I updated the config above to combine XYZ into a single number.

Bass Reactive LEDs with Micropython and ESP32

Stephen Carey — Sun, 05 Mar 2023 15:41:31 GMT

A sampling of some different kinds of music « Music: bensound.com »

This is my take on creating some cool lighting for my car. I thought it would be more interesting if the LEDs reacted only to the bass instead of simply the volume. After a bunch of googling I couldn't really find exactly what I wanted but I managed to piece things together from a bunch of sources. See for yourself!

Supplies

GY-MAX4466 - Electret Microphone Amplifier Sensor Sound Module with Adjustable Gain Control
ESP32 development board, ESP32 Mini, or whatever ESP32 you prefer
Neopixel strip - You could go with IP65 or IP67 waterproofing but I went with the cheaper IP30 and so far so good. I used 18 LEDs per footwell, 60 pixels per meter.
KY-040 Rotary Encoder Module
Capacitor (500–1000 µF at 6.3V or higher)
2 resistors (300-500Ω)
Soldering iron
Wire

When you purchase through links on this site, I may earn an affiliate commission.

Wiring

Compiling the firmware

The library I'm using to analyze the sound is too big to be used as a normal module on the ESP32 and needs to be frozen into the firmware. Here's the guide I followed:

a numpy-like fast vector module for micropython, circuitpython, and their derivatives - GitHub - v923z/micropython-ulab: a numpy-like fast vector module for micropython, circuitpython, and their de…

GitHubv923z

This did the trick to freeze ulab into micropython 1.19.1 on my Ubuntu 22.04.2 LTS system :

sudo apt install cmake
cd ~/dev/git
git clone https://github.com/micropython/micropython.git
git clone https://github.com/v923z/micropython-ulab.git ulab
export BUILD_DIR=$(pwd)
cd micropython
git checkout v1.19.1
git clone -b v4.0.2 --recursive https://github.com/espressif/esp-idf.git
cd esp-idf/
sudo apt install python-is-python3
./install.sh 
. ./export.sh 
cd $BUILD_DIR/micropython/mpy-cross
make
cd $BUILD_DIR/micropython/ports/esp32
make submodules

# The next 6 lines are a single command
cat <> makefile
BOARD = GENERIC
USER_C_MODULES = \$(BUILD_DIR)/ulab/code/micropython.cmake

include Makefile
EOT

make

After building it will spit out the command to flash the firmware.

Or download the firmware I built here:

Build

ESP32 micropython firmware 1.19.1 + ulab

build.tgz

982 KB

After unpacking the files the flash command might look something like (replace with your device's port, e.g. /dev/ttyUSB0):

esptool.py -p  -b 460800 --before default_reset --after hard_reset write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x1000 build-GENERIC/bootloader/bootloader.bin 0x8000 build-GENERIC/partition_table/partition-table.bin 0x10000 build-GENERIC/micropython.bin

Code

Getting Started With Micropython

1. Getting started with MicroPython on the ESP32 — MicroPython latest documentation

micropython-rotary

GitHub - miketeachman/micropython-rotary: MicroPython module to read a rotary encoder.

MicroPython module to read a rotary encoder. . Contribute to miketeachman/micropython-rotary development by creating an account on GitHub.

GitHubmiketeachman

Grab rotary.py and rotary_irq_esp.py and upload them to the ESP32.

This project's code

GitHub - scarey/bass-reactive-leds: Micropython code for bass reactive NeoPixel strips with an ESP32.

Micropython code for bass reactive NeoPixel strips with an ESP32. - GitHub - scarey/bass-reactive-leds: Micropython code for bass reactive NeoPixel strips with an ESP32.

Mic Amp MAX4466 Enclosure by jgutz20

Controls

Pressing on the rotary encoder will cycle through the modes
In the reactive mode, turning counter-clockwise will increase the sensitivity (higher brightness for less bass)
In the other modes, turning counter-clockwise will speed up the rainbow effects.

Notes

ADC

Note: The ESP32 has 2 ADC chips and ADC2 is shared with Wifi. This project isn't using Wifi but if you wanted to tweak the code to add Wifi support you'd want to move the mic to a pin using ADC1. See here for more details.

Mic

There's a sensitivity adjustment on the back. Turn counter-clockwise for more sensitivity. Play with it and see what works best.

Power

With a 2 footwell setup I'm powering from a USB port integrated into my car. Depending on how many pixels you've got planned you may want a 5V cigarette lighter adapter with at least 2 amps.

More strips

The code assumes 2 strips. If you wanted to add strips to the rear footwell or elsewhere you can just chain off the end of the left/right strip and increase the NUM_LEDS_PER by how many you're adding.

Assembly ideas

For the car I went with a separate mic enclosure so I could more easily position it.

a simple compact case for Max4466 breakout board/microphone. I’m using mine attached to a project box for a WLED Sound Reactive setup. The enclosure has 2 small pins to line up the circuit board and hold it in place, on the bottom is a “key” for the lid to help keep the bottom end secured. Unde…

KY-040 rotary encoder mounting block by The__Captain

A simple mounting block for a KY-040 rotary encoder. This is basically useless by itself; it is meant to be attached to the inside of a device case/housing where a rotary encoder is needed. Just snug this up to the inside of your case model, and pop a 3.6mm radius hole in the case model with your…

ESP32 WLED Sound Reactive Box by jgutz20

I’ve seen quite a few ESP32 boxes out there, and even some that can accommodate a speaker for running WLED SR (Sound Reactive), but i wanted a box with a little bit more room. I made this container/enclosure for those that want a little bit more room for using breadboard jumpers instead of soldering…