inex
/
HLPL2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

REST API

This commit is contained in:
Inex Code 2021-04-13 16:07:55 +00:00
parent 49bb33c7bb
commit 62e9027911
2 changed files with 376 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
UML1/Makefile
View File

@ -1,9 +1,9 @@
CXX = g++
CXXFLAGS = -Wall -g --std=c++11
main: superpoohMQTT.o
$(CXX) -o main superpoohMQTT.o -lpthread -lmosquittopp -lmosquitto -lboost_system
main: superpoohREST.o
$(CXX) -o main superpoohREST.o -lpthread -lboost_system -lcrypto -lssl -lcpprest
superpoohMQTT.o: superpoohMQTT.cpp
clang-format -i --style=webkit superpoohMQTT.cpp
$(CXX) $(CXXFLAGS) -c superpoohMQTT.cpp
superpoohMQTT.o: superpoohREST.cpp
clang-format -i --style=webkit superpoohREST.cpp
$(CXX) $(CXXFLAGS) -c superpoohREST.cpp

371
UML1/superpoohREST.cpp Normal file
View File

@ -0,0 +1,371 @@
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <chrono>
#include <cmath>
#include <future>
#include <iostream>
#include <mutex>
#include <thread>
#include <cpprest/http_listener.h>
#include <cpprest/filestream.h>
#include <cpprest/uri.h>
#include <cpprest/json.h>
using namespace utility; // Common utilities like string conversions
using namespace web; // Common features like URIs.
using namespace web::http; // Common HTTP functionality
using namespace web::http::experimental::listener; // HTTP listener
using namespace concurrency::streams; // Asynchronous streams
using namespace std;
class PIDImpl {
public:
// Kp - proportional gain
// Ki - Integral gain
// Kd - derivative gain
// dt - loop interval time
// max - maximum value of manipulated variable
// min - minimum value of manipulated variable
PIDImpl(double dt, double max, double min, double Kp, double Kd, double Ki);
~PIDImpl();
// Returns the manipulated variable given a setpoint and current process value
double calculate(double setpoint, double pv);
private:
double _dt;
double _max;
double _min;
double _Kp;
double _Kd;
double _Ki;
double _pre_error;
double _integral;
};
/**
* Implementation
*/
PIDImpl::PIDImpl(double dt, double max, double min, double Kp, double Kd, double Ki)
: _dt(dt)
, _max(max)
, _min(min)
, _Kp(Kp)
, _Kd(Kd)
, _Ki(Ki)
, _pre_error(0)
, _integral(0)
{
}
double PIDImpl::calculate(double setpoint, double pv)
{
// Calculate error
double error = setpoint - pv;
// Proportional term
double Pout = _Kp * error;
// Integral term
_integral += error * _dt;
double Iout = _Ki * _integral;
// Derivative term
double derivative = (error - _pre_error) / _dt;
double Dout = _Kd * derivative;
// Calculate total output
double output = Pout + Iout + Dout;
//std::cout<<"out="<<output<< "Pout = "<< Pout <<" " <<Iout <<" "<< Dout <<std::endl;
// Restrict to max/min
if (output > _max)
output = _max;
else if (output < _min)
output = _min;
//std::cout << "outB=" << output << std::endl;
// Save error to previous error
_pre_error = error;
return output;
}
PIDImpl::~PIDImpl()
{
}
enum ECmd {
ENone,
EExit
};
ECmd cmd = ENone;
int counter = 0;
std::mutex mtx;
float targetH = 10.;
float getHZadFromUser()
{
return 10.;
}
class Bear {
float h;
float m;
float v;
float a;
public:
Bear()
{
v = 0; // m/s
a = 0; // m/s2
m = 10; // kg
h = 0; // Текущая высота
}
float getH()
{
return h;
}
float getV()
{
return v;
}
float getM()
{
return m;
}
float getA()
{
return a;
}
virtual void calc(float dt, float extrnForce)
{
float dh;
v = v + a * dt;
dh = v * dt;
h = h + dh;
a = (extrnForce - 9.8 * m) / m; // m * a = mg - F
if (h < 0) { // Stay on the ground
h = 0.;
v = 0.;
a = 0.;
}
}
void eat(float mass)
{
m = m + mass;
}
virtual void show()
{
std::cout << "h=" << h << std::endl;
}
};
class Engine;
class Engine {
float enginePower = 0; // n 0..500 n
float maxPower; // n
public:
Engine(float imaxPower)
{
enginePower = 0.;
maxPower = imaxPower;
}
void setPower(float enginePowerPercent)
{
if (enginePowerPercent > 100.)
enginePowerPercent = 100;
if (enginePowerPercent < -100.)
enginePowerPercent = -100;
enginePower = enginePowerPercent * (maxPower / 100.);
}
float getForce()
{
return enginePower;
}
};
class SmartFlyingBear : public Bear {
PIDImpl* pid;
Engine* pengine;
float hZad;
public:
SmartFlyingBear(PIDImpl* ppid, Engine* ppengine)
{
pid = ppid;
pengine = ppengine;
hZad = 0;
}
void setHZad(float val)
{
hZad = val;
}
virtual void calc(float dt, float extrnForce)
{
float enginePowerPercent = 0;
if (pid != nullptr) {
enginePowerPercent = pid->calculate(hZad, getH());
}
if (pengine != nullptr) {
pengine->setPower(enginePowerPercent);
Bear::calc(dt, extrnForce + pengine->getForce());
}
}
};
int model()
{
//PIDImpl pid(0.1, 100, -100, 0.05, 0.001, 0.1);
//Bear pooh;
SmartFlyingBear superpooh(new PIDImpl(0.1, 100, -100, 0.15, 0.001, 0.01), new Engine(500.));
float t = 0; // Время моделирования
float dt = 0.1; // s
float lastT = -5;
float hZad = 0; // Измененение высоты за шаг моделирования
while (cmd != EExit) {
mtx.lock();
hZad = targetH; // Неблокирующая функция для получения высоты
mtx.unlock();
if (abs(superpooh.getH() - hZad) < 1 && abs(t - lastT) > 5) {
superpooh.eat(0.1);
lastT = t;
}
superpooh.setHZad(hZad);
superpooh.show();
superpooh.calc(dt, 0);
t = t + dt;
if (t < 200) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
} else {
std::cout << "Weight = " << superpooh.getM() << std::endl;
std::cout << "Velocity = " << superpooh.getV() << std::endl;
std::cout << "Acceleration = " << superpooh.getA() << std::endl;
std::cout << "Time = " << t << std::endl;
std::cout << "===========" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
}
return 0;
}
void handle_signal(int s)
{
cmd = EExit;
}
/*
void message_callback(struct mosquitto* mosq, void* obj, const struct mosquitto_message* message)
{
bool match = 0;
printf("got message '%.*s' for topic '%s'\n", message->payloadlen, (char*)message->payload, message->topic);
mosquitto_topic_matches_sub("/pooh/height", message->topic, &match);
if (match) {
std::cout << "Going up!" << std::endl;
mtx.lock();
targetH = std::atof((char*)message->payload);
mtx.unlock();
}
mosquitto_topic_matches_sub("/pooh/land", message->topic, &match);
if (match) {
std::cout << "Going down!" << std::endl;
mtx.lock();
targetH = 0.;
mtx.unlock();
}
mosquitto_topic_matches_sub("/pooh/quit", message->topic, &match);
if (match) {
std::cout << "Exiting!" << std::endl;
cmd = EExit;
}
}*/
void handle_get(http_request message){
cout<<"Handle get: "<<message.to_string()<<endl;
json::value jsonObject;
jsonObject[U("target_height")] = json::value::number(targetH);
message.reply(status_codes::OK,jsonObject);
}
void handle_post(http_request message){
cout<<"Handle post: "<<message.to_string()<<endl;
json::value jsonObject;
try{
message.extract_json()
.then([&jsonObject](json::value jo){
cout<<"Val:"<<jo.serialize() << endl;
jsonObject = jo;
mtx.lock();
targetH = jsonObject.at(U("target_height")).as_number().to_double();
cout<<"Val:"<<targetH<< endl;
mtx.unlock();
})
.wait();
}
catch (const std::exception & e) {
printf("Error exception:%s\n", e.what());
}
message.reply(status_codes::OK,jsonObject);
}
void handle_quit(http_request message){
cout<<"Handle quit: "<<message.to_string()<<endl;
cmd = EExit;
message.reply(status_codes::OK);
}
int main()
{
int rc = 0;
web::http::experimental::listener::http_listener
listener(U("http://localhost:8080/cpprest"));
listener.support(methods::GET,handle_get);
listener.support(methods::POST,handle_post);
listener.support(methods::DEL,handle_quit);
try{
std::thread th(model);
listener.open()
.then([&listener](){printf("\nStarting svrRest\n");})
.wait();
while(cmd != EExit);
th.join();
}
catch (const std::exception & e) {
printf("Error exception:%s\n", e.what());
}
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
return rc;
}