robotka.h

Zobrazit dokumentaci tohoto souboru.

 
#ifndef _LIBRB_H
#define _LIBRB_H
 
#include <memory>
 
#include <fmt/core.h>
#include <fmt/printf.h>
 
#include <Arduino.h>
 
#include "SmartLeds.h"
 
#include "SmartServoBus.hpp"
 
#include "RBCX.h"
#include "gridui.h"
#include "rbprotocol.h"
 
using namespace gridui;
 
struct rkPinsConfig {
    rkPinsConfig()
        : line_cs(5)
        , line_mosi(23)
        , line_miso(19)
        , line_sck(18)
        , smartled_sig(12)
        , ir_adc_chan_left(ADC1_CHANNEL_0)
        , ir_adc_chan_right(ADC1_CHANNEL_3) {
    }
 
    uint8_t line_cs;
    uint8_t line_mosi;
    uint8_t line_miso;
    uint8_t line_sck;
 
    uint8_t smartled_sig;
 
    adc1_channel_t ir_adc_chan_left;
    adc1_channel_t ir_adc_chan_right;
};
 
#define RK_DEFAULT_WIFI_AP_PASSWORD "flusflus" 
 
struct rkConfig {
    rkConfig()
        : rbcontroller_app_enable(false)
        , rbcontroller_enable_webocket(true)
        , rbcontroller_enable_udp(true)
        , owner("Nenastaven")
        , name("Nenastaveno")
        , wifi_name("")
        , wifi_password("")
        , wifi_default_ap(false)
        , wifi_ap_password(RK_DEFAULT_WIFI_AP_PASSWORD)
        , wifi_ap_channel(1)
        , motor_id_left(1)
        , motor_id_right(4)
        , motor_max_power_pct(80)
        , motor_polarity_switch_left(false)
        , motor_polarity_switch_right(true)
        , motor_enable_failsafe(false)
        , motor_wheel_diameter(67)
        , motor_max_ticks_per_second(2000)
        , motor_max_acceleration(10000)
        , stupid_servo_min(-1.65f)
        , stupid_servo_max(1.65f)
        , smart_leds_count(8) {
    }
 
    bool rbcontroller_app_enable; 
    bool rbcontroller_enable_webocket;
    bool rbcontroller_enable_udp;
 
    const char* owner; 
    const char* name; 
 
    const char* wifi_name; 
    const char* wifi_password; 
 
    bool wifi_default_ap; 
    const char* wifi_ap_password; 
    uint8_t wifi_ap_channel; 
 
    uint8_t motor_id_left; 
    uint8_t motor_id_right; 
    uint8_t motor_max_power_pct; 
    bool motor_polarity_switch_left; 
    bool motor_polarity_switch_right; 
    bool motor_enable_failsafe; 
    uint16_t motor_wheel_diameter; 
 
    uint32_t motor_max_ticks_per_second;
 
    uint32_t motor_max_acceleration;
 
    float stupid_servo_min; 
    float stupid_servo_max; 
 
    uint16_t smart_leds_count; 
 
    rkPinsConfig pins; 
};
 
void rkSetup(const rkConfig& cfg = rkConfig());
 
void rkMotorsSetPower(int8_t left, int8_t right);
 
void rkMotorsSetPowerLeft(int8_t power);
 
void rkMotorsSetPowerRight(int8_t power);
 
void rkMotorsSetPowerById(uint8_t id, int8_t power);
 
void rkMotorsSetSpeed(int8_t left, int8_t right);
 
void rkMotorsSetSpeedLeft(int8_t speed);
 
void rkMotorsSetSpeedRight(int8_t speed);
 
void rkMotorsSetSpeedById(uint8_t id, int8_t speed);
 
void rkMotorsDrive(float mmLeft, float mmRight, uint8_t speed);
 
void rkMotorsDriveLeft(float mm, uint8_t speed);
 
void rkMotorsDriveRight(float mm, uint8_t speed);
 
void rkMotorsDriveById(uint8_t id, float mm, uint8_t speed);
 
void rkMotorsDriveAsync(float mmLeft, float mmRight, uint8_t speed, std::function<void()> callback = nullptr);
 
void rkMotorsDriveLeftAsync(float mm, uint8_t speed, std::function<void()> callback = nullptr);
 
void rkMotorsDriveRightAsync(float mm, uint8_t speed, std::function<void()> callback = nullptr);
 
void rkMotorsDriveByIdAsync(uint8_t id, float mm, uint8_t speed, std::function<void()> callback = nullptr);
 
float rkMotorsGetPositionLeft(bool fetch = false);
 
float rkMotorsGetPositionRight(bool fetch = false);
 
float rkMotorsGetPositionById(uint8_t id, bool fetch = false);
 
void rkMotorsSetPositionLeft(float positionMm = 0.f);
 
void rkMotorsSetPositionRight(float positionMm = 0.f);
 
void rkMotorsSetPositionById(uint8_t id, float positionMm = 0.f);
 
void rkMotorsJoystick(int32_t x, int32_t y);
 
uint32_t rkBatteryPercent();
 
uint32_t rkBatteryVoltageMv();
 
int16_t rkTemperature();
 
void rkControllerSendLog(const char* format, ...);
void rkControllerSendLog(const std::string& text);
 
void rkControllerSend(const char* cmd, rbjson::Object* data = nullptr);
void rkControllerSendMustArrive(const char* cmd, rbjson::Object* data = nullptr);
 
void rkLedRed(bool on = true);
void rkLedYellow(bool on = true);
void rkLedGreen(bool on = true);
void rkLedBlue(bool on = true);
 
void rkLedAll(bool on = true);
 
void rkLedById(uint8_t id, bool on = true);
 
enum rkButtonId {
    BTN_DOWN = rb::ButtonId::Down, 
    BTN_UP = rb::ButtonId::Up, 
    BTN_LEFT = rb::ButtonId::Left, 
    BTN_RIGHT = rb::ButtonId::Right, 
    BTN_ON = rb::ButtonId::On, 
    BTN_OFF = rb::ButtonId::Off, 
};
 
#define EXTRA_BUTTON1 27 
#define EXTRA_BUTTON2 14 
 
bool rkButtonIsPressed(rkButtonId id, bool waitForRelease = false);
 
void rkButtonOnChangeAsync(std::function<bool(rkButtonId, bool)> callback = nullptr);
 
inline bool rkButtonDown(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_DOWN, waitForRelease);
}
 
inline bool rkButtonUp(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_UP, waitForRelease);
}
 
inline bool rkButtonLeft(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_LEFT, waitForRelease);
}
 
inline bool rkButtonRight(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_RIGHT, waitForRelease);
}
 
inline bool rkButtonOn(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_ON, waitForRelease);
}
 
inline bool rkButtonOff(bool waitForRelease = false) {
    return rkButtonIsPressed(BTN_OFF, waitForRelease);
}
 
void rkButtonWaitForRelease(rkButtonId id);
 
void rkLineCalibrate(float motor_time_coef = 1.0);
 
void rkLineClearCalibration();
 
uint16_t rkLineGetSensor(uint8_t sensorId);
 
float rkLineGetPosition(bool white_line = false, uint8_t line_threshold_pct = 25);
 
uint16_t rkIrLeft();
 
uint16_t rkIrRight();
 
uint32_t rkUltraMeasure(uint8_t id);
 
void rkUltraMeasureAsync(uint8_t id, std::function<bool(uint32_t)> callback);
 
void rkBuzzerSet(bool on);
 
void rkSmartLedsRGB(uint16_t idx, uint8_t r, uint8_t g, uint8_t b);
 
void rkSmartLedsHSV(uint16_t idx, uint8_t h, uint8_t s, uint8_t v);
 
void rkSmartLedsHEX(uint16_t idx, uint32_t hexCode);
SmartLed& rkSmartLedsGetController();
 
void rkServosSetPosition(uint8_t id, float angleDegrees);
 
float rkServosGetPosition(uint8_t id);
 
void rkServosDisable(uint8_t id);
 
lx16a::SmartServoBus& rkSmartServoBus(uint8_t servo_count);
 
#endif // LIBRB_H