Hardware, Coding, & Automation

1. Sense - A sensor measures something physical, such as temperature, light, distance, or pressure. It converts that condition into an electrical signal. 2. Read - The ESP32 receives the signal through a digital input, analog input, or communication bus. A digital signal reports states such as high or low; an analog signal reports a changing voltage; a bus lets several devices exchange formatted data. 3. Decide - Your program compares the reading with a chosen limit. For example, it can decide that a fan should start when temperature reaches 28 degrees Celsius. 4. Drive - The ESP32 sends a low-power control signal to a relay, transistor, or motor driver. The driver handles the larger current required by the load. 5. Act - The actuator changes the physical world. A relay switches a lamp, a buzzer creates sound, a solenoid moves a plunger, and a motor turns a shaft. 6. Verify - You check the result with a second sensor, a status light, a serial message, or a meter. Verification catches wiring and control errors before they become equipment problems.

A sensor does not “know” what to do. A soil-moisture sensor may produce a voltage that changes as soil dries, but the ESP32 must interpret that voltage. An actuator does not decide when to operate either. A relay waits for a control signal, while a motor follows the voltage and current supplied through its driver. Treat each part as one link in the ladder.

For a simple digital sensor, connect power, ground, and signal. Connect the signal wire to an ESP32 input pin, not to a pin that your program already uses for another device. For an analog sensor, connect its output to an analog-capable input and confirm that the output voltage stays within the ESP32’s input range. For an I2C (Inter-Integrated Circuit) sensor, connect power, ground, the serial data line, and the serial clock line. The ESP32 then reads data through a shared bus rather than measuring a raw voltage.

A load such as a motor needs a separate power path. Connect the motor to the motor driver’s output terminals. Connect the motor supply to the driver’s power terminals. Connect the ESP32 ground to the driver ground so both devices share a reference for the control signal. Connect one ESP32 output to the driver’s input. Never assume that an ESP32 pin can power a motor: the pin provides a logic command, not motor power.

A typical control rule looks like this:

`cpp const int fanDriverPin = 26;

void setup() { pinMode(fanDriverPin, OUTPUT); digitalWrite(fanDriverPin, LOW); }

void loop() { float temperatureC = readTemperature(); // Replace with your sensor code

if (temperatureC >= 28.0) { digitalWrite(fanDriverPin, HIGH); } else if (temperatureC <= 26.0) { digitalWrite(fanDriverPin, LOW); }

delay(1000); } `

The two temperature limits create hysteresis, which means the program uses separate start and stop points. Without hysteresis, a temperature hovering around 28 degrees could switch the fan on and off repeatedly. Ask yourself: can you point to the exact wire carrying the sensor signal, the exact pin reading it, and the exact driver input receiving the control command? If not, pause before powering the load.

Building a Temperature-Controlled Fan

A practical test uses an ESP32, a temperature sensor, a logic-level motor driver module, a small direct-current fan, and a separate supply that matches the fan’s voltage. A logic-level driver accepts the ESP32’s low-voltage control signal and switches the fan’s higher current. Choose a driver with a current rating above the fan’s normal current and startup current, because motors often draw extra current when they begin turning.

Use this wiring plan:

| Part | Connection | Purpose | |---|---|---| | Temperature sensor power | ESP32 3.3-volt pin | Supplies the sensor | | Temperature sensor ground | ESP32 ground | Completes the sensor circuit | | Temperature sensor signal | GPIO 4 | Sends the reading to the ESP32 | | Driver logic input | GPIO 26 | Receives the fan command | | Driver logic ground | ESP32 ground | Gives both devices the same reference | | Fan supply positive | Separate fan supply positive | Provides motor power | | Fan supply negative | Driver motor ground | Completes the motor circuit | | Fan terminals | Driver output terminals | Carries switched motor current |

Follow these steps in order:

1. Test the ESP32 and sensor first. Upload a program that prints the temperature once per second to the serial monitor. At 115200 baud, you should see stable readings rather than random values. This isolates sensor wiring before the motor introduces electrical noise. 2. Confirm the driver input. Disconnect the fan and use the ESP32 to switch the driver input between low and high. Watch the driver’s indicator light, if it has one, or measure the output with a multimeter. The expected result is a clear change between the off and on states. 3. Connect the fan supply with power removed. Check the supply voltage against the fan label. A 5-volt fan needs a suitable 5-volt supply; do not connect it to a higher voltage because the fan may overheat. 4. Join the grounds. Connect the ESP32 ground, driver logic ground, and the negative side of the motor supply. The shared ground gives the driver a reliable reference for the ESP32 command. 5. Run the control program. Set the fan to start at 28 degrees Celsius and stop at 26 degrees. Print both the temperature and fan state so you can compare the decision with the physical result. 6. Check the response. Warm the sensor gently with your hand, without touching exposed conductors. The temperature should rise slowly, the fan should start at the upper limit, and it should remain on until the reading falls to the lower limit.

Expected results include a readable sensor value, no ESP32 reset when the fan starts, and a fan that changes state only at the selected limits. If the fan runs backward, swap the two motor wires on a reversible direct-current motor. If it does not run, measure voltage at the driver’s motor supply terminals before changing program code.

Quick checklist

• Confirm the sensor type and its required voltage. - Connect every device ground required by the signal path. - Use an ESP32 input for sensing and an ESP32 output for control. - Power the motor from a supply suited to the motor. - Place the driver between the ESP32 and the motor. - Test sensor code before connecting the load. - Add hysteresis to prevent rapid switching. - Log the reading and output state during testing.

This sequence keeps faults local. If the temperature reading fails, inspect the sensor stage. If the reading works but the fan does not respond, inspect the driver and motor-power stage. The ladder turns a confusing project into a series of measurable checks.

Mistakes That Damage Hardware or Hide Faults

Connecting a motor directly to an ESP32 pin

An ESP32 output pin can send a control signal, but a motor needs more current than the pin should supply. Motor coils also create voltage spikes when switching off. Those spikes can reset or damage the microcontroller.

Do this: connect the ESP32 output to a motor driver input, then connect the motor to the driver output. Use a driver with a built-in flyback diode, or add a correctly oriented diode across a simple direct-current motor circuit.

Not this: connect one motor wire to a GPIO pin and the other to ground.

Forgetting the shared ground

The ESP32 can send a high or low signal, but the driver needs a common voltage reference to interpret that signal. Without a shared ground, the driver input may appear unpredictable even when the program works correctly.

Do this: connect ESP32 ground to the driver logic ground and the negative terminal of the motor supply, unless the driver provides a clearly documented isolated input.

Not this: power the ESP32 and motor from separate supplies while leaving their grounds unconnected.

Using the wrong voltage or ignoring startup current

A motor marked for 5 volts can fail on a 12-volt supply. A supply that matches the label can still struggle if it cannot provide the motor’s startup current. The result may include slow starting, driver overheating, or repeated ESP32 resets.

Do this: read the motor label, select a supply with suitable voltage and extra current capacity, and test the supply voltage at the driver while the motor starts.

Not this: choose a supply because its plug fits or because its current rating matches only the motor’s idle reading.

When a system behaves strangely, return to the Signal-Flow Ladder: measure first, read second, decide third, drive fourth, act fifth, and verify last. That order connects code to physical behavior without hiding the electrical path. Once you can trace a fan from temperature to motion, the same method applies to pumps, lights, valves, locks, and robotic mechanisms - the hardware changes, but the signal flow remains clear.

End of chapter one. 4 more chapters and about 8,381 words in the full book.