Mastering hardware protocols with ESP32 and Arduinos

Differentiate oscilloscope and logic analyzer use, explore features and use cases, then master bit operations in C++ on Arduino, including bit shifts, masks, and logical and/or for UART and I-squared-C.

Compare oscilloscope and logic analyzer: oscilloscope captures analog voltages over time with high detail, while the logic analyzer converts signals to 0/1 TTL levels across eight channels.

Evaluate logic analyzers for hobby use by comparing sampling rate, channels, and memory depth, noting 24 MHz sampling with eight channels for Arduino and ESP32 protocols.

Explore practical logic analyzer uses for hobby projects with limited resources. Learn to capture sensor data, transform logic levels to ascii, analyze protocols, and reverse-engineer devices using ESP32/ESP8266.

Learn to apply the bitwise and operation to mask data, extract the last four bits from sensor values, and understand hex and binary representations in Arduino.

Master the bitwise or operation using the vertical bar in the Arduino environment. Combine two 8-bit values into one number through bit shifting, as shown by 10011011 equals 155.

Master bitwise shift concepts for Arduino sketches, including left and right shifts, shifting eight-bit values, combining shifted bits using OR, and using long data types.

Follow along in the practical part as you learn bit operations on an Arduino Uno, printing binary, hex, and decimal values, and combining registers with shifts and or operations.

Explore practical exercises verifying bitwise masking with x and y bytes, comparing binary, decimal and hex representations, and debugging in the Arduino environment before moving to pulse view.

Master open source software and external decoders with Python to study hardware protocols with pulse view, configure sampling rates and megahertz settings, and capture pwm data for infrared-triggered measurements.

Explore PulseView, a free and open source logic analyzer with a user friendly GUI that supports commercial use, plus access to Python decoders and GitHub plugins.

Download the required tools across Linux, Windows, and Mac OS X using installers or containers. Switch to a dark theme and access the same features across platforms for the course.

Introduce the base sketch as the universal starting point for all projects, built step by step in Visual Studio Code, using pin eight as a digital output for 300 ms.

Learn to configure a logic analyzer with an Arduino Uno, connect ground and pin eight, set sampling rates, run the capture, and use cursors and protocol decoders to analyze signals.

Explain how sample rate and total sampling time on a logic analyzer affect data capture, noting higher rates capture fast changes and align with Arduino Uno USB specs.

Explore the relation between frequency and milliseconds and how to convert between milliseconds and hertz. Learn to recalculate baud rate and timing for data capture.

Master baud rate as symbols per second in serial communication; align sender and receiver speeds, recognize presets like 9600 and 115200 on ESP32 and Arduino Uno, recalculate from captured data.

Learn to produce pwm signals with arduino and inspect pwm on pins five, six, and seven using a logic analyzer, including duty cycles and esp32 analog write considerations.

Learn how to use external triggers for circuit inspection with an infrared sensor, using a logic analyzer to trigger on a low level and rising/falling edges to capture relevant data.

Explore uart theory with practical Arduino Uno and ESP32 examples, using a logic analyzer to capture data, compare software and hardware serial, and reverse engineer sensor communication for IoT.

Explore universal asynchronous receiver transmitter basics, including two-line serial data, cross RX/TX, and 8-bit frames with start stop bits and parity checks in UART communication across microcontrollers.

Learn ttl logic and transistor transistor logic basics, interpret uart data frames with start bits, data bits, and stop bits, and relate timing to 9600 baud around 104 microseconds.

Test UART communication between an Arduino Uno and a logic analyzer using TX and RX with PulseView. Verify data at 9600 or 115200 baud.

Master the built-in software serial library on the Arduino Uno, configure pins (6 for tx, 5 for rx), and substitute for hardware serial by printing to the serial monitor.

Visualize ASCII charts in pulse view by configuring a UART decoder, setting 9600 baud, decoding binary to ASCII text, and optionally inverting signals to display ASCII characters.

Learn how to send hex data from the Arduino Uno to a monitor using hardware serial, convert hex to ASCII, and replace delays with millis-based timing for non-blocking operation.

Explore the concepts of least significant bit and most significant bit, their read order, and how datasheets define LSB-first or MSB-first transmission in UART data. Note how it affects outputs.

Explore how to send and interpret binary data with Arduino UNO, switching between least significant bit first and most significant bit first, using serial monitor and pulse view.

Configure the hardware serial on an ESP32 using UART2 and GPIO17 for TX, include the hardware serial library, and print hello messages to the serial monitor and Pulse View.

Understand parity bits in UART with even parity to detect errors by counting ones in the data frame, plus note limitations and checksum alternatives.

Configure eight data bits, even parity, one stop bit (SERIAL_8E1) on the ESP32, using serial begin with parity options and pulse view to confirm parity in data frames.

Demonstrates UART communication between two Arduino Uno boards by sending a debounced button press as a 'button' string, toggling an led on the receiver at 9600 baud.

Demonstrate safe interfacing between a 5V arduino uno and a 3.3V ESP32 using a logic level shifter to convert uart signals and toggle an led via serial communication.

Identify baud rates by measuring the time between logic levels and calculating the rate, using an Arduino Uno with hardware serial. Validate with 9600 and 57600 and PulseView data frames.

Explore a reverse engineering approach to the Ikea Vindriktning air quality sensor, analyzing its datasheet and UART interface to capture data with ESP32 or Arduino, and build an IoT library.

Build an ESP 8266-based IoT device to read pm2,5 data from an IKEA sensor via UART, with optional BME 280 for humidity and temperature.

Explore the advantages and disadvantages of UART, including point-to-point use, limited distance and bandwidth, no built-in error detection (parity, checksums require manual handling), and its simple, widely supported nature.

Explore the one wire protocol using the DS18B20 temperature sensor and learn to write an Arduino sketch that reads temperature without external libraries.

Master the one wire protocol using 1820 sensors on a single data line with a pull-up resistor, unique addresses, and CRC checks for cheap temperature data access in Arduino.

Learn to wire a ds18b20 sensor with esp32 or arduino using the one-wire protocol, including vcc, ground, a 4.7k pull-up, and the dallas temperature library to read temperatures.

Explore the data sheet to learn the pin configuration, supply voltage, and -55°C to +125°C range of the digital thermometer, and how 9-bit to 12-bit resolution converts data to Celsius.

Analyze the last data frame from an ESP32 temperature sensor using a logic analyzer and one-wire decoder; derive 30.69 °C through bit-level calculation and binary-to-decimal conversion.

Change the sensor resolution to nine bit to speed data retrieval and obtain rough values. Compare nine-bit and twelve-bit readings using the set resolution function to balance speed and accuracy.

demonstrate importing external decoders into pulse viewer for rds 1820 sensor, using a python-based decoder package. copy folder to /usr/share/lib/psychrock/decode/decoders on linux, restart pulse viewer, and verify temperature readings.

Use the one wire library to fetch temperature data from Dallas sensors. The video demonstrates initializing the OneWire object, issuing skip rom and read scratchpad commands, and calculating temperature from two bytes.

Explore non standardized protocols using the dht11 as an example by reverse engineering datasheet details and examining the library to reveal how the protocol operates and data reaches the MCU.

Wire a simple one-wire circuit for esp32 or arduino with dht11 or dht22 and resistors, then use Adafruit sensor and the dbt library to read humidity, temperature, and heat index.

Explore how the DHT11 uses a single bus protocol to transmit 40 bits of humidity and temperature data. Verify the 40-bit payload and checksum through timing cues.

Study the DHT protocol by reading the datasheet, set the data line D0, and compare DHT11 and DHT22 to spot circuit errors.

Explore the dht library internals by inspecting header and cpp files in arduino ide, and learn how it reads the dht11 data via pulse widths to compute temperature and humidity.

Master the spi protocol and its duplex data transfer in the Arduino environment, building a master-slave setup that sends data from one Arduino Uno to another, with a Dht22 example.

Explore SPI, the five-wire serial parallel interface with clock, MOSI, MISO, ground, and slave select, for multiple slaves; compare its full duplex to iSCSI’s two-line, half duplex approach.

Set up arduino clones to communicate over SPI, wiring pins 10 to 13 and using SPI library for master transmit and slave receive. Validate by sending and printing hex data.

Analyze the spi protocol with a logic analyzer, decoding clock, data lines, and chip select to demonstrate full duplex spi between ESP32 and Arduinos, using master in and slave out.

Discover how to transmit DHT22 humidity and temperature data over SPI between ESP32 and Arduino, including wiring, the DHT sensor library, and SPI data transfer.

Explore E squared protocol in the microcontroller and Arduino environment, analyze the th 1750 ambient light sensor, and build a bit-operation library to read lux values from the D20 sensor.

Master Arduino or ESP communicates with many I2C devices over two wires, using unique addresses, pull-ups, clocked data, and half-duplex transfers at speeds up to 3.5 Mbps.

Explore the e square c protocol flow from start condition through seven-bit address and read/write bit to an acknowledged, register address, and data transmission in real time with pulse viewer.

Wire an ESP32 to a BH1750 ambient light sensor via I2C using SDA GPIO21 and SCL GPIO22 with 3.3V power; read lux and print it.

Analyze BH1750 I2C communication, including start/address/ack; read high and low bytes, compute lux, and validate against the datasheet using a logic analyzer.

Read BH1750 via I2C using the Wire library without external libraries, fetch two bytes from address 0x23, combine into lux by dividing by 1.2.

Use the DF robot library with the DHT20 sensor to read temperature and humidity in a simple sketch, printing results for later data capture with pulse view.

Analyze the DHT20 datasheet and I2C communication at address 0x38, triggering measurements to read humidity and temperature data, then parse raw bytes into values using the shown calculations.

Learn to read the DHT20 on ESP32 or Arduino without external libraries using i2c, address 0x38, and six bytes to extract humidity and temperature with bitwise parsing.

Create an I2C master–slave setup with two Arduino Uno boards, exchanging random data via wire, handling requests and addressing multiple slaves up to 128, with serial visualization.

Explore e squared C addresses beyond seven-bit schemes, including ten-bit addressing to 1024 devices, and use Adafruit e squared C address list to define or identify addresses in Arduino sketches.

Create your own sketch to discover i2c addresses in an existing circuit by iterating 0–127, begin transmission, and print found hex addresses to build an i2c scanner.

Discover how an i2c multiplexer lets you run multiple devices from a single microcontroller, such as oled displays, by providing internal addresses and cascading up to seven devices.

Master practical hardware protocols for ESP32 and Arduinos by reviewing logic analyzers, bitwise operations, and serial interfaces such as UART, I2C, SPI, and one-wire.

Thank attendees and invite reviews; contact via email or text for coupon codes and promotional code, and I am happy to see you in another online course.