CloudPendulum — Language Bindings

#include <libcloudpendulum/client.hpp>
#include <chrono>
#include <cmath>
#include <iostream>

const std::string user_token = "user token";
const std::string experiment_type = "SimplePendulum";
const double experiment_time = 30.0;
const double preparation_time = 5.0;
const bool record = false;
const std::optional<int> cell_id = std::nullopt;
const double delta_time = 0.01;
const std::vector<std::optional<double>> kp = { 0.04 };
const std::vector<std::optional<double>> kd = { 0.017 };

int main() {
    Client client;

    const auto [session_token, livestream_url] = client.start_experiment(
        user_token, experiment_type, experiment_time,
        preparation_time, record, cell_id
    );
    std::cout << "Session token: " << session_token << std::endl;

    client.set_impedance_controller_params(kp, kd, session_token);

    auto t_experiment_start = std::chrono::steady_clock::now();
    auto t_iteration_start = std::chrono::steady_clock::now();
    while (true) {
        double t = std::chrono::duration<double>(
            t_iteration_start - t_experiment_start
        ).count();
        if (t >= experiment_time) break;

        std::vector<double> position = { std::sin(t) };
        client.set_position(position, session_token);

        while (true) {
            double t = std::chrono::duration<double>(
                std::chrono::steady_clock::now() - t_iteration_start
            ).count();
            if (t >= delta_time) break;
        }

        t_iteration_start = std::chrono::steady_clock::now();
    }

    client.stop_experiment(session_token);
    std::cout << "Stopped experiment" << std::endl;
}

g++ <filename> -l libcloudpendulum

from pycloudpendulum import Client
import time
import math

user_token = "user token"
experiment_type = "SimplePendulum"
experiment_time = 30.0
preparation_time = 5.0
record = False
cell_id = None
delta_time = 0.01
kp = [0.04]
kd = [0.017]

client = Client()
session_token, livestream_url = client.start_experiment(
    user_token, experiment_type, experiment_time, preparation_time, record, cell_id,
    None, None, None
)
print("Session token: ", session_token)

client.set_impedance_controller_params(kp, kd, session_token)

t_experiment_start = time.time()
t_iteration_start = time.time()
t = 0.0
while time.time() - t_experiment_start < experiment_time:
    target_pos = [math.sin(t)]
    client.set_position(target_pos, session_token)

    while time.time() - t_iteration_start < delta_time:
        pass

    current_time = time.time()
    t = current_time - t_experiment_start
    t_iteration_start = current_time

client.stop_experiment(session_token)
print("Stopped experiment")

import jlcloudpendulum

user_token = "user token"
experiment_type = "SimplePendulum"
experiment_time = 10.0
preparation_time = 5.0
record = false
cell_id = nothing
delta_time = 0.01
kp = [0.04]
kd = [0.017]

client = jlcloudpendulum.Client()
session_token, livestream_url = jlcloudpendulum.start_experiment(
    client, user_token,
    experiment_type, experiment_time, preparation_time, record, cell_id,
    nothing, nothing, nothing
)
println("Session token: ", session_token)

jlcloudpendulum.set_impedance_controller_params(client, kp, kd, session_token)

t_experiment_start = time()
t_iteration_start = time()
t = 0.0
while time() - t_experiment_start < experiment_time
    target_pos = [sin(t * 2.0) * 2.0]
    jlcloudpendulum.set_position(client, target_pos, session_token)

    while time() - t_iteration_start < delta_time
    end

    current_time = time()
    global t = current_time - t_experiment_start
    global t_iteration_start = current_time
end

jlcloudpendulum.stop_experiment(client, session_token)
println("Stopped experiment")