▷ Object-Oriented Programming in Arduino: Master OOP

The Object-Oriented Programming (OOP) is a paradigm that organizes code into objects, which combine data and behaviors into a single entity. Although Arduino primarily uses C++ (a language that supports OOP), many developers do not take advantage of these capabilities to create clearer and more scalable projects. In this article, we will see how to apply OOP in Arduino to achieve more organized, reusable, and maintainable.

The Four Pillars of OOP

OOP is based on four fundamental principles that we can also apply in Arduino projects:

Principle	Description	Benefit in Arduino
Encapsulation	Hide the internal details of an object and expose only a clear and controlled interface.	Protects hardware from incorrect access.
Abstraction	Show only the essentials and simplify internal complexity.	Facilitates the use of complex components without needing to understand their implementation.
Inheritance	Create new classes based on existing classes.	Allows for easy extension and reuse of functionalities.
Polymorphism	Make different objects respond to the same message differently.	Facilitates the creation of uniform interfaces for different devices.

Practical Example: Controlling an LED with OOP

As an example, we will create a class Ledthat encapsulates all the logic necessary to control an LED: turning it on, turning it off, adjusting its brightness, and making it blink.

Definition of the Led class

// Led.h - Header file
#ifndef LED_H
#define LED_H

#include <Arduino.h>

class Led {
private:
  int pin;      // LED pin
  bool state;  // Current state (true=on, false=off)
  int brightness; // Brightness level (0-255)

public:
 // Constructor
  Led(int pinLed);

 // Public methods
  void start();
  void turnOn();
  void turnOff();
  void toggle();
  void setBrightness(int level);
  void blink(int times, int duration);
  bool getState();
};
#endif

Implementation of the Led class

// Led.cpp - Implementation
#include "Led.h"

// Constructor
Led::Led(int pinLed) {
  pin = pinLed;
  state = false;
  brightness = 255;  // Default maximum brightness
}

// Initialize pin
void Led::start() {
  pinMode(pin, OUTPUT);
  turnOff();
}

// Turn on LED
void Led::turn on() {
 state = true;
  analogWrite(pin, brightness);
}

// Turn off LED
void Led::turnOff() {
 state = false;
  analogWrite(pin, 0);
}

// Change state
void Led::toggle() {
  if (state) turnOff();
  else turnOn();
}

// Adjust brightness
voidLed::setBrightness(int level) {
 brightness = constrain(level, 0, 255);
  if (state) analogWrite(pin, brightness);
}

// Blink
void Led::blink(int times, int duration) {
  for (int i = 0; i < times; i++) {
    toggle();
    delay(duration);
  }
}

// Get status
boolLed::getState() {
  return state;
}

Using the Led class in the main sketch

// main_sketch.ino
#include "Led.h"

// Create LED instances for different colors
Led redLed(9);    // red LED on pin 9 (PWM)
Led greenLed(10);  // green LED on pin 10 (PWM)
Led blueLed(11);   // blue LED on pin 11 (PWM)


void setup() {
  Serial.begin(9600);

  // Initialize the LEDs
  redLed.start();
  greenLed.start();
  blueLed.start();

  Serial.println("LED system initialized");
}

void loop() {
  // LED sequence with different brightness
  redLed.setBrightness(255);
  redLed.turnOn();
  delay(1000);

  // Show the state of the red LED
  Serial.print("Red LED state: ");
  Serial.println(redLed.getStatus() ? "ON" : "OFF");

  greenLed.setBrightness(150);
  greenLed.turnOn();
  delay(1000);

  blueLed.setBrightness(80);
  blueLed.turnOn();
  delay(1000);

 // Turn off all LEDs
  redLed.turnOff();
  greenLed.turnOff();
  blueLed.turnOff();
  delay(500);

 // Show the status of the red LED
  Serial.print("Red LED status: ");
  Serial.println(redLed.getStatus() ? "ON" : "OFF");

  // Make the green LED blink 3 times
  greenLed.blink(3, 300);
  delay(1000);
}

Inheritance Example: LedRGB (with composition)

The inheritance allows creating new classes based on existing ones. This avoids code repetition and makes it easier to extend functionalities. In this case, we start from the class Led and create a new class LedRGB, which controls an RGB LED composed of three LEDs (red, green, and blue).

Definition of the LedRGB class

// LedRGB.h
#ifndef LEDRGB_H
#define LEDRGB_H

#include "Led.h"

class LedRGB {
private:
 Led red;
 Green LED;
 Blue LED;

public:
  LedRGB(int pinR, int pinG, int pinB)
    : red(pinR), green(pinG), blue(pinB) {}

  void start() {
    red.start();
    green.start();
    blue.start();
  }

  void setColor(int r, int g, int b) {
    red.setBrightness(r);
    green.setBrightness(g);
    blue.setBrightness(b);

    red.turnOn();
    green.turnOn();
    blue.turn on();
  }

  void turn off() {
    red.turn off();
    green.turn off();
    blue.turn off();
  }
};
#endif

Usage of Led + LedRGB classes

// main_sketch.ino
#include "Led.h"
#include "LedRGB.h"


// Create LED instances for different colors
Led ledRed(9);    // red LED on pin 9 (PWM)
Led ledGreen(10);  // green LED on pin 10 (PWM)
Led blueLed(11);   // Blue LED on pin 11 (PWM)

// Create LedRGB instance
LedRGBledRGB(3, 5, 6);  // Pins R=3, G=5, B=6


void setup() {
  Serial.begin(9600);

  // Initialize the LEDs
  ledRed.start();
  ledGreen.start();
  ledBlue.start();

  // Initialize LedRGB
  ledRGB.start();

  Serial.println("LED system initialized");
}

void loop() {
 // LED sequence with different brightness levels
  redLed.setBrightness(255);
  redLed.turnOn();
  delay(1000);

 // Show the state of the red LED
  Serial.print("Red LED state: ");
  Serial.println(redLed.getState() ? "ON" : "OFF");

  greenLed.setBrightness(150);
  greenLed.turnOn();
  delay(1000);

  blueLed.setBrightness(80);
  blueLed.turnOn();
  delay(1000);

  // Turn off all LEDs
  ledRed.turnOff();
  ledGreen.turn off();
  blueLed.turn off();
  delay(500);

 // Show the status of the red LED
  Serial.print("Red LED status: ");
  Serial.println(redLed.getStatus() ? "ON" : "OFF");

 // Make the green LED blink 3 times
  greenLed.blink(3, 300);
  delay(1000);

 // Turn on red color RGB led
  Serial.println("Led Rgb");
  ledRGB.setColor(255, 0, 0);
  delay(1000);
  ledRGB.turn off();  //turn off RGB LED
  delay(1000);
}

In this example, LedRGBreuses the logic of Ledfor each of its channels (red, green, and blue). Thanks to the inheritanceand to object composition, we can control an RGB LED without duplicating code, leveraging the functionalities already developed in the class Led.

Advantages of Using OOP in Arduino

More organized code:Groups related data and behaviors
Reusability:You can use the same class in multiple projects
Maintainability:It's easier to make changes without breaking other parts of the code
Abstraction:Hides the complexity of the hardware behind simple interfaces
Scalability:Facilitates the addition of new functionalities

⚠️ Performance considerations:Although OOP offers many benefits, in Arduino with limited resources, you must be aware of memory usage. Avoid creating too many objects or using very deep inheritance that may consume memory.

Conclusion

Object-Oriented Programming in Arduino can transform the way you develop your projects, making your code more organized, reusable, and maintainable. Although it requires a shift in mindset from traditional procedural programming, the long-term benefits are significant.

Start with simple classes like the class Ledpresented here and gradually advances towards more complex structures. Soon you will discover that OOP allows you to create more sophisticated Arduino projects with less effort and cleaner code.

0/Leave a comment/Comments

Hello! We're so glad you've made it this far and are reading this article on Edeptec.

This form is an open space for you: you can leave a comment with your questions, suggestions, experiences, or simply your opinion on the topic discussed.

» Did you find the information helpful?
» Do you have any personal experiences you'd like to share?
» Do you have any topics you'd like to see covered in future articles?

Remember that this space is for learning and sharing, so we encourage you to participate respectfully and constructively. Your comments can help other readers who are on the same path, whether in electronics, programming, sports, or technology.

Thank you for being part of this learning community! Your participation is what makes this project grow.