Uso de SOLID com C para Projeto em IoT

Neste projeto de IoT, aplicamos os princípios SOLID para garantir que nosso código seja modular, extensível e fácil de manter.

Princípios SOLID

1. Single Responsibility Principle (SRP)

Cada classe ou módulo deve ter apenas uma razão para mudar.

• Exemplo: Nossa classe SensorTemperature é responsável apenas pela leitura da temperatura do ambiente e não tem conhecimento sobre outros aspectos do sistema.

2. Open/Closed Principle (OCP)

As entidades de software devem estar abertas para extensão, mas fechadas para modificação.

• Exemplo: Podemos estender a funcionalidade do nosso sistema adicionando novos sensores ou dispositivos de saída sem modificar o código existente.

3. Liskov Substitution Principle (LSP)

Objetos de um programa devem ser substituíveis por instâncias de seus subtipos sem afetar a corretude do programa.

• Exemplo: Podemos substituir um sensor de temperatura por um sensor de umidade sem alterar o comportamento do sistema.

4. Interface Segregation Principle (ISP)

Muitas interfaces específicas são melhores do que uma interface única genérica.

• Exemplo: Dividimos interfaces específicas para sensores (ISensor) e dispositivos de saída (IOutputDevice) em vez de ter uma única interface genérica.

5. Dependency Inversion Principle (DIP)

Dependa de abstrações e não de implementações.

• Exemplo: Nossas classes dependem de interfaces (por exemplo, ISensor) em vez de implementações concretas, permitindo a troca fácil de implementações específicas.

Exemplo de Implementação

class ISensor {
public:
    virtual float readData() = 0;
    virtual ~ISensor() {}
};

class SensorTemperature : public ISensor {
public:
    float readData() override {
        // Código para ler temperatura
    }
};

class IOutputDevice {
public:
    virtual void displayData(float data) = 0;
    virtual ~IOutputDevice() {}
};

class DisplayLCD : public IOutputDevice {
public:
    void displayData(float data) override {
        // Código para exibir dados no LCD
    }
};

class DisplayLED : public IOutputDevice {
public:
    void displayData(float data) override {
        // Código para exibir dados em LEDs
    }
};

class DataProcessor {
private:
    ISensor* sensor;
    IOutputDevice* outputDevice;

public:
    DataProcessor(ISensor* sensor, IOutputDevice* outputDevice)
        : sensor(sensor), outputDevice(outputDevice) {}

    void processData() {
        float data = sensor->readData();
        outputDevice->displayData(data);
    }
};

Neste exemplo, aplicamos SRP dividindo as responsabilidades entre as classes SensorTemperature, DisplayLCD e DisplayLED. Usamos OCP permitindo a extensão de funcionalidades sem modificar o código existente. Seguimos o LSP garantindo que os sensores possam ser substituídos por instâncias de seus subtipos. Aplicamos ISP dividindo as interfaces em ISensor e IOutputDevice. E finalmente, usamos DIP dependendo de abstrações em vez de implementações concretas.