Week 10: Output Devices

                        Code:
                        #include <Wire.h>
                        #include <Adafruit_GFX.h>
                        #include <Adafruit_SSD1306.h>
                        
                        #define Height 128
                        #define Width 64
                        
                        Adafruit_SSD1306 display(Height,Width,&Wire,-1);
                        
                        void setup(){
                        Serial.begin(115200);
                        
                        if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3D)){
                            Serial.println ("I2C initialisation failed");
                            for(;;);
                        }
                        delay(200);
                        Serial.println ("I2C initialisation sucessful");
                        
                        display.clearDisplay();
                        display.setTextSize(1);
                        display.setTextColor(WHITE);
                        display.setCursor(0,0);
                        display.println("Hello world!");
                        display.display();
                        Serial.println ("Display has been sucessfully programmed"); 
                        }
                        
                        void loop(){ 
                        }
                                

                        E (135) i2c.master: i2c_master_multi_buffer_transmit(1186): I2C I2C initialisation sucessful
                        Display has been sucessfully programmed
                                

The given code initializes and controls an SSD1306 OLED display using the Adafruit_SSD1306 library over the I2C protocol.

Issues & Fixes:

1. Incorrect Parameter Order in Constructor
   • The constructor should be Adafruit_SSD1306 display(Width, Height, &Wire, -1);
   • Currently, Height and Width are swapped.
2. Incorrect I2C Address
   • Most SSD1306 displays use 0x3C instead of 0x3D.
   • Try changing display.begin(SSD1306_SWITCHCAPVCC, 0x3D) to display.begin(SSD1306_SWITCHCAPVCC, 0x3C).
3. Possible I2C Wiring Issue
   • Ensure the SDA and SCL pins are correctly connected.
   • Run an I2C scanner sketch to confirm the device address.
4. Check Power Supply
   • Ensure the OLED module is receiving the correct voltage (3.3V or 5V, depending on your module).

Corrected Code:

                        #include <Wire.h>
                        #include <Adafruit_GFX.h>
                        #include <Adafruit_SSD1306.h>
                        
                        #define Width 128
                        #define Height 64
                        
                        Adafruit_SSD1306 display(Width, Height, &Wire, -1);
                        
                        void setup(){
                        Serial.begin(115200);
                        
                        if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)){
                            Serial.println("I2C initialization failed");
                            for(;;);
                        }
                        delay(200);
                        Serial.println("I2C initialization successful");
                        
                        display.clearDisplay();
                        display.setTextSize(1);
                        display.setTextColor(WHITE);
                        display.setCursor(0,0);
                        display.println("Hello world!");
                        display.display();
                        Serial.println("Display has been successfully programmed");
                        }
                        
                        void loop(){
                        }
                                

Try these fixes and verify your connections to ensure proper functionality!

    #include <Wire.h>

    void setup()
    {
    Serial.begin (115200);
    while (!Serial)
    {
    }

    Serial.println ();
    Serial.println ("I2C scanner. Scanning ...");
    byte count = 0;
    pinMode(13,OUTPUT); 
    digitalWrite(13,HIGH);
    Wire.begin();
    for (byte i = 1; i < 120; i++)
    {
        Wire.beginTransmission (i);
        if (Wire.endTransmission () == 0)
        {
        Serial.print ("Found address: ");
        Serial.print (i, DEC);
        Serial.print (" (0x");
        Serial.print (i, HEX);
        Serial.println (")");
        count++;
        delay (1); 
        } 
    } 
    Serial.println ("Done.");
    Serial.print ("Found ");
    Serial.print (count, DEC);
    Serial.println (" device(s).");
    } 

    void loop() {}
            

This is an I2C scanner program written for an Arduino. It scans for devices connected to the I2C (Inter-Integrated Circuit) bus and prints their addresses to the serial monitor.

1. Including the Required Library

#include <Wire.h>

Includes the Wire library to enable I2C communication.

2. Setup Function

void setup()

The setup() function runs once at the start.

3. Initializing Serial Communication

Serial.begin(115200);

Starts serial communication at 115200 baud rate.

while (!Serial) {}

Waits for the Serial Monitor to open (useful for some boards).

4. Starting the Scan

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

Prints a message indicating that the I2C scan is starting.

byte count = 0;

Initializes a variable to count detected I2C devices.

5. Configuring an LED Indicator

pinMode(13, OUTPUT);
                    digitalWrite(13, HIGH);

Turns on the built-in LED on pin 13.

6. Initializing I2C Communication

Wire.begin();

Starts the I2C communication.

7. Scanning for I2C Devices

for (byte i = 1; i < 120; i++)

Loops through all possible I2C addresses (1 to 119).

Wire.beginTransmission(i);

Attempts to start communication with the device at address i.

if (Wire.endTransmission() == 0)

Checks if the device acknowledges communication.

Serial.print("Found address: ");

Prints the detected I2C device address.

delay(1);

Adds a 1-millisecond delay to avoid overloading the I2C bus.

8. Completing the Scan

Serial.println("Done.");

Indicates that the scan is complete.

9. Loop Function

void loop() {}

The loop() function is empty since the scan is done only once.

10. Usage

• Upload the code to an Arduino board.
• Open the Serial Monitor (set baud rate to 115200).
• See detected I2C addresses of connected devices.

11. Why is this useful?

It helps find the I2C addresses of unknown devices, which is useful for working with sensors, displays, or motor controllers.

The variable byte is used in this Arduino I2C scanner program for efficiency and to match the expected data type for I2C addresses. Here’s why:

1. Memory Efficiency

• A byte in Arduino is an 8-bit unsigned integer (0-255).
• I2C addresses range from 0 to 127, which fits within a byte.
• Using a byte instead of an int (which is 16-bit) saves memory.

2. Matching I2C Address Format

• The function Wire.beginTransmission(i) expects an 8-bit address.
• Since byte is 8-bit, it avoids unnecessary type conversions.

3. Faster Execution

• On 8-bit microcontrollers (e.g., ATmega328P in Arduino Uno), byte operations are faster.
• Using an int (16-bit) would require extra processing, slightly slowing execution.

Alternative:

If working with 10-bit I2C addressing, uint16_t (16-bit unsigned integer) would be a better choice.

Conclusion: Using byte in this case is memory-efficient, type-appropriate, and optimized for performance. 🚀

An unsigned integer is a type of integer that only stores non-negative values (0 and positive numbers). Unlike signed integers, which can be positive or negative, unsigned integers do not have a sign.

1. No Negative Numbers

• Signed integers store both negative and positive numbers (e.g., -10, 0, 25).
• Unsigned integers only store positive numbers and zero (e.g., 0, 1, 255).

2. Increased Positive Range

• Since no bits are used for the sign, unsigned integers can store larger positive values in the same memory space.
• Example (for an 8-bit integer):
  • Signed 8-bit integer: -128 to 127
  • Unsigned 8-bit integer: 0 to 255

3. Common Use Cases

• When negative numbers aren’t needed, using unsigned integers saves memory and extends the range.
• Examples:
  • I2C addresses (0-127)
  • Sensor readings (e.g., distance in millimeters)
  • Loop counters (if always positive)

4. Example in Arduino

                    byte value = 200;  // 'byte' is an 8-bit unsigned integer (0-255)
                    unsigned int largeValue = 50000;  // 16-bit unsigned integer (0-65535)
                            

If you try to store -5 in an unsigned integer, it will wrap around to a large positive number due to underflow.

Let me know if you need more details! 🚀

This line of code initializes an Adafruit SSD1306 OLED display object using the Adafruit_SSD1306 library.

Adafruit_SSD1306 display(Height, Width, &Wire, -1);

Explanation of Parameters:

• Height → The height (in pixels) of the OLED display (e.g., 32 or 64).
• Width → The width (in pixels) of the OLED display (e.g., 128).
• &Wire → A reference to the I2C communication interface. Wire is the default I2C object for communication.
• -1 → The reset pin number.
  • If -1, the display does not have a dedicated reset pin, and a software reset is used.
  • Otherwise, you should specify the GPIO pin number connected to the display’s reset pin.

Example Initialization:

For a 128x64 OLED display using I2C:

Adafruit_SSD1306 display(128, 64, &Wire, -1);

For a 128x32 OLED display using I2C:

Adafruit_SSD1306 display(128, 32, &Wire, -1);

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
                            Serial.println(F("SSD1306 allocation failed"));
                            for(;;);
                        }

Understanding the Code

This block of code initializes an SSD1306 OLED display and checks whether the initialization was successful.

Breaking It Down

1️⃣ display.begin(SSD1306_SWITCHCAPVCC, 0x3C)

• Initializes the OLED display.
• Parameters:
  • SSD1306_SWITCHCAPVCC → Uses an internal charge pump for power.
  • 0x3C → I2C address of the display (some models use 0x3D).

2️⃣ if (!display.begin(...))

• The ! (logical NOT) operator negates the result of display.begin().
• If the initialization fails, display.begin() returns false, making !false → true.
• This triggers the error-handling block.

3️⃣ Serial.println(F("SSD1306 allocation failed"));

• Prints an error message to the Serial Monitor if initialization fails.
• F("...") stores the string in Flash memory (PROGMEM) to save RAM.

4️⃣ for(;;); → Infinite Loop (Halt Execution)

• for(;;); is an infinite loop that prevents further code execution.
• If the display fails, the program stays in this loop to prevent further errors.

What Happens in Different Scenarios?

OLED Initialization	display.begin() Returns	if(!display.begin(...)) Evaluates To	Outcome
Successful	true	false	Code continues normally
Failed	false	true	Error message printed, program halts

This error in Wokwi is a linker error, meaning the compiler successfully compiled your code, but the linker failed to resolve a reference to the function _Z4loopv. Let's break it down:

Understanding the Error

• The error mentions an "undefined reference to `_Z4loopv`".
• _Z4loopv is the mangled name of the function loop() in C++.
• This means the linker couldn't find an implementation of the loop() function.

The error originates from main.cpp in the ESP32 core, specifically from loopTaskPv, which is the FreeRTOS task responsible for running the loop() function.

Possible Causes & Fixes

1. Missing loop() Function

The Arduino framework requires both setup() and loop() functions. If loop() is missing, the linker will fail.

Fix: Add the missing loop() function in your sketch.

                        void setup() {
                            Serial.begin(115200);
                            Serial.println("Setup complete.");
                        }
                        
                        void loop() {
                            Serial.println("Loop running...");
                            delay(1000);
                        }
                                

2. Incorrect Function Signature

Even if you define loop(), the function signature must be:

                        void loop() {
                            // Your code here
                        }
                                

If you accidentally define it incorrectly (e.g., int loop() or void loop(int)), the linker won't recognize it.

Fix: Ensure loop() has the correct signature.

3. Corrupt or Incomplete Wokwi Project

Sometimes, Wokwi might not properly load all required files.

Fix: Try the following:

• Refresh Wokwi (Ctrl+Shift+R).
• Create a new ESP32 project in Wokwi and copy your code.
• Ensure you are using the correct ESP32 board in Wokwi.

4. Custom main() Instead of Arduino Framework

If you're writing custom ESP32 code (not using the Arduino framework), you must provide your own loop() or redefine the main execution.

Fix: Either:

• Stick to the standard setup() and loop().
• If you're using main(), you need to handle the main execution loop yourself.

Conclusion

This error happens because the ESP32 Arduino core expects a loop() function, and it’s missing. The simplest fix is to define a valid loop() function in your code. If the problem persists, try resetting Wokwi or using a fresh ESP32 project.

Let me know if you need more help! 🚀

This error occurs because SCLpin is being used incorrectly in the code.

Issue:

• The macro definition #define SCLpin 6 is conflicting with existing identifiers.
• In C++, predefined macros or function names cannot be redefined as constants.

Fix:

Use uppercase naming conventions to avoid conflicts:

#define SCL_PIN 6
                        #define SDA_PIN 5

This error occurs when the compiler cannot find the definition of the loop() function.

Possible Causes:

• The loop() function is missing.
• The function name is misspelled.
• There is a missing function prototype or implementation.

Fix:

Ensure that loop() is defined in the sketch:

void loop() {
                            // Your code here
                        }

If the display is not showing anything, the issue could be due to incorrect wiring, incorrect I2C address, or missing initialization.

Debugging Steps:

1. Check the I2C pins: ESP32 default I2C pins are SDA: GPIO 21, SCL: GPIO 22.
2. Run an I2C scanner to find the display address:

#include <Wire.h>
                        
                        void setup() {
                            Serial.begin(115200);
                            Wire.begin(21, 22);
                            Serial.println("Scanning I2C devices...");
                            for (byte address = 1; address < 127; address++) {
                                Wire.beginTransmission(address);
                                if (Wire.endTransmission() == 0) {
                                    Serial.print("I2C device found at 0x");
                                    Serial.println(address, HEX);
                                }
                                delay(10);
                            }
                        }
                        
                        void loop() {}

Fix:

• Verify power connections: VCC → 3.3V or 5V, GND → GND.
• Use correct I2C address in the initialization.

The U8g2 library is a popular graphics library used to interface with monochrome displays (OLEDs, LCDs) in embedded systems like Arduino and ESP32. The parameters in U8g2 functions usually define the display type, communication method, and pin configuration.

1. Constructor Parameters

When initializing a display, U8g2 uses constructors with parameters specifying:

• Display model
• Communication method
• Pin configuration

Example:

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

2. Breakdown of Parameters

Parameter	Meaning
U8G2_SSD1306_128X64_NONAME_F_HW_I2C	Display model (SSD1306 128x64) with Full buffer mode & Hardware I2C
U8G2_R0	Rotation (R0 = No rotation, R1 = 90°, R2 = 180°, R3 = 270°)
U8X8_PIN_NONE	Reset pin (none in this case, or can be assigned a GPIO pin)

The function u8g2.drawFilledEllipse(x, y, rx, ry) is used to draw a filled ellipse on the display using the U8g2 library.

Function Breakdown:

u8g2.drawFilledEllipse(62, 55, 8, 5);

Parameter	Meaning
62	X-coordinate of the ellipse center
55	Y-coordinate of the ellipse center
8	Radius along the X-axis (horizontal)
5	Radius along the Y-axis (vertical)

Example Usage:

                    #include 
                    #include 
                    
                    // Initialize display (example for SSD1306 with I2C)
                    U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
                    
                    void setup() {
                        u8g2.begin();  // Start the display
                    }
                    
                    void loop() {
                        u8g2.firstPage();
                        do {
                            u8g2.drawFilledEllipse(62, 55, 8, 5); // Draw ellipse
                        } while (u8g2.nextPage());
                    
                        delay(1000);
                    }
                                

Explanation:

• The function draws an ellipse centered at (62, 55), with a horizontal radius of 8 and a vertical radius of 5.
• The firstPage() and nextPage() loop is used for page-buffered drawing (needed for certain displays).
• The delay(1000); ensures the drawing remains visible before updating again.

The function ESP32PWM::allocateTimer(a); is used to allocate hardware timers on the ESP32 for generating PWM (Pulse Width Modulation) signals. The ESP32 has four hardware PWM timers (0-3), and each timer can be used to generate PWM signals for servos or other devices requiring precise timing.

How It Works:

• Each call to allocateTimer(a) reserves a specific timer for PWM use.
• The numbers 0, 1, 2, 3 correspond to the four available hardware timers on the ESP32.
• Allocating a timer ensures that PWM signals are generated with precise timing, without conflicts.

No, you do not need to manually add a timer delay for PWM in your code. The ESP32Servo library uses hardware timers to generate PWM signals automatically.

Why?

• PWM signals require precise pulse widths, which the ESP32 hardware timers handle internally.
• Delays (delay()) should only be used to control the movement speed of a servo, not for PWM signal timing.

Example (Without Unnecessary Delay):

                        for (int pos = 0; pos <= 180; pos++) {
                            myservo.write(pos); // Move servo to position
                            delay(15);          // Controls movement speed, not PWM signal
                        }
                                

If you do not call ESP32PWM::allocateTimer(a);, the ESP32 may not generate PWM signals correctly, and your servo might not move as expected.

Possible Issues:

• The ESP32Servo library requires a timer to generate PWM, and without allocation, PWM signals may not work.
• Conflicts may arise if multiple servos or PWM devices are used without assigned timers.

Solution: Always allocate a timer before attaching a servo.

                        ESP32PWM::allocateTimer(0); // Allocate Timer 0
                        myservo.attach(18, 500, 2500); // Attach servo to GPIO 18
                                

The function ESP32PWM::allocateTimer(a); allows the user to explicitly assign one of the four available hardware PWM timers on the ESP32.

Parameters:

• a - Specifies which timer (0 to 3) should be allocated for PWM.

Key Features:

• Ensures that specific timers are dedicated to PWM functions.
• Prevents conflicts when using multiple PWM devices.
• Explicitly defining timers allows better control over hardware resources.

Example: Single Servo

                        ESP32PWM::allocateTimer(2); // Allocates Timer 2 for PWM use
                        Servo myservo;
                        myservo.attach(5, 500, 2500); // Attaches a servo to GPIO 5 using Timer 2
                                

Example: Multiple Servos

                        ESP32PWM::allocateTimer(0);
                        ESP32PWM::allocateTimer(1);
                        Servo servo1;
                        Servo servo2;
                        servo1.attach(18, 500, 2500); // Attach first servo to GPIO 18 using Timer 0
                        servo2.attach(19, 500, 2500); // Attach second servo to GPIO 19 using Timer 1
                                

What Happens If You Don't Allocate a Timer?

• The library may not function correctly, causing PWM output to fail.
• Timers might be shared improperly between different peripherals, leading to erratic behavior.

Modifying an Arduino library involves accessing and editing its header (.h) and implementation (.cpp) files. Here's a step-by-step guide:

1. Locate the Library:

• Go to your Arduino libraries folder. It's usually found at:
• Documents/Arduino/libraries/ (Windows/Mac)
• Find the folder of the library you want to modify.

2. Open the Header (.h) and Implementation (.cpp) Files:

• Open the files using a code editor (like VS Code, Notepad++, Arduino IDE).

3. Make Your Changes:

• You can modify functions, variables, or even add new ones.
• Make sure to maintain correct C++ syntax and structure.

4. Save and Test:

• Save your edits and test your changes with an Arduino sketch that uses the library.
• Watch for compile-time errors and test behavior on the hardware.

Note:

If you installed the library via the Library Manager, your edits may be overwritten during updates. To avoid this:

• Copy the library folder, rename it, and include it manually with #include "MyModifiedLibrary.h".

getScreenConstraint_Y() is likely a helper function that returns the maximum Y-axis value the eyes (or animation) can move to on an OLED screen.

What It Does:

• Prevents eye elements from going outside the visible screen area.
• Could return something like SCREEN_HEIGHT - margin.

How to Modify It:

1. Open the `.h` file where it is defined.
2. Look for the function signature or inline definition:

int getScreenConstraint_Y() {
                        return screenHeight - bottomMargin;
                    }

3. Adjust the return value or the logic based on your OLED dimensions or desired animation boundaries.

That’s totally okay — in smaller libraries (especially optimized ones for microcontrollers), the implementation is sometimes done entirely in the header file.

How This Works:

• Function bodies are defined directly inside the header using inline functions or directly in-place.
• This makes the library easier to manage for small footprints (like OLED graphics).

How to Modify:

• Just edit the header file directly where the function is defined.
• Search for getScreenConstraint_Y or any other function name in the `.h` file.

In a typical 0.96" dual-color OLED (often using the SSD1306 driver), the screen is 128x64 pixels. The two-color region is usually split vertically like this:

• Top 16 pixels → Yellow
• Bottom 48 pixels → Blue

So the color changes at:

Y = 16

If you draw pixels from y = 0 to y = 15, they’ll appear yellow, and from y = 16 to y = 63, they’ll appear blue.

Not directly. The idle boolean usually represents whether the eye (or robot animation) is currently inactive or in an "idle" state.

How it may influence positioning:

• If idle == true: The eye might stop moving or return to a resting (neutral) position.
• If idle == false: The eye is actively moving, so target coordinates like eyeLxNext or eyeLyNext are used.

Check where idle is used in your `.h` file — it might be used to control whether new random positions are generated or not.

This line assigns a random Y-coordinate for the eye to move vertically within a constrained screen space.

Breakdown:

• random(N) → Generates a random number between 0 and N - 1.
• getScreenConstraint_Y() → Returns the highest allowed Y value (likely less than screen height).
• eyeLyNext → Stores the next vertical coordinate for eye movement.

Example:

getScreenConstraint_Y() returns 48;
                    random(48) could return any value from 0 to 47.

This makes the eye move to a new random vertical position each time.

To Customize:

• To avoid edge overlap: random(10, getScreenConstraint_Y() - 10)
• To smooth movement: use easing, interpolation, or Perlin noise instead of randomness.