Copy

conda create --name esp32 python=3.8
conda activate esp32
          

Copy

conda install -c conda-forge esptool
          

Copy

pip install esptool
          

Copy

esptool --chip esp32s3 --port COM4 erase_flash
# deletes complete flash memory of the target board
          

Copy

esptool --port COM4 --baud 460800 write_flash 0 ESP32_GENERIC_S3-20251209-v1.27.0.bin
# writes MicroPython firmware to flash address 0x0
          

>>> print("Hello FabAcademy!")
Hello FabAcademy!
          

Copy

# Navigate to Houdini's embedded Python
cd "C:\Program Files\Side Effects Software\Houdini 21.0.596\python311"

# Install serial package into this Python runtime
.\python.exe -m pip install pyserial

# Test in Houdini: Windows > Houdini Python Shell
import serial
          

Copy

import serial
import time
import hou


# Close old connection if available
if hasattr(hou.session, 'esp32') and hou.session.esp32 is not None:
    try:
        hou.session.esp32.close()
    except:
        pass

# Open new connection
esp = serial.Serial('COM5', 115200, timeout=0)
time.sleep(2)

# Enter raw REPL
# \x03 = Ctrl+C (interrupt running code), sent twice for a clean stop; \x01 = Ctrl+A (switch to raw REPL)
esp.write(b'\x03\x03\x01')
time.sleep(0.2)
esp.read(esp.in_waiting or 1)

# Initialize NeoPixel object on the board
# \n sends newline, \x04 sends Ctrl+D to execute the buffered command in raw REPL
esp.write(b'from machine import Pin;import neopixel;np=neopixel.NeoPixel(Pin(48),1)\n\x04')
time.sleep(0.2)
esp.read(esp.in_waiting or 1)

# Store globally for reuse in other nodes
hou.session.esp32 = esp
hou.session.esp32_ready = True

print("ESP32 initialized and stored in session")
print("You can now use it in other nodes.")
          

Copy

import hou
import serial
import time

def ensure_esp32_healthy():

    if hasattr(hou.session, 'esp32') and hou.session.esp32:
        esp = hou.session.esp32
        try:
            if esp.is_open:
                if esp.in_waiting > 500:
                    esp.read(esp.in_waiting)
                return esp
        except:
            pass

# Reconnect from scratch
esp = serial.Serial('COM5', 115200, timeout=0.5)
time.sleep(2)
# \x03 = Ctrl+C (interrupt), \x01 = Ctrl+A (enter raw REPL)
esp.write(b'\x03\x03\x01')
time.sleep(0.2)
esp.read(esp.in_waiting or 1)
# \x04 = Ctrl+D (execute current raw REPL command buffer)
esp.write(b'from machine import Pin;import neopixel;np=neopixel.NeoPixel(Pin(48),1)\n\x04')
time.sleep(0.2)
esp.read(esp.in_waiting or 1)

    hou.session.esp32 = esp
    print("ESP32 reconnected")
    return esp

# Main
esp = ensure_esp32_healthy()
node = hou.pwd()
geo = node.geometry()

# Clean serial buffer
if esp.in_waiting:
    esp.read(esp.in_waiting)

# Read simulation attributes
color = geo.attribValue('avgCd') if geo.findGlobalAttrib('avgCd') else (1, 0, 0)
brightness = geo.attribValue('stress') if geo.findGlobalAttrib('stress') else 1.0

r = max(0, min(255, int(color[0] * 255 * brightness)))
g = max(0, min(255, int(color[1] * 255 * brightness)))
b = max(0, min(255, int(color[2] * 255 * brightness)))

# Send with error handling
try:
    cmd = f'np[0]=({r},{g},{b})\nnp.write()\n'
    esp.write(b'\x01' + cmd.encode() + b'\x04')
    time.sleep(0.01)
    if esp.in_waiting:
        esp.read(esp.in_waiting)
except Exception as e:
    print(f"ESP32 error: {e}")
    hou.session.esp32 = None  # Force reconnect on next frame
          

Copy

// Analog Pin
#define POTI_PIN 4

// Config
#define READ_INTERVAL 50  // ms between measurements

void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println("\nESP32-H2 Rotation Sensor Test");
  Serial.println("GPIO 4");

  // ADC config
  analogReadResolution(12);  // 12-bit ADC (0-4095)
  analogSetAttenuation(ADC_11db);
}

void loop() {
  static unsigned long lastRead = 0;

  if (millis() - lastRead >= READ_INTERVAL) {
    // Read ADC (0-4095 = 12-bit)
    int rawValue = analogRead(POTI_PIN);
    // Convert
    float percent = (rawValue / 4095.0) * 100.0;
    float degrees = (rawValue / 4095.0) * 300.0; // guessed 300 degree turn

    // Visualize
    Serial.print("Value: ");
    Serial.print(rawValue);
    Serial.print(" [");

    int bars = map(rawValue, 0, 4095, 0, 40);
    for (int i = 0; i < 40; i++) {
      if (i < bars) {
        Serial.print("█");
      } else {
        Serial.print("░");
      }
    }

    Serial.print("] ");
    Serial.print(percent, 1);
    Serial.print("% / ");
    Serial.print(degrees, 0);
    Serial.println("°");

    lastRead = millis();
  }

  delay(10);
}
          

Model: Claude Sonnet 4.5 Thinking:

"This is my current Arduino code. I want to add Zigbee support and send the sensor result. However, due to noisy results, the output has to be smoothed and should only be sent when a noticeably large difference is detected. The device should be configured as a Zigbee router."

Copy

#include "Zigbee.h"

#define POTI_PIN 4
#define ZIGBEE_ENDPOINT 10

// Calibration
int minValue = 0;
int maxValue = 3504;

// Smoothing
#define SMOOTHING_SAMPLES 10
int readings[SMOOTHING_SAMPLES];
int readIndex = 0;
int total = 0;

ZigbeeAnalog zbPoti = ZigbeeAnalog(ZIGBEE_ENDPOINT);

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("\n=== Zigbee Potentiometer Router ===");

  analogReadResolution(12);
  analogSetAttenuation(ADC_11db);

  // Initialize smoothing buffer
  for (int i = 0; i < SMOOTHING_SAMPLES; i++) {
    readings[i] = 0;
  }

  // Zigbee setup
  zbPoti.setManufacturerAndModel("ESP H2", "Rotation Sensor");
  zbPoti.addAnalogInput();
  zbPoti.setAnalogInputDescription("Rotation Sensor");
  zbPoti.setAnalogInputMinMax(0, 100);

  Zigbee.addEndpoint(&zbPoti);
  Zigbee.setRebootOpenNetwork(180);

  Serial.println("Starting Zigbee...");
  if (!Zigbee.begin(ZIGBEE_ROUTER, false)) {
    Serial.println("Zigbee failed!");
    ESP.restart();
  }

  Serial.println("Zigbee OK! Waiting for connection...");
}

void loop() {
  static unsigned long lastRead = 0;
  static int lastValue = -1;

  if (millis() - lastRead >= 100) {
    int rawValue = analogRead(POTI_PIN);
    total = total - readings[readIndex];
    readings[readIndex] = rawValue;
    total = total + readings[readIndex];
    readIndex = (readIndex + 1) % SMOOTHING_SAMPLES;
    int smoothed = total / SMOOTHING_SAMPLES;

    // Map to 0-100 range
    int mappedValue = map(smoothed, minValue, maxValue, 0, 100);
    mappedValue = constrain(mappedValue, 0, 100);

    // Update if change > 2%
    if (abs(mappedValue - lastValue) >= 2) {
      Serial.print("Potentiometer: ");
      Serial.print(mappedValue);
      Serial.println("%");

      if (Zigbee.connected()) {
        zbPoti.setAnalogInput((float)mappedValue);
        zbPoti.reportAnalogInput();
      }

      lastValue = mappedValue;
    }

    lastRead = millis();
  }

  delay(10);
}