el proceso consta de tres estanques, el control del flujo de dos de ellos se realiza por medio de dos v´alvulas y la salida del ´ultimo estanque es controlada por la ´ultima v´alvula, se busca que exista una mezcla del liquido del estanque TK-00 y el TK-01, el porcentaje de llenado de cada estanque debe realizarse por medio de las v´alvulas VAL-01y VAL-02, y el vaciado del estanque TK-02 debe realizarse con la v´alvula VAL-03. Realice una librer´ıa en lenguaje C++ de nombre CONTROLPLANTA en donde existan dos clases, ESTANQUE con el atributo de NIVELESTANQUE y VALVULA con el atributo de ESTADOVALVULA, como m´ınimo (puede agregar m´as atributos dentro de cada clase, m´as clases y funciones en la librer´ıa si es necesario). Luego utilizar la librer´ıa para escribir un programa en C++ en donde se pueda realizar el control de la planta

Aquí te presento la librería `CONTROLPLANTA` en C++ con las dos clases `ESTANQUE` y `VALVULA` como se solicitó:

**controlplanta.h**
```cpp
#ifndef CONTROLPLANTA_H
#define CONTROLPLANTA_H

#include <iostream>

class ESTANQUE {
public:
    ESTANQUE(std::string nombre);
    void setNivelEstanque(double nivel);
    double getNivelEstanque();
    std::string getNombre();

private:
    std::string nombre;
    double nivelEstanque;
};

class VALVULA {
public:
    VALVULA(std::string nombre);
    void setEstadoValvula(bool estado);
    bool getEstadoValvula();
    std::string getNombre();

private:
    std::string nombre;
    bool estadoValvula;
};

#endif  // CONTROLPLANTA_H
```

**controlplanta.cpp**
```cpp
#include "controlplanta.h"

ESTANQUE::ESTANQUE(std::string nombre) : nombre(nombre), nivelEstanque(0.0) {}

void ESTANQUE::setNivelEstanque(double nivel) {
    nivelEstanque = nivel;
}

double ESTANQUE::getNivelEstanque() {
    return nivelEstanque;
}

std::string ESTANQUE::getNombre() {
    return nombre;
}

VALVULA::VALVULA(std::string nombre) : nombre(nombre), estadoValvula(false) {}

void VALVULA::setEstadoValvula(bool estado) {
    estadoValvula = estado;
}

bool VALVULA::getEstadoValvula() {
    return estadoValvula;
}

std::string VALVULA::getNombre() {
    return nombre;
}
```

Ahora, te presento el programa principal que utiliza la librería `CONTROLPLANTA` para controlar la planta:

**main.cpp**
```cpp
#include "controlplanta.h"

int main() {
    // Crear estanques
    ESTANQUE tk00("TK-00");
    ESTANQUE tk01("TK-01");
    ESTANQUE tk02("TK-02");

    // Crear valvulas
    VALVULA val01("VAL-01");
    VALVULA val02("VAL-02");
    VALVULA val03("VAL-03");

    // Establecer niveles iniciales
    tk00.setNivelEstanque(50.0);
    tk01.setNivelEstanque(75.0);
    tk02.setNivelEstanque(25.0);

    // Establecer estados iniciales de las valvulas
    val01.setEstadoValvula(true);
    val02.setEstadoValvula(true);
    val03.setEstadoValvula(false);

    // Mostrar estados iniciales
    std::cout << "Estados iniciales:" << std::endl;
    std::cout << "TK-00: " << tk00.getNivelEstanque() << "%" << std::endl;
    std::cout << "TK-01: " << tk01.getNivelEstanque() << "%" << std::endl;
    std::cout << "TK-02: " << tk02.getNivelEstanque() << "%" << std::endl;
    std::cout << "VAL-01: " << (val01.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;
    std::cout << "VAL-02: " << (val02.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;
    std::cout << "VAL-03: " << (val03.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;

    // Simular control de la planta
    for (int i = 0; i < 10; i++) {
        // Controlar nivel de TK-00
        if (tk00.getNivelEstanque() < 50.0) {
            val01.setEstadoValvula(true);
        } else if (tk00.getNivelEstanque() > 60.0) {
            val01.setEstadoValvula(false);
        }

        // Controlar nivel de TK-01
        if (tk01.getNivelEstanque() < 75.0) {
            val02.setEstadoValvula(true);
        } else if (tk01.getNivelEstanque() > 80.0) {
            val02.setEstadoValvula(false);
        }

        // Controlar nivel de TK-02
        if (tk02.getNivelEstanque() < 25.0) {
            val03.setEstadoValvula(true);
        } else if (tk02.getNivelEstanque() > 30.0) {
            val03.setEstadoValvula(false);
        }

        // Mostrar estados actuales
        std::cout << "Iteración " << i + 1 << ":" << std::endl;
        std::cout << "TK-00: " << tk00.getNivelEstanque() << "%" << std::endl;
        std::cout << "TK-01: " << tk01.getNivelEstanque() << "%" << std::endl;
        std::cout << "TK-02: " << tk02.getNivelEstanque() << "%" << std::endl;
        std::cout << "VAL-01: " << (val01.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;
        std::cout << "VAL-02: " << (val02.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;
        std::cout << "VAL-03: " << (val03.getEstadoValvula() ? "Abierta" : "Cerrada") << std::endl;
        std::cout << std::endl;
    }

    return 0;
}
```

Este programa simula el control de la planta con los estanques `TK-00`, `TK-01` y `TK-02`, y las valvulas `VAL-01`, `VAL-02` y `VAL-03`. El programa establece los niveles iniciales de los estanques y los estados iniciales de las valvulas, y luego simula el control de la planta durante 10 iteraciones. En cada iteración, el programa controla el nivel de cada estanque y ajusta el estado de las valvulas según sea necesario. Finalmente, el programa muestra los estados actuales de los estanques y las valvulas en cada iteración.