IO

In this section, you will learn about IO pins, its purpose, and how you can use them for your projects.

Introduction

The Echo features a versatile array of GPIO (General Purpose Input/Output) pins, enabling control over various sensors and devices. These pins support a wide range of communication signals, including:

• Digital: For on/off states

• PWM (Pulse Width Modulation): For analog-like control using digital signals

• I2C (Inter-Integrated Circuit): A two-wire serial communication protocol

• UART (Universal Asynchronous Receiver-Transmitter): For serial data transmission

• SPI (Serial Peripheral Interface): A synchronous serial data protocol

• Analog: For reading continuous voltage values

A key advantage of the Echo's pins is their full configurability. This means that most pins can serve various purposes, provided they are correctly declared and configured in your code.

Important Note on PWM: Due to the Echo's integrated motor drivers utilizing all of the ESP32's built-in MCPWM (Motor Control PWM) channels, additional MCPWM functionality may not be available for other GPIO purposes if the motor drivers are actively used and declared in your code.

Given the extensive number of communication protocols and compatible devices, we will provide fundamental examples for each communication type to demonstrate the Echo's versatility.

Digital I/O

Digital communication, utilizing digitalWrite() and digitalRead() functions in Arduino, involves setting a pin to a HIGH (typically 3.3V) or LOW (0V) state for output, or detecting a HIGH or LOW state for input. This allows for basic on/off control or sensing of binary signals.

Digital Input Example

For this example, we will demonstrate reading data from a digital sensor, specifically the MAGsense sensor by 3DBU.

#define HALL_SENSOR_PIN 1  // Set the pin accordingly, This must be set on a DIGITAL enabled pin

void setup() {
    pinMode(HALL_SENSOR_PIN, INPUT);
    Serial.begin(115200);
}

void loop() {
    int sensorState = digitalRead(HALL_SENSOR_PIN);
    if (sensorState == HIGH) {
        Serial.println("Magnet Detected");
    } else {
        Serial.println("No Magnet");
    }
    delay(500); // Delay for readability, adjust as needed
}

Digital Output Example

This example demonstrates controlling an LED or relay using digital output.

#define LED_PIN 2          // Set the pin accordingly
#define BUTTON_PIN 3       // Input pin for button

void setup() {
    pinMode(LED_PIN, OUTPUT);
    pinMode(BUTTON_PIN, INPUT_PULLUP); // Enable internal pull-up resistor
    Serial.begin(115200);
}

void loop() {
    int buttonState = digitalRead(BUTTON_PIN);
    
    if (buttonState == LOW) { // Button pressed (pull-up inverts logic)
        digitalWrite(LED_PIN, HIGH); // Turn LED on
        Serial.println("LED ON");
    } else {
        digitalWrite(LED_PIN, LOW);  // Turn LED off
        Serial.println("LED OFF");
    }
    
    delay(100);
}

The code above configures digital pins for both input and output, demonstrating basic on/off control and binary signal detection.

PWM (Pulse Width Modulation)

PWM allows you to simulate analog output by rapidly switching a digital pin between HIGH and LOW states. This is useful for controlling LED brightness, servo positions, or motor speeds.

#define PWM_PIN 4          // PWM-capable pin
#define POTENTIOMETER_PIN A0

void setup() {
    pinMode(PWM_PIN, OUTPUT);
    Serial.begin(115200);
}

void loop() {
    // Read potentiometer value (0-4095 on ESP32)
    int potValue = analogRead(POTENTIOMETER_PIN);
    
    // Map to PWM range (0-255)
    int pwmValue = map(potValue, 0, 4095, 0, 255);
    
    // Output PWM signal
    analogWrite(PWM_PIN, pwmValue);
    
    Serial.println("PWM Value: " + String(pwmValue));
    delay(100);
}

This example reads an analog input and uses it to control PWM output, demonstrating variable analog-like control using digital signals.

I2C Communication

I2C (Inter-Integrated Circuit) is a powerful and efficient two-wire serial communication protocol. It's particularly useful because it allows for daisy-chaining multiple devices (provided they have unique I2C addresses), significantly reducing the number of pins required for communication. It is also known for its speed and ease of use.

I2C Scanner

The Echo has one available I2C channel. This example demonstrates how to use the Echo to scan for and identify I2C devices connected to its I2C bus. This is an invaluable tool for troubleshooting and confirming that your I2C sensors or modules are properly connected and recognized.

#include <Wire.h> // Include the Wire library for I2C communication.

void setup() {
    Wire.begin();         // Initialize the I2C bus.
    Serial.begin(115200); // Initialize serial communication for debugging output.
    Serial.println("\nI2C Scanner");
}

void loop() {
    byte error, address;
    int nDevices;

    Serial.println("Scanning...");

    nDevices = 0;
    for (address = 1; address < 127; address++) {
        // The i2c_scanner uses the return value of Wire.endTransmission to see if
        // a device did acknowledge to the address.
        Wire.beginTransmission(address);
        error = Wire.endTransmission();

        if (error == 0) {
            Serial.print("I2C device found at address 0x");
            if (address < 16) {
                Serial.print("0");
            }
            Serial.print(address, HEX);
            Serial.println("  !");

            nDevices++;
        } else if (error == 4) {
            Serial.print("Unknown error at address 0x");
            if (address < 16) {
                Serial.print("0");
            }
            Serial.println(address, HEX);
        }
    }
    
    if (nDevices == 0) {
        Serial.println("No I2C devices found\n");
    } else {
        Serial.println("done\n");
    }

    delay(5000); // Wait 5 seconds before next scan
}

I2C Device Communication

This example demonstrates reading data from a common I2C temperature sensor (like the BME280):

#include <Wire.h>

#define SENSOR_ADDRESS 0x76  // Common BME280 address

void setup() {
    Wire.begin();
    Serial.begin(115200);
    Serial.println("I2C Temperature Sensor Example");
}

void loop() {
    Wire.beginTransmission(SENSOR_ADDRESS);
    Wire.write(0xFA); // Temperature register address (example)
    Wire.endTransmission();
    
    Wire.requestFrom(SENSOR_ADDRESS, 2); // Request 2 bytes
    
    if (Wire.available() >= 2) {
        byte highByte = Wire.read();
        byte lowByte = Wire.read();
        
        int rawTemp = (highByte << 8) | lowByte;
        float temperature = rawTemp / 100.0; // Convert based on sensor specs
        
        Serial.println("Temperature: " + String(temperature) + "°C");
    }
    
    delay(1000);
}

UART Communication

UART provides asynchronous serial communication, useful for connecting to GPS modules, other microcontrollers, or serial devices.

#include <HardwareSerial.h>

HardwareSerial SerialGPS(1); // Use UART1

#define GPS_RX_PIN 16
#define GPS_TX_PIN 17

void setup() {
    Serial.begin(115200);           // Main serial for debugging
    SerialGPS.begin(9600, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN); // GPS serial
    
    Serial.println("UART GPS Communication Example");
}

void loop() {
    // Read data from GPS module
    if (SerialGPS.available()) {
        String gpsData = SerialGPS.readStringUntil('\n');
        Serial.println("GPS Data: " + gpsData);
    }
    
    // Send command to GPS module
    static unsigned long lastCommand = 0;
    if (millis() - lastCommand > 10000) { // Every 10 seconds
        SerialGPS.println("$GPRMC"); // Request specific GPS sentence
        lastCommand = millis();
    }
    
    delay(100);
}

This example demonstrates bidirectional UART communication with a GPS module, showing both data reception and command transmission.

SPI Communication

SPI is a high-speed synchronous communication protocol commonly used with displays, SD cards, and high-speed sensors.

#include <SPI.h>

#define CS_PIN 5    // Chip Select pin
#define MOSI_PIN 23 // Master Out Slave In
#define MISO_PIN 19 // Master In Slave Out  
#define SCK_PIN 18  // Serial Clock

void setup() {
    Serial.begin(115200);
    
    // Initialize SPI with custom pins
    SPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, CS_PIN);
    
    pinMode(CS_PIN, OUTPUT);
    digitalWrite(CS_PIN, HIGH); // Deselect device initially
    
    Serial.println("SPI Communication Example");
}

void loop() {
    // Example: Read from SPI device
    digitalWrite(CS_PIN, LOW);  // Select device
    
    SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
    
    // Send read command (example for generic sensor)
    byte command = 0x80; // Read command
    SPI.transfer(command);
    
    // Read response
    byte response = SPI.transfer(0x00); // Send dummy byte to read
    
    SPI.endTransaction();
    digitalWrite(CS_PIN, HIGH); // Deselect device
    
    Serial.println("SPI Response: 0x" + String(response, HEX));
    
    delay(1000);
}

This example shows SPI configuration and basic read operation, demonstrating the protocol's chip-select mechanism and transaction management.

Analog Input

Analog pins can read continuous voltage values, useful for sensors that output variable voltages like potentiometers, light sensors, or temperature sensors.

#define ANALOG_PIN A0
#define VOLTAGE_DIVIDER_PIN A1

void setup() {
    Serial.begin(115200);
    Serial.println("Analog Input Examples");
}

void loop() {
    // Read raw ADC value (0-4095 on ESP32)
    int rawValue = analogRead(ANALOG_PIN);
    
    // Convert to voltage (ESP32 ADC reference is typically 3.3V)
    float voltage = (rawValue / 4095.0) * 3.3;
    
    // Read voltage divider for battery monitoring
    int batteryRaw = analogRead(VOLTAGE_DIVIDER_PIN);
    float batteryVoltage = (batteryRaw / 4095.0) * 3.3 * 2; // Assuming 2:1 voltage divider
    
    Serial.println("Analog Reading: " + String(rawValue) + " (Raw), " + String(voltage, 2) + "V");
    Serial.println("Battery Voltage: " + String(batteryVoltage, 2) + "V");
    
    // Example: Light sensor interpretation
    String lightLevel;
    if (voltage < 0.5) {
        lightLevel = "Dark";
    } else if (voltage < 2.0) {
        lightLevel = "Dim";
    } else {
        lightLevel = "Bright";
    }
    
    Serial.println("Light Level: " + lightLevel);
    Serial.println("---");
    
    delay(1000);
}

This example demonstrates reading analog values and converting them to meaningful measurements.

Conclusion

The examples provided here illustrate the fundamental versatility of the Echo's I/O pins. While these specific sensors are used for demonstration, the principles apply to a vast array of compatible devices and communication protocols. Ultimately, the choice and configuration of your I/O pins will be dictated by the specific requirements and integrated components of your project.