#include <Wire.h>
              #include <Adafruit_GFX.h>
              #include <Adafruit_SSD1306.h>
            
          

These handle I2C communication and graphics rendering on the OLED. After defining the display size and initializing the display object, pin definitions were made for both the joystick analog pins and the digital pins connected to LEDs.

The setup() function initializes serial communication for debugging, the OLED display using display.begin(), and sets the LED pins as outputs using pinMode(). The joystick pins are left as analog inputs by default.

The loop() function is where the bulk of the logic occurs. First, analog readings are taken from the joystick's X and Y axes:

              
                int xVal = analogRead(A0);
                int yVal = analogRead(A1);

Using calibrated thresholds, the code determines which direction the joystick is pointing. For example, if xVal > 3000, it's considered "Right". These conditions are used to trigger the corresponding LED and update the OLED display. Before every new update, display.clearDisplay() is called to avoid overlapping frames.

The direction is then printed to the OLED using:

              
                display.setCursor(0, 20);
                display.print("Direction: RIGHT");
                display.display();

The corresponding LED is also activated using digitalWrite().

To add a sliding effect, a global variable xOffset can be used to shift the cursor position across frames. This adds UI flair and simulates text scrolling across the screen.

One challenge in the programming process was creating a responsive interface without flicker or delay. OLEDs can flicker when content is cleared and redrawn too quickly. To address this, frame updates were optimized, and redraws were done only when the direction changed.

Debouncing logic was added to prevent rapid LED flicker when the joystick was near the center threshold. Flags were used to track direction changes and update outputs only when a transition occurred.

Modularity was emphasized through use of functions like updateDisplay(direction) and setLED(direction), which made debugging and scalability easier.

In summary, the programming involved:

• Pin configuration
• Threshold-based analog input handling
• Conditional direction detection
• I2C communication with OLED
• Dynamic UI updates
• LED output synchronization
• Debounce and state change logic

This structured approach made the entire system responsive and reliable.

Hardware Addressing and Problem Solving

A critical part of this project was ensuring proper **hardware addressing**, especially because multiple peripherals were used: an **OLED screen** (using I2C) and four **LEDs** (using GPIO). The **XIAO ESP32-C3** has a unique pin mapping structure compared to traditional Arduino boards, and confirming pin assignments and communication addresses was essential to achieving reliable operation.

OLED I2C Addressing

The OLED display used in this project operates on the **I2C protocol**. I2C devices require a unique 7-bit address to communicate with the microcontroller. The common address for most SSD1306 OLED displays is **0x3C**, but it can vary depending on the module's configuration. To confirm this:

• I uploaded an **I2C scanner sketch** (available online) to the XIAO ESP32-C3.
• This scanner detected the OLED at address **0x3C**, confirming communication.

              
                #include <Wire.h>
                void setup() {
                  Wire.begin();
                  Serial.begin(115200);
                  while (!Serial); // wait for serial monitor
                  Serial.println("I2C Scanner");
                }

                void loop() {
                  byte error, address;
                  for (address = 1; address < 127; address++) {
                    Wire.beginTransmission(address);
                    error = Wire.endTransmission();
                    if (error == 0) {
                      Serial.print("I2C device found at 0x");
                      Serial.println(address, HEX);
                    }
                  }
                  delay(1000);
                }
              
            

This verified that my OLED module was correctly wired to the default I2C pins:

• SDA → GPIO5 (D5)
• SCL → GPIO4 (D4)

These are default hardware I2C pins on the XIAO ESP32-C3. While it's possible to use Wire.begin(SDA, SCL), sticking with default pins ensured library compatibility.

LED GPIO Addressing

The LEDs were assigned to digital GPIO pins on the microcontroller. The following assignments were used:

To avoid any hardware confusion:

• I double-checked the XIAO ESP32-C3 pinout diagram.
• Used digitalWrite() after setting pinMode(pin, OUTPUT) in setup().
• Verified each LED connection by writing a test program to blink them individually.

Joystick Analog Input Addressing

The joystick's X and Y axes were connected to analog pins:

• X → A0 (GPIO1)
• Y → A1 (GPIO2)

These inputs were confirmed using `analogRead()` and `Serial.print()` to verify the response to physical joystick movement. I also ensured the analog resolution matched the ESP32's default 12-bit ADC range (0 to 4095).

Conclusion

By verifying the I2C address using an I2C scanner, confirming GPIO pin mappings via official documentation, and testing each peripheral in isolation, I ensured the full addressing scheme worked correctly. This step was crucial to avoid overlapping resources and debugging conflicts. Proper addressing is foundational in embedded systems, especially when multiple input/output devices share the same communication bus or pin bank.

Joystick Analog Input Addressing

Every embedded project introduces a set of technical challenges, and this joystick-OLED-LED interface was no exception. Through iterative testing and debugging, I encountered several problems related to communication, flickering displays, unstable readings, and wiring misconfigurations. Here is a breakdown of the major problems and how they were fixed:

Problem 1: OLED Not Displaying Anything

• Issue: The OLED screen remained blank on startup even though the code compiled successfully.
• Cause: The I2C address was either incorrect or the OLED wasn’t connected to the expected pins.
• Fix: I uploaded an I2C scanner sketch to the board and verified the OLED was connected at 0x3C. I had initially misconnected SDA/SCL to the wrong GPIOs. After correcting them to GPIO5 (SDA) and GPIO4 (SCL), the display worked.

Problem 2: Flickering Text on OLED

• Issue: The OLED flickered every time a new direction was printed.
• Cause: This was due to the frequent use of `display.clearDisplay()` and redrawing everything on every loop iteration.
• Fix: I implemented a simple optimization where the OLED is only updated when the direction changes. I used a string variable `prevDirection` to store the last displayed value and compared it with the current one before updating the display.

Lessons Learned

These problems taught me the importance of:

• Proper hardware debugging through test sketches
• Using serial debugging to isolate problems
• Understanding noise and debounce in analog signals
• Verifying I2C wiring and address settings
• Consulting board-specific documentation (especially for non-standard pin maps)

By systematically tackling each issue, I was able to build a stable, real-time UI interface driven by joystick input.