TemperatureControlTutorial

#Temperature Control Simulation in C++

C++ Controller Implementation:

Here’s the C++ version of the temperature control logic with camelCase naming:

TempControl.h

#pragma once

class TempControl {
public:
    TempControl(float setPoint, float proportionalGain);

    void update(float currentTemp);

    float getHeaterPower() const;
    float getTemperatureError() const;

private:
    float setPoint;
    float proportionalGain;
    float heaterPower;
    float temperatureError;
};

TempControl.cpp

#include "TempControl.h"

TempControl::TempControl(float setPoint, float proportionalGain)
    : setPoint(setPoint), proportionalGain(proportionalGain), heaterPower(0), temperatureError(0) {}

void TempControl::update(float currentTemp) {
    // Calculate error between setpoint and current temperature
    temperatureError = setPoint - currentTemp;

    // Apply proportional control
    heaterPower = proportionalGain * temperatureError;

    // Limit heater power between 0 and 100%
    if (heaterPower > 100.0f) {
        heaterPower = 100.0f;
    } else if (heaterPower < 0.0f) {
        heaterPower = 0.0f;
    }
}

float TempControl::getHeaterPower() const {
    return heaterPower;
}

float TempControl::getTemperatureError() const {
    return temperatureError;
}

This C++ class represents a simple temperature controller with proportional control. It calculates the heater power based on the error between the desired temperature (setPoint) and the current temperature.

Create the Simulation Class:

We now integrate the TempControl class into a simulation class that inherits from the CppModel framework’s Simulation class.

SimulateTempControl.h

#pragma once
#include <cppmodel/Simulation.h>
#include "TempControl.h"

class SimulateTempControl : public CppModelBase::Simulation
{
public:
    SimulateTempControl(std::string apiKey);
    void runCyclic(double simulationTime) override;

private:
    TempControl* tempController;
};
SimulateTempControl.cpp

cpp
Copy code
#include "SimulateTempControl.h"

SimulateTempControl::SimulateTempControl(std::string apiKey)
    : CppModelBase::Simulation(apiKey), tempController(nullptr)
{
    name = "TempControl";

    time = 60;       // Run simulation for 60 seconds
    stepSize = 0.1;  // Simulation step size, 100ms
}

void SimulateTempControl::runCyclic(double simulationTime)
{
    if (tempController == nullptr) {
        // Initialize the TempControl object with inputs from CppModel
        float setPoint = inputs["Setpoint"];
        float proportionalGain = inputs["ProportionalGain"];
        tempController = new TempControl(setPoint, proportionalGain);
    }

    // Read current temperature input
    float currentTemp = inputs["CurrentTemperature"];

    // Update the temperature controller
    tempController->update(currentTemp);

    // Update the simulation outputs
    outputs["HeaterPower"] = tempController->getHeaterPower();
    outputs["TemperatureError"] = tempController->getTemperatureError();
}

Main Program:

Here’s the main.cpp file that runs the simulation:

main.cpp

#include "SimulateTempControl.h"

int main(void)
{
    SimulateTempControl sim(CPPMODEL_API_KEY);
    sim.simulate();
    return 0;
}

4. CMake Configuration: You’ll need a CMake configuration file to compile the project and link it with the CppModel library.

cmake Copy code project(TempControlCpp)

Add your API key here

add_compile_definitions(CPPMODEL_API_KEY="Your API key.")
add_executable(SimulateTempControl TempControl.cpp SimulateTempControl.cpp main.cpp)
target_link_libraries(SimulateTempControl CppModelBase)

Execution and Visualization:

Compile the project and run the executable. As with the previous example, a URL will be generated that allows you to visualize the simulation:

Copy code
UI: http://model.cppmodel.com?apiKey=Your_API_key&simName=TempControl

This link will take you to a web interface where you can observe how the heater power is controlled to maintain the desired temperature.