exodus/1NiM-WatingRoom-WatchController
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

proj: Migrate to core as git-submodule

Browse Source
This commit is contained in:
Jakob Gegeniger
2025-02-15 21:45:13 +01:00
parent c7e1b4805b
commit a5805aceb2
99 changed files with 68 additions and 8635 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.configs/TelnetTeraTerm.INI
BIN
View File
Binary file not shown.
.configs/UartTeraTerm.INI
BIN
View File
Binary file not shown.
.vscode/c_cpp_properties.json
Vendored
+4 -2
View File
@@ -7,13 +7,15 @@
"includePath": [
"${config:idf.espIdfPath}/components/**",
"${config:idf.espIdfPathWin}/components/**",
"${workspaceFolder}/**"
"${workspaceFolder}/**",
"${workspaceFolder}/core/**"
],
"browse": {
"path": [
"${config:idf.espIdfPath}/components",
"${config:idf.espIdfPathWin}/components",
"${workspaceFolder}"
"${workspaceFolder}",
"${workspaceFolder}/core"
],
"limitSymbolsToIncludedHeaders": true
}
.vscode/tasks.json
Vendored
+1 -1
View File
@@ -263,7 +263,7 @@
"telnet://${config:project.deviceIp}:23",
"/W=\"Device-Platform\"",
"/T=1",
"/F=\"${workspaceFolder}/.configs/TelnetTeraTerm.INI\""
"/F=\"${workspaceFolder}/core/.configs/TelnetTeraTerm.INI\""
],
"problemMatcher": []
}
CMakeLists.txt
+5
View File
@@ -1,4 +1,9 @@
cmake_minimum_required(VERSION 3.16)
set(EXTRA_COMPONENT_DIRS
"core/components"
"core/managed_components"
)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(X_WatchController_FW)
components/artNet/Artnet.h
-98
View File
@@ -1,98 +0,0 @@
#pragma once
#ifndef ARDUINO_ARTNET_H
#define ARDUINO_ARTNET_H
// Spec (Art-Net 4) : http://artisticlicence.com/WebSiteMaster/User%20Guides/art-net.pdf
// Packet Summary : https://art-net.org.uk/structure/packet-summary-2/
// Packet Definition : https://art-net.org.uk/structure/streaming-packets/artdmx-packet-definition/
namespace arx { // others
template <class AlwaysVoid, template<class...> class Check, class... T>
struct is_detected_impl : std::false_type {};
template <template <class...> class Check, class... T>
struct is_detected_impl <std::void_t<Check<T...>>, Check, T...> : std::true_type {};
template <template <class...> class Check, class... T>
using is_detected = is_detected_impl<void, Check, T...>;
template <typename T>
struct is_callable {
template <typename U, decltype(&U::operator()) = &U::operator()>
struct checker {};
template <typename U> static std::true_type test(checker<U> *);
template <typename> static std::false_type test(...);
static constexpr bool value = decltype(test<T>(nullptr))::value;
};
template <typename R, typename ... Arguments>
struct is_callable<R(*)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(*&)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(&)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<std::function<R(Arguments ...)>> {
static constexpr bool value = true;
};
namespace detail {
template <typename ret, typename ... arguments>
struct function_traits {
static constexpr size_t arity = sizeof...(arguments);
using result_type = ret;
using arguments_types_tuple = std::tuple<arguments ...>;
// template <size_t index>
// using argument_type = type_at<index, arguments ...>;
using function_type = std::function<ret(arguments ...)>;
template <typename function_t>
static constexpr function_type cast(function_t f) {
return static_cast<function_type>(f);
}
};
}
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())> {};
template <typename class_type, typename ret, typename ... arguments>
struct function_traits<ret(class_type::*)(arguments ...) const>
: detail::function_traits<ret, arguments ...> {};
template <typename class_type, typename ret, typename ... arguments>
struct function_traits<ret(class_type::*)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(*)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(*&)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<std::function<ret(arguments ...)>>
: detail::function_traits<ret, arguments ...> {};
} // namespace arx
#include "ArtnetCommon.h"
using Artnet = arx::artnet::Manager;
using ArtnetSender = arx::artnet::Sender;
using ArtnetReceiver = arx::artnet::Receiver;
#endif // ARDUINO_ARTNET_H
components/artNet/ArtnetCommon.h
-540
View File
@@ -1,540 +0,0 @@
#pragma once
#ifndef ARTNET_COMMON_H
#define ARTNET_COMMON_H
#include "udpSockets.hpp"
#include <functional>
#include <map>
#include <string.h>
#include <string>
#include <algorithm>
#include <Task.hpp>
namespace arx {
namespace artnet {
// Packet Summary : https://art-net.org.uk/structure/packet-summary-2/
// Packet Definition : https://art-net.org.uk/structure/streaming-packets/artdmx-packet-definition/
struct Target { // DMX Universe Port-Address
uint32_t universe : 4;
uint32_t subnet : 4;
uint32_t net : 7;
};
enum class OpCode : uint16_t {
// Device Discovery
Poll = 0x2000,
PollReply = 0x2100,
// Device Configuration
Address = 0x6000,
Input = 0x7000,
IpProg = 0xF800,
IpProgReply = 0xF900,
Command = 0x2400,
// Streaming Control
Dmx = 0x5000,
Nzs = 0x5100,
Sync = 0x5200,
// RDM
TodRequest = 0x8000,
TodData = 0x8100,
TodControl = 0x8200,
Rdm = 0x8300,
RdmSub = 0x8400,
// Time-Keeping
TimeCode = 0x9700,
TimeSync = 0x9800,
// Triggering
Trigger = 0x9900,
// Diagnostics
DiagData = 0x2300,
// File Transfer
FirmwareMaster = 0xF200,
FirmwareReply = 0xF300,
Directory = 0x9A00,
DirectoryReply = 0x9B00,
FileTnMaster = 0xF400,
FileFnMaster = 0xF500,
FileFnReply = 0xF600,
// N/A
NA = 0x0000,
};
constexpr uint16_t OPC(OpCode op) {
return static_cast<uint16_t>(op);
}
enum class Index : uint16_t {
ID = 0,
OP_CODE_L = 8,
OP_CODE_H = 9,
PROTOCOL_VER_H = 10,
PROTOCOL_VER_L = 11,
SEQUENCE = 12,
PHYSICAL = 13,
SUBUNI = 14,
NET = 15,
LENGTH_H = 16,
LENGTH_L = 17,
DATA = 18
};
constexpr uint16_t IDX(Index i) {
return static_cast<uint16_t>(i);
}
constexpr uint16_t DEFAULT_PORT{0x1936}; // 6454
constexpr uint16_t HEADER_SIZE{18};
constexpr uint16_t PACKET_SIZE{530};
constexpr uint16_t PROTOCOL_VER{0x0014};
constexpr uint8_t ID_LENGTH{8};
constexpr char ID[ID_LENGTH]{"Art-Net"};
constexpr int DEFAULT_FPS_IN_TICKS {40 / portTICK_PERIOD_MS};
static constexpr uint8_t NUM_PIXELS_PER_UNIV{170};
using CallbackAllType =
std::function<void(const uint32_t universe, const uint8_t *data, const uint16_t size)>;
using CallbackType = std::function<void(const uint8_t *data, const uint16_t size)>;
template <uint16_t SIZE> using Array = std::array<uint8_t, SIZE>;
using IntervalMap = std::map<uint32_t, uint32_t>;
using CallbackMap = std::map<uint32_t, CallbackType>;
using namespace std;
union ArtPollReply {
struct {
uint8_t id[8];
uint8_t op_code_l;
uint8_t op_code_h;
uint8_t ip[4];
uint8_t port_l;
uint8_t port_h;
uint8_t ver_h;
uint8_t ver_l;
uint8_t net_sw;
uint8_t sub_sw;
uint8_t oem_h;
uint8_t oem_l;
uint8_t ubea_ver;
uint8_t status_1;
uint8_t esta_man_l;
uint8_t esta_man_h;
uint8_t short_name[18];
uint8_t long_name[64];
uint8_t node_report[64];
uint8_t num_ports_h;
uint8_t num_ports_l;
uint8_t port_types[4];
uint8_t good_input[4];
uint8_t good_output[4];
uint8_t sw_in[4];
uint8_t sw_out[4];
uint8_t sw_video;
uint8_t sw_macro;
uint8_t sw_remote;
uint8_t spare[3];
uint8_t style;
uint8_t mac[6];
uint8_t bindIp[4];
uint8_t bindIndex;
uint8_t status_2;
uint8_t filler[26];
};
std::array<uint8_t, 239> b;
};
class Sender {
Array<PACKET_SIZE> packet;
uint8_t target_net {0};
uint8_t target_subnet {0};
uint8_t target_universe {0};
uint8_t seq {0};
uint8_t phy {0};
IntervalMap intervals;
UdpSocket& stream;
public:
Sender(UdpSocket & socket) : stream(socket) {
for (size_t i = 0; i < ID_LENGTH; i++) packet[IDX(Index::ID) + i] =
static_cast<uint8_t>(ID[i]); packet[IDX(Index::OP_CODE_H)] = (OPC(OpCode::Dmx) >> 8) &
0x00FF; packet[IDX(Index::OP_CODE_L)] = (OPC(OpCode::Dmx) >> 0) & 0x00FF;
packet[IDX(Index::PROTOCOL_VER_H)] = (PROTOCOL_VER >> 8) & 0x00FF;
packet[IDX(Index::PROTOCOL_VER_L)] = (PROTOCOL_VER >> 0) & 0x00FF;
}
virtual ~Sender() {}
// streaming packet
void streamingData(const uint8_t* const data, const uint16_t size) {
memcpy((&packet[IDX(Index::DATA)]), data, size);
}
void streamingData(const uint16_t ch, const uint8_t data) {
packet[IDX(Index::DATA) + ch] = data;
}
void streaming(const std::string& ip, const uint32_t universe) {
uint32_t now = fos::Timing::getTickCount();
if (intervals.find(universe) == intervals.end()) {
intervals.insert(make_pair(universe, now));
}
if (now >= intervals[universe] + DEFAULT_FPS_IN_TICKS) {
setUniverse(universe);
sendPacket(ip);
intervals[universe] = now;
}
}
void streaming(const std::string& ip, const uint8_t net, const uint8_t subnet, const uint8_t
universe) {
uint32_t u = ((uint32_t)net << 8) | ((uint32_t)subnet << 4) | (uint32_t)universe;
streaming(ip, u);
}
// one-line sender
void send(const std::string& ip, const uint32_t universe, const uint8_t* const data, const
uint16_t size) {
setUniverse(universe);
streamingData(data, size);
sendPacket(ip);
}
void send(
const std::string& ip,
const uint8_t net,
const uint8_t subnet,
const uint8_t universe,
const uint8_t* const data,
const uint16_t size) {
setUniverse(net, subnet, universe);
streamingData(data, size);
sendPacket(ip);
}
void physical(const uint8_t i) {
phy = std::clamp<uint8_t>(i, 0, 3);
}
uint8_t sequence() const {
return seq;
}
protected:
void sendPacket(const std::string& ip) {
packet[IDX(Index::SEQUENCE)] = seq++;
packet[IDX(Index::PHYSICAL)] = phy;
packet[IDX(Index::NET)] = target_net;
packet[IDX(Index::SUBUNI)] = (target_subnet << 4) | target_universe;
packet[IDX(Index::LENGTH_H)] = (512 >> 8) & 0xFF;
packet[IDX(Index::LENGTH_L)] = (512 >> 0) & 0xFF;
if (ip == "")
{
stream.write(packet.data(), packet.size());
} else {
auto ipAddr = IpAdr(ip, DEFAULT_PORT);
stream.write(packet.data(), packet.size(), &ipAddr);
}
}
void setUniverse(const uint32_t universe) {
target_net = (universe >> 8) & 0x7F;
target_subnet = (universe >> 4) & 0x0F;
target_universe = universe & 0x0F;
}
void setUniverse(const uint8_t net, const uint8_t subnet, const uint8_t universe) {
target_net = net & 0x7F;
target_subnet = subnet & 0x0F;
target_universe = universe & 0x0F;
}
};
class Receiver {
Array<PACKET_SIZE> packet;
uint8_t net_switch; // net of universe
uint8_t sub_switch; // subnet of universe
std::string short_name{"Custom ArtNet"};
std::string long_name{"Arduino ArtNet Adaption by gustice"};
std::string node_report{""};
CallbackMap callbacks;
CallbackAllType callback_all;
UdpSocket &stream;
bool b_verbose{false};
public:
Receiver(UdpSocket &socket, const uint8_t subscribe_net = 0, const uint8_t subscribe_subnet = 0)
: stream(socket) {
if (subscribe_net > 128) {
ESP_LOGE("ARX", "Net must be < 128");
} else {
net_switch = subscribe_net;
}
if (subscribe_subnet > 16) {
ESP_LOGE("ARX", "Subnet must be < 16");
} else {
sub_switch = subscribe_subnet;
}
}
virtual ~Receiver() {}
OpCode parse() {
auto data = stream.read();
if (data.size() <= 0)
return OpCode::NA;
uint8_t *d = &data[0];
OpCode op_code = OpCode::NA;
if (checkID(d)) {
switch (opcode(d)) {
case OPC(OpCode::Dmx): {
memcpy(packet.data(), d, data.size());
if (callback_all)
callback_all(universe15bit(), dataPtr(), data.size() - HEADER_SIZE);
for (auto &c : callbacks) {
if (universe15bit() == c.first)
c.second(dataPtr(), data.size() - HEADER_SIZE);
}
op_code = OpCode::Dmx;
break;
}
case OPC(OpCode::Poll): {
pollReply();
op_code = OpCode::Poll;
break;
}
default: {
if (b_verbose) {
ESP_LOGW("ARX", "Unsupported OpCode: %d", opcode(d));
}
op_code = OpCode::NA;
break;
}
}
}
return op_code;
}
inline std::string id() const {
std::string str;
for (uint8_t i = 0; i < ID_LENGTH; ++i)
str += packet[IDX(Index::ID) + i];
return str;
}
inline uint16_t opcode() const {
return (packet[IDX(Index::OP_CODE_H)] << 8) | packet[IDX(Index::OP_CODE_L)];
}
inline uint16_t opcode(const uint8_t *p) const {
return (p[IDX(Index::OP_CODE_H)] << 8) | p[IDX(Index::OP_CODE_L)];
}
inline uint16_t version() const {
return (packet[IDX(Index::PROTOCOL_VER_H)] << 8) | packet[IDX(Index::PROTOCOL_VER_L)];
}
inline uint8_t sequence() const {
return packet[IDX(Index::SEQUENCE)];
}
inline uint8_t physical() const {
return packet[IDX(Index::PHYSICAL)];
}
uint8_t net() const {
return packet[IDX(Index::NET)] & 0x7F;
}
uint8_t subnet() const {
return (packet[IDX(Index::SUBUNI)] >> 4) & 0x0F;
}
inline uint8_t universe() const {
return packet[IDX(Index::SUBUNI)] & 0x0F;
}
inline uint16_t universe15bit() const {
return (packet[IDX(Index::NET)] << 8) | packet[IDX(Index::SUBUNI)];
}
inline uint16_t length() const {
return (packet[IDX(Index::LENGTH_H)] << 8) | packet[IDX(Index::LENGTH_L)];
}
inline uint16_t size() const {
return length();
}
inline uint8_t *dataPtr() {
return &(packet[HEADER_SIZE]);
}
inline uint8_t dataPtr(const uint16_t i) const {
return packet[HEADER_SIZE + i];
}
template <typename Fn>
inline auto subscribe(const uint8_t universe, Fn &&func)
-> std::enable_if_t<arx::is_callable<Fn>::value> {
if (callbacks.size() >= 4) {
if (b_verbose) {
ESP_LOGE("ARX", "too many callbacks");
}
} else {
if (universe > 0xF) {
if (b_verbose) {
ESP_LOGE("ARX", "universe out of bounds");
}
return;
} else {
uint32_t u =
((uint32_t)net_switch << 8) | ((uint32_t)sub_switch << 4) | (uint32_t)universe;
callbacks.insert(make_pair(u, arx::function_traits<Fn>::cast(func)));
}
}
}
template <typename Fn> inline auto subscribe(const uint8_t universe, Fn *func) {
if (callbacks.size() >= 4) {
if (b_verbose) {
ESP_LOGE("ARX", "too many callbacks");
}
} else {
if (universe > 0xF) {
if (b_verbose) {
ESP_LOGE("ARX", "universe out of bounds");
}
} else {
uint32_t u =
((uint32_t)net_switch << 8) | ((uint32_t)sub_switch << 4) | (uint32_t)universe;
callbacks.insert(make_pair(u, arx::function_traits<Fn>::cast(func)));
}
}
}
template <typename Fn>
inline auto subscribe15bit(const uint16_t universe, Fn &&func)
-> std::enable_if_t<arx::is_callable<Fn>::value> {
if (callbacks.size() >= 4) {
if (b_verbose) {
ESP_LOGE("ARX", "too many callbacks");
}
} else {
callbacks.insert(make_pair(universe, arx::function_traits<Fn>::cast(func)));
}
}
template <typename Fn> inline auto subscribe15bit(const uint16_t universe, Fn *func) {
if (callbacks.size() >= 4) {
if (b_verbose) {
ESP_LOGE("ARX", "too many callbacks");
}
} else {
callbacks.insert(make_pair(universe, arx::function_traits<Fn>::cast(func)));
}
}
template <typename F>
inline auto subscribe(F &&func) -> std::enable_if_t<arx::is_callable<F>::value> {
callback_all = arx::function_traits<F>::cast(func);
}
template <typename F> inline auto subscribe(F *func) {
callback_all = arx::function_traits<F>::cast(func);
}
inline void unsubscribe(const uint8_t universe) {
auto it = callbacks.find(universe);
if (it != callbacks.end())
callbacks.erase(it);
}
inline void unsubscribe() {
callback_all = nullptr;
}
inline void clear_subscribers() {
unsubscribe();
callbacks.clear();
}
void nodereport(const std::string nr) {
node_report = nr;
}
void verbose(const bool b) {
b_verbose = b;
}
protected:
private:
bool checkID() const {
const char *idptr = reinterpret_cast<const char *>(packet.data());
return !strcmp(ID, idptr);
}
bool checkID(const uint8_t *p) const {
const char *idptr = reinterpret_cast<const char *>(p);
return !strcmp(ID, idptr);
}
void pollReply() {
ArtPollReply r;
for (size_t i = 0; i < ID_LENGTH; i++)
r.id[i] = static_cast<uint8_t>(ID[i]);
r.op_code_l = ((uint16_t)OpCode::PollReply >> 0) & 0x00FF;
r.op_code_h = ((uint16_t)OpCode::PollReply >> 8) & 0x00FF;
IpInfo ipInfo = stream.getIpInfo();
Ip my_ip = ipInfo.address;
for (size_t i = 0; i < 4; ++i)
r.ip[i] = my_ip[i];
r.port_l = (DEFAULT_PORT >> 0) & 0xFF;
r.port_h = (DEFAULT_PORT >> 8) & 0xFF;
r.ver_h = (PROTOCOL_VER >> 8) & 0x00FF;
r.ver_l = (PROTOCOL_VER >> 0) & 0x00FF;
r.oem_h = 0; // https://github.com/tobiasebsen/ArtNode/blob/master/src/Art-NetOemCodes.h
r.oem_l = 0xFF; // OemUnknown
r.ubea_ver = 0; // UBEA not programmed
r.status_1 = 0x00; // Unknown / Normal
r.esta_man_l = 0; // No EATA manufacture code
r.esta_man_h = 0; // No ESTA manufacture code
memset(r.short_name, 0, 18);
memset(r.long_name, 0, 64);
memset(r.node_report, 0, 64);
memcpy(r.short_name, short_name.c_str(), short_name.length());
memcpy(r.long_name, long_name.c_str(), long_name.length());
memcpy(r.node_report, node_report.c_str(), node_report.length());
r.num_ports_h = 0; // Reserved
r.num_ports_l = callbacks.size(); // This library implements only 4 port
memset(r.port_types, 0, 4);
memset(r.sw_in, 0, 4);
memset(r.sw_out, 0, 4);
memset(r.good_input, 0, 4);
memset(r.good_output, 0, 4);
r.net_sw = net_switch & 0x7F;
r.sub_sw = sub_switch & 0x0F;
size_t i = 0;
for (const auto &pair : callbacks) {
// r.port_types[i] = 0xC0; // I/O available by DMX512 // @todo Bug@ liveShowSoftware
r.port_types[i] = 0x80; // Output available by DMX512
r.good_input[i] = 0x80; // Data received without error
r.good_output[i] = 0x80; // Data transmitted without error
r.sw_in[i] = i;// dummy: input port is flexible
r.sw_out[i] = pair.first & 0x0F;
if (++i >= 4)
break;
}
r.sw_video = 0; // Video display shows local data
r.sw_macro = 0; // No support for macro key inputs
r.sw_remote = 0; // No support for remote trigger inputs
memset(r.spare, 0x00, 3);
r.style = 0x00; // A DMX to / from Art-Net device
std::copy(ipInfo.macAddress.asArray().begin(), ipInfo.macAddress.asArray().end(), std::end(r.mac));
for (size_t i = 0; i < 4; ++i)
r.bindIp[i] = my_ip[i];
r.bindIndex = 0;
r.status_2 = 0x0C; // features: 15bitAddr | DHCP
memset(r.filler, 0x00, 26);
Ip bc = ipInfo.getBradcastAddress();
IpAdr broadCast(bc.asWord(), DEFAULT_PORT);
stream.write(r.b.data(), r.b.size(), &broadCast); // on sending station
}
};
class Manager : public Sender, public Receiver {
public:
Manager(UdpSocket &socket) : Sender(socket), Receiver(socket) {
}
void parse() {
this->Receiver::parse();
}
};
} // namespace artnet
} // namespace arx
#endif // ARTNET_COMMON_H
components/artNet/CMakeLists.txt
-5
View File
@@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES sockets
)
components/artNet/LICENSE
-21
View File
@@ -1,21 +0,0 @@
MIT License
Copyright (c) 2019 Hideaki Tai
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
components/artNet/examples/Ethernet/receive_fastled/receive_fastled.ino
-54
View File
@@ -1,54 +0,0 @@
#include <FastLED.h> // include FastLED *before* Artnet
// Please include ArtnetEther.h to use Artnet on the platform
// which can use both WiFi and Ethernet
#include <ArtnetEther.h>
// this is also valid for other platforms which can use only Ethernet
// #include <Artnet.h>
// Ethernet stuff
const IPAddress ip(192, 168, 0, 201);
uint8_t mac[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB};
ArtnetReceiver artnet;
uint8_t universe = 1; // 0 - 15
// FastLED
#define NUM_LEDS 1
CRGB leds[NUM_LEDS];
const uint8_t PIN_LED_DATA = 3;
void setup() {
Serial.begin(115200);
delay(2000);
FastLED.addLeds<NEOPIXEL, PIN_LED_DATA>(leds, NUM_LEDS);
Ethernet.begin(mac, ip);
artnet.begin();
// artnet.subscribe_net(0); // optionally you can change
// artnet.subscribe_subnet(0); // optionally you can change
// if Artnet packet comes to this universe, forward them to fastled directly
artnet.forward(universe, leds, NUM_LEDS);
// this can be achieved manually as follows
// if Artnet packet comes to this universe, this function is called
// artnet.subscribe(universe, [&](uint8_t* data, uint16_t size)
// {
// // set led
// // artnet data size per packet is 512 max
// // so there is max 170 pixel per packet (per universe)
// for (size_t pixel = 0; pixel < NUM_LEDS; ++pixel) {
// size_t idx = pixel * 3;
// leds[pixel].r = data[idx + 0];
// leds[pixel].g = data[idx + 1];
// leds[pixel].b = data[idx + 2];
// }
// });
}
void loop() {
artnet.parse(); // check if artnet packet has come and execute callback
FastLED.show();
}
components/artNet/examples/Ethernet/receiver/receiver.ino
-47
View File
@@ -1,47 +0,0 @@
// Please include ArtnetEther.h to use Artnet on the platform
// which can use both WiFi and Ethernet
#include <ArtnetEther.h>
// this is also valid for other platforms which can use only Ethernet
// #include <Artnet.h>
// Ethernet stuff
const IPAddress ip(192, 168, 0, 201);
uint8_t mac[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB};
ArtnetReceiver artnet;
uint32_t universe1 = 1; // 0 - 15
uint32_t universe2 = 2; // 0 - 15
void callback(const uint8_t* data, const uint16_t size) {
// you can also use pre-defined callbacks
}
void setup() {
Serial.begin(115200);
Ethernet.begin(mac, ip);
artnet.begin();
// artnet.subscribe_net(0); // optionally you can change
// artnet.subscribe_subnet(0); // optionally you can change
// if Artnet packet comes to this universe, this function is called
artnet.subscribe(universe1, [&](const uint8_t* data, const uint16_t size) {
Serial.print("artnet data (universe : ");
Serial.print(universe1);
Serial.print(", size = ");
Serial.print(size);
Serial.print(") :");
for (size_t i = 0; i < size; ++i) {
Serial.print(data[i]);
Serial.print(",");
}
Serial.println();
});
// you can also use pre-defined callbacks
artnet.subscribe(universe2, callback);
}
void loop() {
artnet.parse(); // check if artnet packet has come and execute callback
}
components/artNet/examples/Ethernet/send_receive/send_receive.ino
-65
View File
@@ -1,65 +0,0 @@
#ifdef __AVR__
#warning THIS EXAMPLE MAY USE TOO MUCH MEMORY FOR AVR. WE RECOMMEND TO USE SENDER OR RECEIVER ONLY.
#endif
// Please include ArtnetEther.h to use Artnet on the platform
// which can use both WiFi and Ethernet
#include <ArtnetEther.h>
// this is also valid for other platforms which can use only Ethernet
// #include <Artnet.h>
// Ethernet stuff
const IPAddress ip(192, 168, 0, 201);
uint8_t mac[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB};
Artnet artnet;
const String target_ip = "192.168.0.200";
uint8_t universe = 1; // 0 - 15
const uint16_t size = 512;
uint8_t data[size];
uint8_t value = 0;
void setup() {
Serial.begin(115200);
delay(2000);
Ethernet.begin(mac, ip);
artnet.begin();
// artnet.begin(net, subnet); // optionally you can change
Serial.println("set subscriber");
// if Artnet packet comes to this universe, this function is called
artnet.subscribe(universe, [](const uint8_t* data, const uint16_t size) {
Serial.print("artnet data (universe : ");
Serial.print(universe);
Serial.print(", size = ");
Serial.print(size);
Serial.print(") :");
for (size_t i = 0; i < size; ++i) {
Serial.print(data[i]);
Serial.print(",");
}
Serial.println();
});
// if Artnet packet comes, this function is called to every universe
artnet.subscribe([&](const uint32_t univ, const uint8_t* data, const uint16_t size) {
Serial.print("ArtNet data has come to universe: ");
Serial.println(univ);
});
Serial.println("start");
}
void loop() {
artnet.parse(); // check if artnet packet has come and execute callback
value = (millis() / 4) % 256;
memset(data, value, size);
artnet.streaming_data(data, size);
artnet.streaming(target_ip, universe); // automatically send set data in 40fps
// artnet.streaming(target_ip, net, subnet, univ); // or you can set net, subnet, and universe
}
components/artNet/examples/Ethernet/sender/sender.ino
-38
View File
@@ -1,38 +0,0 @@
// Please include ArtnetEther.h to use Artnet on the platform
// which can use both WiFi and Ethernet
#include <ArtnetEther.h>
// this is also valid for other platforms which can use only Ethernet
// #include <Artnet.h>
// Ethernet stuff
const IPAddress ip(192, 168, 0, 201);
uint8_t mac[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB};
ArtnetSender artnet;
const String target_ip = "192.168.0.200";
uint32_t universe = 1;
const uint16_t size = 512;
uint8_t data[size];
uint8_t value = 0;
void setup() {
Serial.begin(115200);
delay(2000);
Ethernet.begin(mac, ip);
artnet.begin();
// artnet.begin(net, subnet); // optionally you can change
Serial.println("start");
Serial.println(UDP_TX_PACKET_MAX_SIZE);
}
void loop() {
value = (millis() / 4) % 256;
memset(data, value, size);
artnet.streaming_data(data, size);
artnet.streaming(target_ip, universe); // automatically send set data in 40fps
// artnet.streaming(target_ip, net, subnet, univ); // or you can set net, subnet, and universe
}
components/artNet/readme.md
-4
View File
@@ -1,4 +0,0 @@
# ArtNet
Implementation is taken form `hideakitai` @ [github](https://github.com/hideakitai/ArtNet)
components/board_io/CMakeLists.txt
-10
View File
@@ -1,10 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
REQUIRES freeRtosApi
project_bases
esp_common
esp_driver_gpio
esp_driver_ledc
esp_driver_gptimer
)
components/board_io/include/gpioPort.hpp
-95
View File
@@ -1,95 +0,0 @@
/**
* @file gpioPort.hpp
* @author Gustice
* @brief GPIO-Port classes
* @details C++ Wrapper for GPIO port
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "driver/gpio.h"
#include "portBase.hpp"
/**
* @brief Digital-Port BaseClass
*/
class GpioPort : public PortBase {
public:
enum PullResistor {
Floating = 0,
PullUp,
PullDown,
};
enum Logic {
Normal = 0, // Normal logic
Inverted, // Inverted logic -> Set low on active state
};
enum Interrupt {
PositiveEdge = gpio_int_type_t::GPIO_INTR_POSEDGE,
NegativeEdge = gpio_int_type_t::GPIO_INTR_NEGEDGE,
AnyEdge = gpio_int_type_t::GPIO_INTR_ANYEDGE
};
GpioPort(gpio_num_t port);
~GpioPort();
uint64_t GetReserved(void) { return _reservedPorts; }
protected:
const gpio_num_t _port;
private:
static uint64_t _reservedPorts;
};
/**
* @brief Input-Port
* @details Provides abstract reading functionality
*/
class InputPort : public GpioPort {
public:
InputPort(gpio_num_t port, GpioPort::PullResistor resistor = PullResistor::Floating);
void setLogic(GpioPort::Logic logic) {
_logic = logic;
}
~InputPort() = default;
bool read(void);
private:
GpioPort::Logic _logic = GpioPort::Logic::Normal;
};
/**
* @brief Output-Port
* @details Provides abstract setting functionality
*/
class OutputPort : public GpioPort {
public:
OutputPort(gpio_num_t port, GpioPort::Logic mode = Logic::Normal);
~OutputPort(){};
void write(int active);
private:
const GpioPort::Logic _mode = Normal;
};
/**
* @brief Interrupt-Port
*/
class TriggeredInput : public InputPort {
public:
TriggeredInput(gpio_num_t port,
GpioPort::PullResistor resistor = GpioPort::PullResistor::Floating,
TriggeredInput::Interrupt edge = TriggeredInput::Interrupt::AnyEdge);
~TriggeredInput(){};
void RegisterIsr(gpio_isr_t pIsrHandle);
private:
static bool _isrServiceInitiated;
};
components/board_io/src/gpioPort.cpp
-98
View File
@@ -1,98 +0,0 @@
/**
* @file gpioPort.cpp
* @author Gustice
* @brief C++ Wrapper for GPIO port
*
* @copyright Copyright (c) 2024
*/
#include "gpioPort.hpp"
#include "esp_log.h"
///
/// Gpio - Implementation
///
uint64_t GpioPort::_reservedPorts = 0;
GpioPort::GpioPort(gpio_num_t port) : _port(port) {
uint64_t p = 1ULL << port;
if ((_reservedPorts & p) != 0) {
ESP_LOGW("HAL", "GpioPort Port %d is already in use!", port);
}
_reservedPorts |= p;
}
GpioPort::~GpioPort() {
uint64_t p = 1ULL << _port;
_reservedPorts &= ~p;
}
///
/// InputPort - Implementation
///
InputPort::InputPort(gpio_num_t port, GpioPort::PullResistor resistor) : GpioPort(port) {
gpio_config_t config = {
.pin_bit_mask = 1ULL << port,
.mode = GPIO_MODE_INPUT,
.pull_up_en = resistor == PullUp ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE,
.pull_down_en = resistor == PullDown ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
ESP_ERROR_CHECK(gpio_config(&config));
}
bool InputPort::read(void) {
auto value = gpio_get_level(_port);
return ((value ^ _logic) & 0x01) == 1;
}
///
/// TriggeredInput - Implementation
///
bool TriggeredInput::_isrServiceInitiated = false;
TriggeredInput::TriggeredInput(gpio_num_t port, GpioPort::PullResistor resistor,
TriggeredInput::Interrupt edge)
: InputPort(port, resistor) {
assert(gpio_set_intr_type(_port, (gpio_int_type_t)edge) == ESP_OK);
if (!_isrServiceInitiated) {
_isrServiceInitiated = true;
esp_err_t err = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL2);
if (err == ESP_OK) {
ESP_LOGI("HAL", "ISR-service installed successfully for gpio-port");
} else {
ESP_LOGE("HAL", "ISR-service failed to install. Code '%s'", esp_err_to_name(err));
}
}
}
void TriggeredInput::RegisterIsr(gpio_isr_t pIsrHandle) {
ESP_LOGI("HAL", "Hooking ISR-Function to gpio-port %d", _port);
gpio_isr_handler_add(_port, pIsrHandle, nullptr);
}
///
/// OutputPort - Implementation
///
OutputPort::OutputPort(gpio_num_t port, GpioPort::Logic mode) : GpioPort(port), _mode(mode) {
gpio_config_t io_conf = {
.pin_bit_mask = 1ULL << port,
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
gpio_config(&io_conf);
}
void OutputPort::write(int active) {
if (_mode == GpioPort::Normal) {
gpio_set_level(_port, active & 1);
} else {
active ^= 1;
gpio_set_level(_port, active & 1);
}
}
components/freeRtosApi/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
)
components/freeRtosApi/examples/fullDemo.cpp
-119
View File
@@ -1,119 +0,0 @@
/**
* @file fullDemo.cpp
* @author Gustice
* @brief Coherent demonstration of FreeRTOS-Abstraction in small environment
* @copyright Copyright (c) 2024
*/
#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include <stdio.h>
constexpr int StackSize = 1024;
constexpr int LED = 2;
#define TerminalPrint(format, ...) ESP_LOGI("main", format, __VA_ARGS__)
#include "Mutex.hpp"
#include "Queue.hpp"
#include "Semaphore.hpp"
#include "Task.hpp"
#include <string>
using namespace fos;
using namespace std::literals::string_view_literals;
constexpr int WAIT = 1000;
/// @brief Arbitrary definition for message type (to be used as queue template parameter)
struct TxMsg {
TxMsg(uint32_t c, std::string m) : cnt(c), message(m){};
uint32_t cnt;
std::string message;
};
/// @brief Global semaphore for blink tasks
Semaphore blinkSem;
void setupLedPin();
void toggleLedPin();
/// @brief Parameterless task entry for generation of blink signals
/// @note uses global semaphore
void TaskBlinkProvider() {
TerminalPrint("starting blink provider task");
while (true) {
Task::delayMs(WAIT); // wait
blinkSem.give(); // then signal a blink event
}
}
/// @brief Parameterless task entry for execution of blink signals
/// @note uses global semaphore
void TaskBlink() {
TerminalPrint("starting blink execution task");
setupLedPin();
while (true) {
blinkSem.take(); // wait for blink event signal
toggleLedPin(); // execute blink event
Task::delayMs(100); // wait
toggleLedPin(); // execute blink event
TerminalPrint("Blink tick");
}
}
/// @brief Parametrized task entry for message provider (generates message object)
/// @param queue reference to appropriate queue
void MessageProvider(Queue<TxMsg> &queue) {
uint32_t cnt{};
while (true) {
auto e = std::make_unique<TxMsg>(cnt++, "tick");
queue.enqueue(std::move(e));
Task::delayMs(WAIT);
}
}
/// @brief Parametrized task entry for message consumer (sends message over UART)
/// @param queue reference to appropriate queue
void MessageConsumer(Queue<TxMsg> &queue) {
while (true) {
auto msg = queue.dequeue(); // Wait with infinit timeout, guaranteed to succeed
TerminalPrint("Message: %s %lu", msg->message.c_str(), msg->cnt);
}
}
void setupTasks() {
/// @note: All definitions as static instances to not be destructed after loosing scope
static Queue<TxMsg> txQueue(8);
static Task blinkerTask(TaskBlink, "BlinkExec", StackSize);
static Task blinkeProviderTask(TaskBlinkProvider, "BlinkFlags", StackSize);
static TaskT<Queue<TxMsg> &> tickerTask(MessageProvider, txQueue, "Tick", StackSize);
static TaskT<Queue<TxMsg> &> senderTask(MessageConsumer, txQueue, "Sender", StackSize);
}
extern "C" { // This switch allows the ROS C-implementation to find this main
void app_main(void);
}
void app_main() {
void setupTasks();
while (true) {
ESP_LOGI("main", "healt tick");
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
void setupLedPin() {
// no Buildin-led on XIAO C3
}
void toggleLedPin() {
// no Buildin-led on XIAO C3
}
components/freeRtosApi/include/Mutex.hpp
-87
View File
@@ -1,87 +0,0 @@
/**
* @file mutex.hpp
* @author Gustice
* @brief Mutex Wrapper
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
namespace fos {
/**
* @brief Mutex
* @details FreeRTOS implementation uses already priority inheritance
* and are recursively callable
*/
class Mutex {
private:
QueueHandle_t _handle;
public:
/// @brief Tick type (redefinition for convenience)
using Tick = TickType_t;
/// @brief Definition for endless waittime
static constexpr Tick MaxDelay = portMAX_DELAY;
/// @brief Constructor
Mutex() {
_handle = xSemaphoreCreateMutex();
assert(_handle != 0 && "Semaphore create must finish successfully");
}
~Mutex() {
vSemaphoreDelete(_handle);
};
/// @brief Relase mutex
void release() {
auto ret = xSemaphoreGive(_handle);
assert(ret == pdPASS && "Underlying semaphore queue must be initialized correcty");
}
/// @brief Take mutex
/// @param timeout Timeout to wait for signal (default = wait forever)
/// @return true if successfully claimed (not timeout)
bool claim(Tick timeout = MaxDelay) {
auto ret = xSemaphoreTake(_handle, timeout);
return ret == pdPASS;
}
};
/**
* @brief Mutex Guard. Self releasing mutex for atomic operation
*/
class MutexGuard {
private:
Mutex &_mutex;
bool _claimed;
public:
/// @brief Constructor
/// @param mtx Mutex to claim
/// @param timeout Timeout to wait for signal (default = wait forever)
MutexGuard(Mutex &mtx, Mutex::Tick timeout = Mutex::MaxDelay) : _mutex(mtx) {
_claimed = _mutex.claim(timeout);
};
~MutexGuard() {
if (!_claimed) {
return;
}
_mutex.release();
}
/// @brief Check if mutex was claimed successfully
/// @return true if claimed
bool isActive() {
return _claimed;
}
};
} // namespace fos
components/freeRtosApi/include/Queue.hpp
-98
View File
@@ -1,98 +0,0 @@
/**
* @file queue.hpp
* @author Gustice
* @brief Queue Wrapper
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <freertos/FreeRTOS.h>
#include <freertos/queue.h>
#include <memory>
#include <string_view>
namespace fos {
/**
* @brief Message Queue
*
* @tparam T Type for message payload
*/
template <typename T>
class Queue {
private:
bool _isActive;
QueueHandle_t xQueue;
public:
/// @brief Tick type (redefinition for convenience)
using Tick = TickType_t;
/// @brief Definition for endless waittime
static constexpr Tick MaxDelay = portMAX_DELAY;
/// @brief Constructor
/// @param size number of slots in queue
Queue(size_t size) {
xQueue = xQueueCreate(size, sizeof(T *));
assert(xQueue != 0 && "Queue create must finish successfully");
_isActive = true;
}
~Queue() {
vQueueDelete(xQueue);
}
/// @brief Push new message in queue
/// @param message payload
/// @return nullptr if successful else give back pointer to queued element if pushing failed
std::unique_ptr<T> enqueue(std::unique_ptr<T> message) {
if (uxQueueSpacesAvailable(xQueue) == 0) {
return message;
}
T *o = message.release();
auto ret = xQueueSend(xQueue, &o, (TickType_t)0);
assert(ret == pdPASS && "Underlying semaphore queue must be initialized correcty");
return message;
}
/// @brief Pop message from queue
/// @param timeout timeout to wait for message (default: wait for ever)
/// @return pointer to dequeued element
std::unique_ptr<T> dequeue(Tick timeout = MaxDelay) {
T *pMsg = nullptr;
if (!xQueueReceive(xQueue, &pMsg, timeout)) {
return {nullptr};
}
return std::unique_ptr<T>(pMsg);
}
/// @brief Pop latest element from queue and ignore all older elements
/// @param timeout timeout to wait for message (default: wait for ever)
/// @return pointer to dequeued element
std::unique_ptr<T> dequeueLatest(Tick timeout = MaxDelay) {
T *pMsg = nullptr;
if (!xQueueReceive(xQueue, &pMsg, timeout)) {
return {nullptr};
}
while (true == xQueueReceive(xQueue, &pMsg, (TickType_t)0)) {
}
return std::unique_ptr<T>(pMsg);
}
/// @brief terminate message queue
void signalClose() {
_isActive = false;
}
/// @brief Check if message queue is active
/// @return true if active
bool isActive() {
return _isActive;
}
};
} // namespace fos
components/freeRtosApi/include/Semaphore.hpp
-69
View File
@@ -1,69 +0,0 @@
/**
* @file semaphore.hpp
* @author Gustice
* @brief Semaphore Wrapper
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
namespace fos {
/**
* @brief Semaphore
*/
class Semaphore {
private:
enum Type {
Binary, ///< Binary semaphore, can only be true or false, no matter how often given
Counting ///< Counting semaphore, keeps track of number of give and takes
};
const Type SemType;
QueueHandle_t _handle;
public:
/// @brief Tick type (redefinition for convenience)
using Tick = TickType_t;
/// @brief Definition for endless waittime
static constexpr Tick MaxDelay = portMAX_DELAY;
/// @brief Constructor for binary semaphore
Semaphore() : SemType(Semaphore::Binary) {
_handle = xSemaphoreCreateBinary();
assert(_handle != 0 && "Semaphore create must finish successfully");
}
/// @brief Constructor for conting semaphore
/// @param maxCount Counting limit
/// @param init Initial count
Semaphore(uint32_t maxCount, uint32_t init = 0) : SemType(Semaphore::Counting) {
_handle = xSemaphoreCreateCounting(maxCount, init);
assert(_handle != 0 && "Semaphore create must finish successfully");
}
~Semaphore() {
vSemaphoreDelete(_handle);
};
/// @brief Give signal
/// @note Binary semaphore can only be effectively given once
void give() {
// checking for error would lead to false positives in case of multiple gives ...
xSemaphoreGive(_handle);
}
/// @brief Consume signal
/// @param timeout Timeout to wait for signal (default = wait forever)
/// @return true if successfully consumed (not timeout)
bool take(Tick timeout = MaxDelay) {
auto ret = xSemaphoreTake(_handle, timeout);
return ret == pdPASS;
}
};
} // namespace fos
components/freeRtosApi/include/Task.hpp
-184
View File
@@ -1,184 +0,0 @@
/**
* @file task.hpp
* @author Gustice
* @brief Task Wrapper
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <cassert>
#include <string_view>
#include <Semaphore.hpp>
#define DEFAULT_STACKSIZE 0x1000uL
namespace fos {
/**
* @brief Base class for tasks
*/
class TaskBase {
protected:
TaskHandle_t _handle;
static void disposeFrameConditionally() {
if constexpr (INCLUDE_vTaskDelete != 0) {
vTaskDelete(NULL);
// NOTE: This only compiles if symbol INCLUDE_vTaskDelete is defined
}
}
Semaphore _finished;
public:
/// @brief Priority type (redefinition for convenience)
using Priority = unsigned short;
/// @brief Tick type (redefinition for convenience)
using Tick = TickType_t;
/// @brief Definition for endless waittime
static constexpr Tick MaxDelay = portMAX_DELAY;
/// @brief Maximum delay
static constexpr int MaximumDelay = portMAX_DELAY;
/// @brief Default Stack size
static constexpr size_t DefaultStackSize = DEFAULT_STACKSIZE;
/// @brief Lowest priority for new tasks
static constexpr Priority MIN_PRIORITY = tskIDLE_PRIORITY + 1;
/// @brief Highest priority for new tasks
static constexpr Priority MAX_PRIORITY = configMAX_PRIORITIES;
/// @brief Kill a task
/// @note It can lead to undefined behaviour when one task deletes another task on a
/// multi-core system. Hence a task should clear itself.
void kill() { // NOTE: this leads to undefined behavior if interferes with Destructor
vTaskDelete(_handle);
}
/// @brief Join threads
/// @param timeout timeout to wait for join else kill
/// @return joined successfully
bool join(Tick timeout = MaxDelay) {
auto success = _finished.take(timeout);
if(not success) {
kill();
}
return success;
}
/// @brief Get task state
/// @return FreeRTOS Task state
eTaskState getState() {
return eTaskGetState(_handle);
}
/// @brief Get task handle
/// @return FreeRTOS Task handle
TaskHandle_t getHandle() {
return _handle;
}
/// @brief Delay function
/// @param msToDelay Milliseconds to delay
/// @note The minimal resolution for the delay is tick based
static void delayMs(unsigned int msToDelay) {
// pdMS_TO_TICKS(_timeout)
vTaskDelay(msToDelay / portTICK_PERIOD_MS);
}
/// @brief Delay function
/// @param ticksToDelay Ticks to delay
static void delayTicks(unsigned int ticksToDelay) {
vTaskDelay(ticksToDelay);
}
virtual ~TaskBase() {
kill();
}
};
/**
* @brief Simple task without task parameter
*/
class Task : public TaskBase {
private:
/// @brief Signature for task-implementation-callback
using TaskSignature = void (*)();
static void TaskFrame(void *_this) {
auto &task = *reinterpret_cast<Task *>(_this);
task._call();
// Tasks shall not return, however if this happens dispose task
disposeFrameConditionally();
task._finished.give();
}
TaskSignature _call;
public:
/// @brief Constructor for task without passed argument
/// @param call Function pointer to implementation
/// @param name Name of task
/// @param stack Stacksize if not default
/// @param prio Priority if not default
Task(TaskSignature call, const char *name, size_t stack = DefaultStackSize,
Priority prio = MIN_PRIORITY)
: _call{call} {
auto ret = xTaskCreate(TaskFrame, name, stack, this, MIN_PRIORITY, &_handle);
assert(pdPASS == ret && "Task create must finish successfully");
}
};
/**
* @brief Task with task parameter
* @tparam T Type of task parameter on call
*/
template <typename T>
class TaskT : public TaskBase {
private:
/// @brief Signature for task-implementation-callback
using TaskSignature = void (*)(T);
template <typename TS>
struct Param {
TaskSignature call;
const TS &arg;
};
Param<T> _param;
static void TaskFrame(void *_this) {
auto &task = *reinterpret_cast<TaskT *>(_this);
auto &param = task._param;
param.call(param.arg);
// Tasks shall not return, however if this happens dispose task
disposeFrameConditionally();
task._finished.give();
}
public:
/// @brief Constructor for task with passed argument
/// @param call Function pointer to implementation
/// @param param Parameter ot pass task implementation
/// @param name Name of task
/// @param stack Stacksize if not default
/// @param prio Priority if not default
TaskT(TaskSignature call, const T &param, const char *name, size_t stack = DefaultStackSize,
Priority prio = MIN_PRIORITY)
: _param{call, param} {
auto ret = xTaskCreate(TaskFrame, name, stack, this, MIN_PRIORITY, &_handle);
assert(pdPASS == ret && "Task create must finish successfully");
}
};
class Timing {
public:
static uint32_t getTickCount() {
return xTaskGetTickCount();
}
};
} // namespace fos
components/freeRtosApi/src/freeRtosApi.cpp
-7
View File
@@ -1,7 +0,0 @@
/**
* @file freeRtosApi.cpp
* @author Gustice
* @brief FreeRtos wrapper
*
* @copyright Copyright (c) 2024
*/
components/freeRtosApi/test/CMakeLists.txt
-5
View File
@@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES cmock freeRtosApi esp_timer
)
components/freeRtosApi/test/test.hpp
-30
View File
@@ -1,30 +0,0 @@
#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include <stdio.h>
constexpr int StackSize = 1024;
#include <unity.h>
class TimeTest {
private:
bool running{};
TickType_t _begin;
public:
TimeTest() {
start();
}
void start() {
_begin = xTaskGetTickCount();
running = true;
}
TickType_t getRunTime() {
return xTaskGetTickCount() - _begin;
}
};
components/freeRtosApi/test/test_mutex.cpp
-85
View File
@@ -1,85 +0,0 @@
#include "test.hpp"
#include <Mutex.hpp>
#include <Semaphore.hpp>
#include <Task.hpp>
using namespace fos;
constexpr int SHORT_DELAY = 10;
TEST_CASE("Test mutexes", "[freeRtos][mutex]") {
Mutex eut;
// first take fails
TEST_ASSERT_TRUE(eut.claim(0));
eut.release();
TEST_ASSERT_TRUE(eut.claim(0));
TEST_ASSERT_FALSE(eut.claim(0));
eut.release();
// eut.release(); // not a good idea
TEST_ASSERT_TRUE(eut.claim(0));
// second take after give fails
TEST_ASSERT_FALSE(eut.claim(0));
}
static Semaphore starter1;
static void testClaimer(Mutex &m) {
m.claim();
starter1.give();
vTaskDelay(SHORT_DELAY);
m.release();
vTaskDelay(SHORT_DELAY);
m.claim();
starter1.give();
while (true) {
vTaskDelay(SHORT_DELAY);
};
}
TEST_CASE("Test mutex timing", "[freeRtos][mutex]") {
static Mutex eut;
TaskT<Mutex &> claimer(testClaimer, eut, "signal1");
starter1.take(100);
{ // All ok
TimeTest timer;
TEST_ASSERT_TRUE(eut.claim(100));
TEST_ASSERT_INT_WITHIN(1, SHORT_DELAY, timer.getRunTime());
eut.release();
}
starter1.take(100);
{ // Timeout
TimeTest timer;
TEST_ASSERT_FALSE(eut.claim(20));
TEST_ASSERT_INT_WITHIN(1, 20, timer.getRunTime());
}
{ // NoWeit timeout
Mutex passiveSem;
passiveSem.claim(0);
TimeTest timer;
TEST_ASSERT_FALSE(passiveSem.claim(0));
TEST_ASSERT_INT_WITHIN(1, 0, timer.getRunTime());
}
}
TEST_CASE("Test mutex guard", "[freeRtos][mutex]") {
Mutex mtx;
{
MutexGuard eut(mtx, 100);
TEST_ASSERT_TRUE(eut.isActive());
// already taken
TEST_ASSERT_FALSE(mtx.claim(0));
}
// now free to go
TEST_ASSERT_TRUE(mtx.claim(0));
{ // Timeout
TimeTest timer;
MutexGuard eut(mtx, SHORT_DELAY);
TEST_ASSERT_FALSE(eut.isActive());
TEST_ASSERT_INT_WITHIN(1, SHORT_DELAY, timer.getRunTime());
}
}
components/freeRtosApi/test/test_queue.cpp
-155
View File
@@ -1,155 +0,0 @@
#include "test.hpp"
#include <Queue.hpp>
#include <Task.hpp>
#include <string>
using namespace fos;
constexpr int SHORT_DELAY = 10;
struct MessageFrame {
MessageFrame(int v, std::string msg) : value(v), message(msg) {}
int value;
std::string message;
};
TEST_CASE("Test enqueueing then dequeueing", "[freeRtos][queue]") {
Queue<MessageFrame> eut(10);
auto e = std::make_unique<MessageFrame>(1, "one");
eut.enqueue(std::move(e));
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(1, r->value);
TEST_ASSERT_TRUE(r->message == "one");
}
TEST_CASE("Test enqueueing then dequeue multiple", "[freeRtos][queue]") {
Queue<MessageFrame> eut(10);
auto e = std::make_unique<MessageFrame>(1, "one");
eut.enqueue(std::move(e));
e = std::make_unique<MessageFrame>(2, "two");
eut.enqueue(std::move(e));
e = std::make_unique<MessageFrame>(3, "three");
eut.enqueue(std::move(e));
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(1, r->value);
TEST_ASSERT_TRUE(r->message == "one");
r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(2, r->value);
TEST_ASSERT_TRUE(r->message == "two");
r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(3, r->value);
TEST_ASSERT_TRUE(r->message == "three");
}
TEST_CASE("Test enqueue cyclically", "[freeRtos][queue]") {
constexpr int Size = 10;
Queue<MessageFrame> eut(Size);
for (size_t i = 0; i < Size * 2; i++) {
auto e = std::make_unique<MessageFrame>(i, "Some message");
eut.enqueue(std::move(e));
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(i, r->value);
}
TEST_ASSERT_TRUE(true);
}
TEST_CASE("Test enqueueing till overflow", "[freeRtos][queue]") {
Queue<MessageFrame> eut(3);
auto e = std::make_unique<MessageFrame>(1, "one");
auto r = eut.enqueue(std::move(e));
TEST_ASSERT_EQUAL(nullptr, r.get());
e = std::make_unique<MessageFrame>(2, "two");
r = eut.enqueue(std::move(e));
TEST_ASSERT_EQUAL(nullptr, r.get());
e = std::make_unique<MessageFrame>(3, "three");
r = eut.enqueue(std::move(e));
TEST_ASSERT_EQUAL(nullptr, r.get());
e = std::make_unique<MessageFrame>(4, "four");
auto pE = e.get();
r = eut.enqueue(std::move(e));
TEST_ASSERT_NOT_EQUAL(nullptr, r.get());
// also return old element ...
TEST_ASSERT_EQUAL(pE, r.get());
}
TEST_CASE("Test enqueueing then dequeue multiple", "[freeRtos][queue]") {
Queue<MessageFrame> eut(10);
auto e = std::make_unique<MessageFrame>(1, "one");
eut.enqueue(std::move(e));
e = std::make_unique<MessageFrame>(2, "two");
eut.enqueue(std::move(e));
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(1, r->value);
r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(2, r->value);
r = eut.dequeue(0); // no waiting
TEST_ASSERT_EQUAL(nullptr, r.get());
}
static void queue1Gen(Queue<MessageFrame> &q) {
vTaskDelay(SHORT_DELAY);
auto e = std::make_unique<MessageFrame>(0, "msg");
q.enqueue(std::move(e));
while (true) {
vTaskDelay(SHORT_DELAY);
};
}
TEST_CASE("Test timing of queue", "[freeRtos][queue]") {
static Queue<MessageFrame> eut(8);
TaskT<Queue<MessageFrame> &> signaler(queue1Gen, eut, "queue1Gen");
{ // All ok
TimeTest timer;
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_INT_WITHIN(1, SHORT_DELAY, timer.getRunTime());
}
{ // Timeout
TimeTest timer;
auto r = eut.dequeue(20);
TEST_ASSERT_NULL(r.get());
TEST_ASSERT_INT_WITHIN(1, 20, timer.getRunTime());
}
}
static void senderTask(Queue<MessageFrame> &q) {
size_t i = 0;
while (q.isActive()) {
auto e = std::make_unique<MessageFrame>(i++, "Some message");
q.enqueue(std::move(e));
vTaskDelay(1);
}
}
TEST_CASE("Test enqueueing series of message", "[freeRtos][queue]") {
constexpr int Size = 10;
Queue<MessageFrame> eut(Size);
TaskT<Queue<MessageFrame> &> sender(senderTask, eut, "sender");
for (size_t i = 0; i < Size * 2; i++) {
auto r = eut.dequeue(100);
TEST_ASSERT_NOT_NULL(r.get());
TEST_ASSERT_EQUAL(i, r->value);
}
eut.signalClose();
TEST_ASSERT_TRUE(true);
}
components/freeRtosApi/test/test_semaphore.cpp
-119
View File
@@ -1,119 +0,0 @@
#include "test.hpp"
#include <Semaphore.hpp>
#include <Task.hpp>
using namespace fos;
constexpr int SHORT_DELAY = 10;
TEST_CASE("Test binary semaphore", "[freeRtos][sem]") {
Semaphore eut;
// first take fails
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
// first take after give fails
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
eut.give();
TEST_ASSERT_TRUE(eut.take(0));
// second take after give fails
TEST_ASSERT_FALSE(eut.take(0));
}
TEST_CASE("Test counting semaphore", "[freeRtos][sem]") {
Semaphore eut(2, 0);
// first take fails
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
// first take after give fails
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
eut.give();
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_TRUE(eut.take(0));
// third take after give fails
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
eut.give();
eut.give();
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_TRUE(eut.take(0));
// still third take after give fails
TEST_ASSERT_FALSE(eut.take(0));
}
TEST_CASE("Test preset counting semaphore", "[freeRtos][sem]") {
Semaphore eut(2, 2);
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_TRUE(eut.take(0));
// third take fails
TEST_ASSERT_FALSE(eut.take(0));
eut.give();
// first take after give fails
TEST_ASSERT_TRUE(eut.take(0));
TEST_ASSERT_FALSE(eut.take(0));
// ...
}
static void test1Signal(Semaphore &s) {
vTaskDelay(SHORT_DELAY);
s.give();
while (true) {
vTaskDelay(SHORT_DELAY);
};
}
TEST_CASE("Test timing binary semaphore", "[freeRtos][sem]") {
static Semaphore eut;
TaskT<Semaphore &> signaler(test1Signal, eut, "signal1");
{ // All ok
TimeTest timer;
TEST_ASSERT_TRUE(eut.take(100));
TEST_ASSERT_INT_WITHIN(1, SHORT_DELAY, timer.getRunTime());
}
{ // Timeout
TimeTest timer;
TEST_ASSERT_FALSE(eut.take(20));
TEST_ASSERT_INT_WITHIN(1, 20, timer.getRunTime());
}
{ // NoWait timeout
Semaphore passiveSem;
TimeTest timer;
TEST_ASSERT_FALSE(passiveSem.take(0));
TEST_ASSERT_INT_WITHIN(1, 0, timer.getRunTime());
}
}
static int syncCount = 0;
static void producerTask(Semaphore &s) {
while (true) {
s.give();
vTaskDelay(SHORT_DELAY);
};
}
static void consumerTask(Semaphore &s) {
while (true) {
s.take();
syncCount++;
};
}
TEST_CASE("Test if tasks signaling with semaphore", "[freeRtos][sem]") {
static Semaphore eut;
TaskT<Semaphore &> producer(producerTask, eut, "producer");
TaskT<Semaphore &> consumer(consumerTask, eut, "consumer");
vTaskDelay(5 * SHORT_DELAY);
TEST_ASSERT_INT_WITHIN(1, 5, syncCount);
}
components/freeRtosApi/test/test_task.cpp
-88
View File
@@ -1,88 +0,0 @@
#include "test.hpp"
#include <Task.hpp>
#include <array>
using namespace fos;
TEST_CASE("Test Delay", "[freeRtos][task]") {
TickType_t start = xTaskGetTickCount();
Task::delayMs(5 * portTICK_PERIOD_MS);
TickType_t end = xTaskGetTickCount();
TEST_ASSERT_GREATER_OR_EQUAL(5, (end - start));
TEST_ASSERT_LESS_OR_EQUAL(6, (end - start));
}
static bool taskWasCalled = false;
static void callableTask() {
taskWasCalled = true;
while (true) {
vTaskDelay(100);
}
}
TEST_CASE("Test creation and deletion", "[freeRtos][task]") {
static Task task(callableTask, "task1");
Task::delayMs(50);
TEST_ASSERT_TRUE(taskWasCalled);
task.kill();
}
static void callableTask2() {
taskWasCalled = true;
while (true) {
vTaskDelay(100);
}
}
TEST_CASE("Test if task can be killed", "[freeRtos][task]") {
static Task task(callableTask2, "task2");
auto handle = task.getHandle();
configASSERT(handle);
TEST_ASSERT_TRUE(eTaskState::eReady == task.getState() ||
eTaskState::eBlocked == task.getState());
Task::delayMs(50);
TEST_ASSERT_TRUE(taskWasCalled);
task.kill();
TEST_ASSERT_EQUAL(eTaskState::eDeleted, eTaskGetState(handle));
}
static std::array<int, 2> values;
static void oneOfMultiple(int idx) {
static std::array<int, 2> c{1, -1};
for (size_t i = 0; i < 10; i++) {
values.at(idx) += c.at(idx);
}
while (true) {
vTaskDelay(100);
}
}
TEST_CASE("Test if tasks do not interfere", "[freeRtos][task]") {
// Both tasks are run by starting the same static function body
int param1 = 0;
TaskT<int> task1(oneOfMultiple, param1, "pTask1");
int param2 = 1;
TaskT<int> task2(oneOfMultiple, param2, "pTask2");
Task::delayMs(50);
TEST_ASSERT_EQUAL(10, values[0]);
TEST_ASSERT_EQUAL(-10, values[1]);
}
TEST_CASE("Test if tasks can be joined correctly", "[freeRtos][task]") {
// Both tasks are run by starting the same static function body
int param1 = 0;
Task task1(oneOfMultiple, param1, "pTask1");
int param2 = 1;
TaskT<int> task2(oneOfMultiple, param2, "pTask2");
Task::delayMs(50);
TEST_ASSERT_EQUAL(10, values[0]);
TEST_ASSERT_EQUAL(-10, values[1]);
}
components/lightEffect/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
)
components/lightEffect/color.hpp
-202
View File
@@ -1,202 +0,0 @@
/**
* @file color.hpp
* @author Gustice
* @brief
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <cassert>
#include <cstdint>
#include <cstring>
#include <type_traits>
/// No Waveform definition
extern uint8_t const *const noWave;
/**
* @brief Color class
*
* @details Defines color data and common operations with color objects
* \li Supports RGB with overlapping white channel (e.g. SK6812-LED)
* \li Supports Operator overloading with '+' and '*' (Combined operation with MixWith)
* \li Return formatted data stream that can be directly sent to an LED
*/
class Color {
private:
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t white;
public:
struct Rgbw {
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t white;
};
struct Rgb {
uint8_t red;
uint8_t green;
uint8_t blue;
};
/// @brief Construct a new Color object
/// @details Default color will be Black \ref _ctBlack
Color(void) {
set(0, 0, 0, 0);
};
/// @brief Copy-Construct a new Color object
Color(const Color & c) {
red = c.red;
green = c.green;
blue = c.blue;
white = c.white;
};
/// @brief Construct a new Color object according to rgb color-channel-values
/// @details This constructor also takes an overlapping white channel
/// @param r Red channel
/// @param g Green channel
/// @param b Blue channel
/// @param w White channel (zero by default if not assigned)
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { set(r, g, b, w); };
/// @brief Set the Color object according to rgb color-channel values
/// @param r Red channel
/// @param g Green channel
/// @param b Blue channel
/// @param w White channel (zero by default if not assigned)
void set(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) {
red = r;
green = g;
blue = b;
white = w;
}
/// @brief Returns Color as Color_t structure
/// @return Color_t Color
template <typename T>
T getColor(void) const {
if constexpr (std::is_same<T, Rgbw>::value) {
return {red, green, blue, white};
} else if constexpr (std::is_same<T, Rgb>::value) {
return {red, green, blue};
} else {
throw "wrong type";
}
}
uint8_t getRed() { return red; };
uint8_t getGreen() { return green; };
uint8_t getBlue() { return blue; };
uint8_t getWhite() { return white; };
/// @brief Scaling and overlaying with given color.
/// @param c2 Color 2
/// @param k scaling factor
/// @return Overlayed Color
Color mixWith(const Color c2, uint8_t k = 0x7F) {
auto t(c2);
*this = (*this * (UINT8_MAX - k)) + (t * k);
return *this;
}
/// @brief Writes Color as formatted byte stream to location
/// @param color
template <typename T>
void writeByteStreamTo(uint8_t raw[sizeof(T)]) const {
if constexpr (std::is_same<T, Rgbw>::value) {
raw[0] = blue;
raw[1] = green;
raw[2] = red;
raw[3] = white;
} else if constexpr (std::is_same<T, Rgb>::value) {
raw[0] = blue;
raw[1] = green;
raw[2] = red;
} else {
throw "wrong type";
}
}
/// @brief Assign overload
Color operator=(const Color &c2) {
red = c2.red;
green = c2.green;
blue = c2.blue;
white = c2.white;
return *this;
}
/// @brief Checks if both color values are equal
bool operator==(Color const &c2) const {
return ((blue == c2.blue) && (green == c2.green) &&
(red == c2.red) && (white == c2.white));
}
/// @brief Checks if both color values are not equal
bool operator!=(Color const &c2) const {
return ((blue != c2.blue) || (green != c2.green) ||
(red != c2.red) || (white != c2.white));
}
/// @brief Scale color by scaling each color-channel by given factor
/// @param c1 Color
/// @param k Scale-factor uint8_t.Max is full-scale
/// @return Scaled Color
Color operator*(uint8_t k) {
red = (uint8_t)((uint16_t)red * k / 0xFF);
green = (uint8_t)((uint16_t)green * k / 0xFF);
blue = (uint8_t)((uint16_t)blue * k / 0xFF);
white = (uint8_t)((uint16_t)white * k / 0xFF);
return *this;
}
/// @brief Overlaying to colors my adding each color channel value
/// @note Colors channels should not overlap since there is no automatic ratio correction.
/// Use *-Operator first in order to scale each color value a a way that no overflow can occur
/// @param c2 Color 2
/// @return Overlayed Color
Color operator+(Color c2) {
red = red + c2.red;
green = green + c2.green;
blue = blue + c2.blue;
white = white + c2.white;
return *this;
}
};
static_assert(sizeof(Color) == 4 && "Color Type is to big");
/// Null color object
extern const Color *noColor;
/// Used old color agreement (if no color pointer)
extern const Color *oldColor;
/// Black color object constant
extern const Color CBlack;
/// Red color object constant
extern const Color CRed;
/// Green color object constant
extern const Color CGreen;
/// Blue color object constant
extern const Color CBlue;
/// Magenta color object constant
extern const Color CMagenta;
/// Cyan color object constant
extern const Color CCyan;
/// Yellow color object constant
extern const Color CYellow;
/// White color object constant
extern const Color CWhite;
/// Warm white color object constant (with higher red channel value)
extern const Color CWarmWhite;
/// Black color object constant (with higher green channel value)
extern const Color CColdWhite;
/// Black color object constant (with higher blue channel value)
extern const Color CSpookyWhite;
components/lightEffect/include/Color.hpp
-202
View File
@@ -1,202 +0,0 @@
/**
* @file color.hpp
* @author Gustice
* @brief
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <cassert>
#include <cstdint>
#include <cstring>
#include <type_traits>
/// No Waveform definition
extern uint8_t const *const noWave;
/**
* @brief Color class
*
* @details Defines color data and common operations with color objects
* \li Supports RGB with overlapping white channel (e.g. SK6812-LED)
* \li Supports Operator overloading with '+' and '*' (Combined operation with MixWith)
* \li Return formatted data stream that can be directly sent to an LED
*/
class Color {
private:
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t white;
public:
struct Rgbw {
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t white;
};
struct Rgb {
uint8_t red;
uint8_t green;
uint8_t blue;
};
/// @brief Construct a new Color object
/// @details Default color will be Black \ref _ctBlack
Color(void) {
set(0, 0, 0, 0);
};
/// @brief Copy-Construct a new Color object
Color(const Color & c) {
red = c.red;
green = c.green;
blue = c.blue;
white = c.white;
};
/// @brief Construct a new Color object according to rgb color-channel-values
/// @details This constructor also takes an overlapping white channel
/// @param r Red channel
/// @param g Green channel
/// @param b Blue channel
/// @param w White channel (zero by default if not assigned)
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { set(r, g, b, w); };
/// @brief Set the Color object according to rgb color-channel values
/// @param r Red channel
/// @param g Green channel
/// @param b Blue channel
/// @param w White channel (zero by default if not assigned)
void set(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) {
red = r;
green = g;
blue = b;
white = w;
}
/// @brief Returns Color as Color_t structure
/// @return Color_t Color
template <typename T>
T getColor(void) const {
if constexpr (std::is_same<T, Rgbw>::value) {
return {red, green, blue, white};
} else if constexpr (std::is_same<T, Rgb>::value) {
return {red, green, blue};
} else {
throw "wrong type";
}
}
uint8_t getRed() { return red; };
uint8_t getGreen() { return green; };
uint8_t getBlue() { return blue; };
uint8_t getWhite() { return white; };
/// @brief Scaling and overlaying with given color.
/// @param c2 Color 2
/// @param k scaling factor
/// @return Overlayed Color
Color mixWith(const Color c2, uint8_t k = 0x7F) {
auto t(c2);
*this = (*this * (UINT8_MAX - k)) + (t * k);
return *this;
}
/// @brief Writes Color as formatted byte stream to location
/// @param color
template <typename T>
void writeByteStreamTo(uint8_t raw[sizeof(T)]) const {
if constexpr (std::is_same<T, Rgbw>::value) {
raw[0] = blue;
raw[1] = green;
raw[2] = red;
raw[3] = white;
} else if constexpr (std::is_same<T, Rgb>::value) {
raw[0] = blue;
raw[1] = green;
raw[2] = red;
} else {
throw "wrong type";
}
}
/// @brief Assign overload
Color operator=(const Color &c2) {
red = c2.red;
green = c2.green;
blue = c2.blue;
white = c2.white;
return *this;
}
/// @brief Checks if both color values are equal
bool operator==(Color const &c2) const {
return ((blue == c2.blue) && (green == c2.green) &&
(red == c2.red) && (white == c2.white));
}
/// @brief Checks if both color values are not equal
bool operator!=(Color const &c2) const {
return ((blue != c2.blue) || (green != c2.green) ||
(red != c2.red) || (white != c2.white));
}
/// @brief Scale color by scaling each color-channel by given factor
/// @param c1 Color
/// @param k Scale-factor uint8_t.Max is full-scale
/// @return Scaled Color
Color operator*(uint8_t k) {
red = (uint8_t)((uint16_t)red * k / 0xFF);
green = (uint8_t)((uint16_t)green * k / 0xFF);
blue = (uint8_t)((uint16_t)blue * k / 0xFF);
white = (uint8_t)((uint16_t)white * k / 0xFF);
return *this;
}
/// @brief Overlaying to colors my adding each color channel value
/// @note Colors channels should not overlap since there is no automatic ratio correction.
/// Use *-Operator first in order to scale each color value a a way that no overflow can occur
/// @param c2 Color 2
/// @return Overlayed Color
Color operator+(Color c2) {
red = red + c2.red;
green = green + c2.green;
blue = blue + c2.blue;
white = white + c2.white;
return *this;
}
};
static_assert(sizeof(Color) == 4 && "Color Type is to big");
/// Null color object
extern const Color *noColor;
/// Used old color agreement (if no color pointer)
extern const Color *oldColor;
/// Black color object constant
extern const Color CBlack;
/// Red color object constant
extern const Color CRed;
/// Green color object constant
extern const Color CGreen;
/// Blue color object constant
extern const Color CBlue;
/// Magenta color object constant
extern const Color CMagenta;
/// Cyan color object constant
extern const Color CCyan;
/// Yellow color object constant
extern const Color CYellow;
/// White color object constant
extern const Color CWhite;
/// Warm white color object constant (with higher red channel value)
extern const Color CWarmWhite;
/// Black color object constant (with higher green channel value)
extern const Color CColdWhite;
/// Black color object constant (with higher blue channel value)
extern const Color CSpookyWhite;
components/lightEffect/include/ExactIndex.hpp
-60
View File
@@ -1,60 +0,0 @@
/**
* @file ExactIndex.h
* @author Gustice
* @brief Index-Class with fix-point arithmetic
*/
#pragma once
#include <algorithm>
#include <cstdint>
/**
* @brief Index-Class with fix-point arithmetic for exact stepping though data-points
* @details Allows stepping through data-points by quotient step-sizes
*/
class ExactIndex {
public:
/// @brief Construct Index-object according to number of data points and steps to be taken
/// @param length
/// @param steps
ExactIndex(unsigned length, uint16_t steps) : Length(std::max(1u, length)), Steps(steps) {
_delta = Length << 8;
_delta = _delta / steps;
_index = unsigned(0u - _delta);
}
/// @brief Get current index-position as floor value to never pass upper bound
uint16_t GetIdx(void) { return ((_index) >> 8); };
/// @brief Move index by quotient step forward
ExactIndex &operator++() {
_index = _index + _delta;
return *this;
}
/// @brief Move index by quotient step backward
ExactIndex &operator--() {
_index = _index - _delta;
return *this;
}
/// @brief Get current index-position as floor value to never pass upper bound
operator int() const { return ((_index) >> 8); }
/// @brief Get size of data set (number of data points)
unsigned GetLength() { return Length; }
/// @brief Get number of steps that are to be taken though data set
uint16_t GetSteps() { return Steps; }
private:
/// @brief Number of data points
unsigned Length;
/// @brief Steps to be taken through data-set
uint16_t Steps;
/// @brief Current index in fixed-point representation
unsigned _index = 0;
/// @brief Step-with in fixed-point representation
unsigned _delta;
};
components/lightEffect/include/Macro.hpp
-95
View File
@@ -1,95 +0,0 @@
/**
* @file Macro.h
* @author Gustice
* @brief Predefined effect macros
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "Color.hpp"
#include "Waveform.hpp"
#include <cstdint>
#include <vector>
namespace Effect {
/// Collection of process values to maintain processing state machine
struct StepProcessVars {
/// @brief Reference of current color
const Color &pCurentColor;
/// @brief Number of color entries
uint8_t ColorLen;
/// @brief Idle value for intensity
uint8_t IdleIntensity;
/// @brief Full value for intensity
uint8_t FullIntensity;
/// @brief Dynamic range for effects
uint8_t DynamicRange;
/// @brief Index in current waveform
uint16_t waveIdx;
/// @brief Reference to processed waveform
const WaveForm_t *const pWave;
};
/**
* @brief Effect implementation for State-Machine
* @details State-Machine invokes referred effect-implementation during processing
*/
typedef Color (*EffectImplementation)(StepProcessVars &pcsParam);
/**
* @brief Definition of Effect-Macro
*/
struct Macro_t {
/// @brief Effect type
const EffectImplementation pImplementation;
/// @brief Effect duration waveforms will be compressed / stretched to fit the duration
const uint8_t Duration;
/// @brief Next SubEffect
const int8_t Next;
/// @brief waveform reference
const WaveForm_t *pWave = emptyWave;
/// @brief Full-Scale-intensity
const uint8_t FsIntensity;
/// @brief Num of Repeats
const int8_t Repeats;
Macro_t(uint8_t duration, int8_t next, EffectImplementation state, uint8_t intensity,
int8_t repeats = 0)
: pImplementation(state), Duration(duration), Next(next), FsIntensity(intensity),
Repeats(repeats) {}
Macro_t(uint8_t duration, int8_t next, WaveForm_t const *wave, EffectImplementation state,
uint8_t intensity, int8_t repeats = 0)
: pImplementation(state), Duration(duration), Next(next), pWave(wave),
FsIntensity(intensity), Repeats(repeats) {}
private:
/// @brief Null-pointer to represent no change in color
static constexpr Color *pOldColor = nullptr;
/// @brief Null-pointer to represent no actual waveform-representation
static constexpr WaveForm_t *pNoWave = nullptr;
/// @brief Default implemented Waveform with no profile
static const constexpr WaveForm_t *emptyWave = &EmptyWave;
};
using Macro = std::vector<Macro_t>;
/// @brief Dark - Nothing to see here
extern const Macro macDark;
/// @brief Continuous idle
extern const Macro macIdle;
/// @brief Continuous flicker
extern const Macro macStartFlicker;
/// @brief Smooth turn on and then remaining idle
extern const Macro macStartIdle;
/// @brief Smooth turn on to full color
extern const Macro macStartFull;
/// @brief Slow pulse starting from idle intensity. Appears like breathing
extern const Macro macStdPulse;
/// @brief Short pulses starting from idle intensity. Appears nervously.
extern const Macro macNervousPulse;
} // namespace Effect
components/lightEffect/include/Processor.hpp
-53
View File
@@ -1,53 +0,0 @@
/**
* @file EffectProcessor.h
* @author Gustice
* @brief Effect-Processor-Class for processing effect scenarios and switching actions
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "Color.hpp"
#include "Macro.hpp"
#include "StateMachine.hpp"
#include <array>
#include <cstdint>
namespace Effect {
/**
* @brief EffectProcessor Class
* @details Maintains State-Machines, Processes effect-switching, and invokes generation
* of raw data stream for LEDs.
* \li If effect scenarios are changed a cross-fading is executed
* \li Raw-data-stream for each Color object is generated
*/
class EffectProcessor {
public:
///@brief Constructor
///@param fadeSteps Steps count for cross fade
EffectProcessor(uint8_t const fadeSteps = 8);
/// @brief Set next effect sequence
/// @param sequence reference to sequence that has to be processed next
/// @param sColor Start color. Use noColor to start with default color
/// @param intens Idle intensity for effect. Use NULL to start with default intensity
void setEffect(const Macro &sequence, Color const *sColor = noColor, uint8_t delay = 0, uint8_t intens = gu8_idleIntensity);
/// @brief Execute step of effect processor
/// @return Reference to color result
Color tick(void);
private:
StateMachine::Parameter _parameter;
std::array<StateMachine, 2> _effectMachines;
uint8_t _fadeSteps;
uint8_t _fadingCnt;
StateMachine *_EffPV;
StateMachine *_EffPV_old;
Color crossFadeColors(Color &cNew, Color &cOld, uint8_t k);
EffectProcessor();
};
} // namespace Effect
components/lightEffect/include/StateMachine.hpp
-118
View File
@@ -1,118 +0,0 @@
/**
* @file EffectStateMachine.h
* @author Gustice
* @brief Effect-State-Machine-Class for processing Effect Macros
* @version 0.6
* @date 2019-10-01
*
* @copyright Copyright (c) 2019
*
*/
#pragma once
#include "Color.hpp"
#include "Macro.hpp"
#include <cstdint>
#include "ExactIndex.hpp"
namespace Effect {
/**
* @brief Effect State Machine Class
* @details Processes Effect macro array Macro entry subsequently
* Processing is executed in following manner:
* \li Index-incrementing each Tick
* \li ticks until duration \ref EffMacro is finished
* \li each tick the index incremented by templateLength/duration
* \li Repeats-processing
* \li Each repeat the tick and the index are set back to start
* \li Switches to next Macro enty
* \li Next entry is given by 'next' index
* \li Color changes can be executed optionally
*/
class StateMachine {
public:
/// @brief Collection of object configuration at startup
struct Parameter {
/// @brief Idle intensity as background color
uint8_t idleIntens;
/// @brief dynamic range as variation around background color
uint8_t dynamicRange;
/// @brief Fade steps for color changes
uint8_t fadeSteps;
/// @brief Count of target LEDs
uint8_t targetCount;
};
///@brief Construct a new Effect State Machine object
///@param templateLength Length of waveforms that are used to display
StateMachine(Parameter &parameter);
///@brief Sets the effect state machine to process given effect macro
///@param sequence reference to sequence
///@param startColor Start color. Use noColor to invoke with default color
///@param initialDelay Number of steps that are waited before effect is started
void setEffect(const Macro &sequence, Color const *startColor = noColor, uint8_t initialDelay = 0);
/// @brief Sets the effect state machine to process given effect macro
/// @param sequence reference to sequence
/// @param startColor Start color. Use noColor to invoke with default color
/// @param intens Idle intensity for effect. Use nullptr to start with default intensity
/// @param delayedStart Number of steps that are waited before effect is started
void setEffect(const Macro &sequence, Color const *startColor, const uint8_t *intens,
const uint8_t delayedStart);
/// @brief Execute step of state machine
/// @details Each tick the tick variable is decremented. After the limit is reached,
/// the current macro line is either repeated or the next macro line is started (with
/// an optional color change).\n
/// @note Tick must be called regularly. For standard light applications all 40 ms seems to be
/// a convenient values.
/// @return Color const* Reference to color result
virtual Color tick(void);
/// Black out lights
static Color UpdateBlank(StepProcessVars &pcsParam);
/// Continuous illumination in idle intensity
static Color UpdateIdle(StepProcessVars &pcsParam);
/// Keep latest state on hold
static Color UpdateFreeze(StepProcessVars &pcsParam);
/// Step through a defined waveform
static Color UpdateWave(StepProcessVars &pcsParam);
/// Step through a defined waveform backwards
static Color UpdateRevWave(StepProcessVars &pcsParam);
/// Show flicker effect with idle intensity as static part with dynamic flicker-range
static Color UpdateFlicker(StepProcessVars &pcsParam);
protected:
/// Collection of process values to maintain processing state machine
struct ProcessValues {
/// Decrementing tick, counting duration
uint8_t tick;
/// Decrementing repeats of current Effect-part
uint8_t repeats;
/// Index to macro element
uint8_t macroIdx;
/// Current index to waveform
uint16_t waveIdx;
/// Index step each tick according to duration and template length.
uint16_t waveStep;
};
/// @brief Concentrated parameter values of instance
Parameter &_params;
Color const * _curentColor;
ProcessValues _prcValues;
void SetIndexes(void);
Macro const *_p_effSeq;
Macro_t const *_p_effMac;
ExactIndex _idx;
// Color& (*apF_Effects)(StateMachine * SM);
typedef Color const *pEffPrc(StateMachine *);
};
} // namespace Effect
components/lightEffect/include/Waveform.hpp
-27
View File
@@ -1,27 +0,0 @@
/**
* @file WaveForm.h
* @author Gustice
* @brief C++ encapsulated waveform definition
*/
#pragma once
#include "Waveforms.hpp"
#include <cstdint>
namespace Effect {
/**
* @brief Waveform definition based on c-definitions
*/
struct WaveForm_t {
/// @brief Reference to waveform
const uint8_t *const pWave;
/// @brief Length of waveform
const unsigned Length;
};
/// @brief Empty waveform with defined pointer to meaningless data to avoid problems
extern const WaveForm_t EmptyWave;
} // namespace Effect
components/lightEffect/include/Waveforms.hpp
-38
View File
@@ -1,38 +0,0 @@
/**
* @file EffectWaveforms.h
* @author Gustice
* @brief Predefined Waveforms that can be put together to a complex Waveform
* @version 0.6
* @date 2019-10-01
*
* @copyright Copyright (c) 2019
*
*/
#pragma once
#include <cstdint>
namespace Effect {
/// Length of all subsequent Template definitions
extern const uint16_t cu16_TemplateLength;
/// Idle intensity for Slopes and Pulses
extern const uint8_t gu8_idleIntensity;
/// Idle intensity for Slopes and Pulses
extern const uint8_t gu8_fullIntensity;
/// Headroom for Effects on top of idle brightness
extern const uint8_t gu8_dynamicRange;
/// Standard cross fade steps
extern const uint8_t gu8_fadeSteps;
/// Starts from idle \ref gu8_idleIntensity and represents a gaussian impulse \ref gu8_fullIntensity
extern const uint8_t gau8_offsetPulse[];
/// Starts at zero and rises to idle intensity \ref gu8_idleIntensity
extern const uint8_t gau8_initSlope[];
/// Starts from idle \ref gu8_idleIntensity and rises up to full intensity \ref gu8_fullIntensity
extern const uint8_t gau8_offsetSlope[];
/// Starts at zero and rises to full intensity \ref gu8_fullIntensity
extern const uint8_t gau8_fullSlope[];
/// Starts at zero and represents a gaussian impulse to full intensity \ref gu8_fullIntensity
extern const uint8_t gau8_fullPulse[];
} // namespace Effect
components/lightEffect/src/Color.cpp
-27
View File
@@ -1,27 +0,0 @@
/**
* @file color.cpp
* @author Gustice
* @brief Implementation of Color-Class
*
* @copyright Copyright (c) 2024
*/
#include "Color.hpp"
uint8_t const * const noWave = nullptr;
const Color *noColor = nullptr;
const Color *oldColor = nullptr;
const Color CBlack(0x00, 0x00, 0x00, 0x00);
const Color CRed(0xFF, 0x00, 0x00, 0x00);
const Color CGreen(0x00, 0xFF, 0x00, 0x00);
const Color CBlue(0x00, 0x00, 0xFF, 0x00);
const Color CMagenta(0x80, 0x00, 0x80, 0x00);
const Color CCyan(0x00, 0x80, 0x80, 0x00);
const Color CYellow(0x80, 0x80, 0x00, 0x00);
const Color CWhite(0x55, 0x55, 0x55, 0x00);
const Color CWarmWhite(0x7F, 0x4F, 0x4F, 0x00);
const Color CColdWhite(0x4F, 0x4F, 0x7F, 0x00);
const Color CSpookyWhite(0x4F, 0x7F, 0x4F, 0x00);
components/lightEffect/src/Macro.cpp
-71
View File
@@ -1,71 +0,0 @@
/**
* @file EffectMacro.cpp
* @author Gustice
* @brief Predefined Macros
* @version 0.6
* @date 2021-03-23
*
* @copyright Copyright (c) 2021
*/
#include "Macro.hpp"
#include "Color.hpp"
#include "Waveforms.hpp"
#include "StateMachine.hpp"
namespace Effect {
const uint8_t Empty[4] = {0, 0, 0, 0};
const WaveForm_t EmptyWave{Empty, 4};
const WaveForm_t OffsetPulseWave{gau8_offsetPulse, cu16_TemplateLength};
const WaveForm_t InitSlopeWave{gau8_initSlope, cu16_TemplateLength};
const WaveForm_t OffsetSlopeWave{gau8_offsetSlope, cu16_TemplateLength};
const WaveForm_t FullSlopeWave{gau8_fullSlope, cu16_TemplateLength};
const WaveForm_t FullPulseWave{gau8_fullPulse, cu16_TemplateLength};
const Macro macDark = {
{32, 0, StateMachine::UpdateBlank, 0, 0}
};
const Macro macIdle = {
{32, 1, StateMachine::UpdateIdle, 0xFF},
{32, 1, StateMachine::UpdateIdle, 0xFF},
};
const Macro macStartIdle = {
{64, 1, &InitSlopeWave, StateMachine::UpdateWave, 0xFF},
{32, 1, StateMachine::UpdateIdle, 0xFF},
};
const Macro macStartFlicker = {
{64, 1, &InitSlopeWave, StateMachine::UpdateWave, 0xFF},
{32, 1, StateMachine::UpdateFlicker, 0xFF},
};
const Macro macStartFull = {
{24, 1, &FullSlopeWave, StateMachine::UpdateWave, 0xFF},
{32, 1, StateMachine::UpdateIdle, 0xFF},
};
const Macro macStdPulse = {
{32, 1, StateMachine::UpdateIdle, 0},
{32, 2, &OffsetPulseWave, StateMachine::UpdateWave, 0xFF},
{32, 0, StateMachine::UpdateIdle, 0},
};
const Macro macNervousPulse = {
{8, 1, StateMachine::UpdateIdle, 0},
{16, 2, &OffsetPulseWave, StateMachine::UpdateWave, 0xFF},
{8, 0, StateMachine::UpdateIdle, 0},
};
const Macro macStdWipe = {
{32, 1, StateMachine::UpdateIdle, 0},
{32, 2, &OffsetSlopeWave, StateMachine::UpdateWave, 0xFF},
{32, 3, StateMachine::UpdateFreeze, 0},
{32, 4, &OffsetSlopeWave, StateMachine::UpdateRevWave, 0xFF},
{32, 1, StateMachine::UpdateFreeze, 0},
};
} // namespace Effect
components/lightEffect/src/Processor.cpp
-58
View File
@@ -1,58 +0,0 @@
/**
* @file Processor.cpp
* @author Gustice
* @brief Implementation of Effect-Processor-Class EffectProcessor.h
* @version 0.6
* @date 2019-10-03
*
* @copyright Copyright (c) 2019
*/
#include "Processor.hpp"
#include "Macro.hpp"
#include "Waveforms.hpp"
#include <algorithm>
#include <math.h>
#include <stdlib.h>
namespace Effect {
EffectProcessor::EffectProcessor(uint8_t const fadeSteps)
: _parameter{0x20, 0x20, 0, 1},
_effectMachines{StateMachine{_parameter}, StateMachine{_parameter}} {
_EffPV = &_effectMachines[0];
_EffPV_old = &_effectMachines[1];
_EffPV->setEffect(macDark, noColor);
_fadeSteps = fadeSteps;
}
void EffectProcessor::setEffect(const Macro &sequence, Color const *sColor, uint8_t delay, uint8_t intens) {
_fadingCnt = _fadeSteps;
std::swap(_EffPV, _EffPV_old);
_EffPV->setEffect(sequence, sColor, &intens, delay);
}
Color EffectProcessor::tick(void) {
uint8_t k;
auto cN = (_EffPV->tick());
if (_fadingCnt > 0) { // always process soft cross dissolve between different macros
_fadingCnt--;
k = (uint16_t)_fadingCnt * 0xFF / _fadeSteps;
auto cO = (_EffPV_old->tick());
cN = crossFadeColors(cN, cO, k);
}
return cN;
}
Color EffectProcessor::crossFadeColors(Color &cNew, Color &cOld, uint8_t k) {
cOld = cOld * k;
cNew = cNew * (0xFF - k);
cNew = cNew + cOld;
return cNew;
}
} // namespace Effect
components/lightEffect/src/StateMachine.cpp
-117
View File
@@ -1,117 +0,0 @@
/**
* @file StateMachine.cpp
* @author Gustice
* @brief Implementation of Effect-State-Machine-Class EffectStateMachine.h
* @version 0.6
* @date 2019-10-01
*
* @copyright Copyright (c) 2019
*
*/
#include "StateMachine.hpp"
#include "Waveforms.hpp"
#include <math.h>
#include <stdlib.h>
namespace Effect {
/// Optional prequel for delayed start.
/// \li Duration must be != 0
/// \li Next entry will be first entry in given Effect sequence
Macro delayPrequel = {
{1, 0, StateMachine::UpdateBlank, 0, 0}
};
StateMachine::StateMachine(Parameter &parameter)
: _params(parameter), _idx(/*pseudo values*/ 1, 1) {}
void StateMachine::setEffect(const Macro &sequence, Color const *startColor, uint8_t initialDelay) {
setEffect(sequence, startColor, &_params.idleIntens, initialDelay);
}
void StateMachine::setEffect(const Macro &sequence, Color const *startColor, const uint8_t *intens,
const uint8_t delayedStart) {
if (startColor != noColor) {
_curentColor = startColor;
}
if (intens != nullptr) {
_params.idleIntens = *intens;
}
_p_effSeq = &sequence;
if (delayedStart > 0) {
_p_effMac = &delayPrequel[0];
_prcValues.tick = delayedStart;
} else {
_p_effMac = &sequence[0];
_prcValues.tick = _p_effMac->Duration;
}
_prcValues.tick++;
_prcValues.repeats = _p_effMac->Repeats;
_idx = ExactIndex(_p_effMac->pWave->Length, _p_effMac->Duration);
}
Color StateMachine::tick(void) {
// tick-increment
if (--_prcValues.tick == 0) {
// repeats-decrement
if (_prcValues.repeats-- == 0) {
_p_effMac = &(*_p_effSeq)[_p_effMac->Next];
_prcValues.repeats = _p_effMac->Repeats;
}
_prcValues.tick = _p_effMac->Duration;
_idx = ExactIndex(_p_effMac->pWave->Length, _p_effMac->Duration);
}
++_idx;
StepProcessVars pv{
.pCurentColor = *_curentColor,
.ColorLen = _params.targetCount,
.IdleIntensity = _params.idleIntens,
.FullIntensity = _p_effMac->FsIntensity,
.DynamicRange = _params.dynamicRange,
.waveIdx = _idx.GetIdx(),
.pWave = _p_effMac->pWave,
};
return _p_effMac->pImplementation(pv);
}
Color StateMachine::UpdateBlank(StepProcessVars &pcsParam) {
return CBlack;
}
Color StateMachine::UpdateIdle(StepProcessVars &pcsParam) {
auto c = pcsParam.pCurentColor;
return c * pcsParam.IdleIntensity;
}
Color StateMachine::UpdateFreeze(StepProcessVars &pcsParam) {
return pcsParam.pCurentColor;
}
Color StateMachine::UpdateWave(StepProcessVars &pcsParam) {
Color temp = pcsParam.pCurentColor;
temp = temp * ((float)(pcsParam.pWave->pWave[pcsParam.waveIdx]) / 0xFF * pcsParam.FullIntensity);
return temp;
}
Color StateMachine::UpdateRevWave(StepProcessVars &pcsParam) {
unsigned lastIndex = pcsParam.pWave->Length - 1;
Color temp = pcsParam.pCurentColor;
temp = temp * ((float)(pcsParam.pWave->pWave[lastIndex - pcsParam.waveIdx]) / 0xFF *
pcsParam.FullIntensity);
return temp;
}
Color StateMachine::UpdateFlicker(StepProcessVars &pcsParam) {
uint8_t k = rand();
k = pcsParam.IdleIntensity + ((int16_t)k * (pcsParam.DynamicRange) / 0xFF);
auto c = pcsParam.pCurentColor;
c = c * ((float)(k));
return c;
}
} // namespace Effect
components/lightEffect/src/Waveforms.cpp
-100
View File
@@ -1,100 +0,0 @@
/**
* @file Waveforms.cpp
* @author Gustice
* @brief Implementation of defined Waveforms
* @version 0.6
* @date 2019-10-01
*
* @copyright Copyright (c) 2019
* @note The defined waveforms are generated with a the WaveformGenerator
*/
#include "Waveforms.hpp"
namespace Effect {
const uint16_t cu16_TemplateLength = 128;
const uint8_t gu8_idleIntensity = 0x55;
const uint8_t gu8_fullIntensity = 0xFF;
const uint8_t gu8_dynamicRange = gu8_fullIntensity - gu8_idleIntensity;
const uint8_t gu8_fadeSteps = 10;
// clang-format off
// Offset Pulse: Gaussian pulse from background illumination with full scale intensity
const uint8_t gau8_offsetPulse[cu16_TemplateLength * 2] = {
0x55, 0x55, 0x55, 0x56, 0x56, 0x56, 0x57, 0x57, 0x57, 0x58, 0x58, 0x59, 0x59, 0x5A, 0x5B, 0x5C,
0x5D, 0x5E, 0x5F, 0x61, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6F, 0x71, 0x74, 0x77, 0x7B, 0x7E,
0x81, 0x85, 0x89, 0x8E, 0x92, 0x97, 0x9B, 0xA0, 0xA5, 0xAA, 0xAF, 0xB5, 0xBA, 0xBF, 0xC4, 0xC9,
0xCF, 0xD3, 0xD8, 0xDD, 0xE1, 0xE6, 0xEA, 0xED, 0xF1, 0xF4, 0xF7, 0xF9, 0xFB, 0xFD, 0xFD, 0xFE,
0xFF, 0xFE, 0xFD, 0xFD, 0xFB, 0xF9, 0xF7, 0xF4, 0xF1, 0xED, 0xEA, 0xE6, 0xE1, 0xDD, 0xD8, 0xD3,
0xCF, 0xC9, 0xC4, 0xBF, 0xBA, 0xB5, 0xAF, 0xAA, 0xA5, 0xA0, 0x9B, 0x97, 0x92, 0x8E, 0x89, 0x85,
0x81, 0x7E, 0x7B, 0x77, 0x74, 0x71, 0x6F, 0x6C, 0x6A, 0x68, 0x66, 0x64, 0x62, 0x61, 0x5F, 0x5E,
0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x59, 0x58, 0x58, 0x57, 0x57, 0x57, 0x56, 0x56, 0x56, 0x55, 0x55,
0x55, 0x55, 0x55, 0x56, 0x56, 0x56, 0x57, 0x57, 0x57, 0x58, 0x58, 0x59, 0x59, 0x5A, 0x5B, 0x5C,
0x5D, 0x5E, 0x5F, 0x61, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6F, 0x71, 0x74, 0x77, 0x7B, 0x7E,
0x81, 0x85, 0x89, 0x8E, 0x92, 0x97, 0x9B, 0xA0, 0xA5, 0xAA, 0xAF, 0xB5, 0xBA, 0xBF, 0xC4, 0xC9,
0xCF, 0xD3, 0xD8, 0xDD, 0xE1, 0xE6, 0xEA, 0xED, 0xF1, 0xF4, 0xF7, 0xF9, 0xFB, 0xFD, 0xFD, 0xFE,
0xFF, 0xFE, 0xFD, 0xFD, 0xFB, 0xF9, 0xF7, 0xF4, 0xF1, 0xED, 0xEA, 0xE6, 0xE1, 0xDD, 0xD8, 0xD3,
0xCF, 0xC9, 0xC4, 0xBF, 0xBA, 0xB5, 0xAF, 0xAA, 0xA5, 0xA0, 0x9B, 0x97, 0x92, 0x8E, 0x89, 0x85,
0x81, 0x7E, 0x7B, 0x77, 0x74, 0x71, 0x6F, 0x6C, 0x6A, 0x68, 0x66, 0x64, 0x62, 0x61, 0x5F, 0x5E,
0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x59, 0x58, 0x58, 0x57, 0x57, 0x57, 0x56, 0x56, 0x56, 0x55, 0x55,
};
// Full Pulse: Gaussian pulse from dark to full scale intensity
const uint8_t gau8_fullPulse[cu16_TemplateLength * 2] = {
0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x0B,
0x0D, 0x0E, 0x10, 0x12, 0x14, 0x17, 0x1A, 0x1D, 0x20, 0x23, 0x27, 0x2B, 0x2F, 0x34, 0x39, 0x3E,
0x43, 0x49, 0x4F, 0x56, 0x5C, 0x63, 0x6A, 0x71, 0x79, 0x80, 0x88, 0x90, 0x98, 0x9F, 0xA7, 0xAF,
0xB7, 0xBE, 0xC5, 0xCC, 0xD3, 0xDA, 0xE0, 0xE5, 0xEA, 0xEF, 0xF3, 0xF6, 0xF9, 0xFC, 0xFD, 0xFE,
0xFF, 0xFE, 0xFD, 0xFC, 0xF9, 0xF6, 0xF3, 0xEF, 0xEA, 0xE5, 0xE0, 0xDA, 0xD3, 0xCC, 0xC5, 0xBE,
0xB7, 0xAF, 0xA7, 0x9F, 0x98, 0x90, 0x88, 0x80, 0x79, 0x71, 0x6A, 0x63, 0x5C, 0x56, 0x4F, 0x49,
0x43, 0x3E, 0x39, 0x34, 0x2F, 0x2B, 0x27, 0x23, 0x20, 0x1D, 0x1A, 0x17, 0x14, 0x12, 0x10, 0x0E,
0x0D, 0x0B, 0x0A, 0x08, 0x07, 0x06, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01,
0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x0B,
0x0D, 0x0E, 0x10, 0x12, 0x14, 0x17, 0x1A, 0x1D, 0x20, 0x23, 0x27, 0x2B, 0x2F, 0x34, 0x39, 0x3E,
0x43, 0x49, 0x4F, 0x56, 0x5C, 0x63, 0x6A, 0x71, 0x79, 0x80, 0x88, 0x90, 0x98, 0x9F, 0xA7, 0xAF,
0xB7, 0xBE, 0xC5, 0xCC, 0xD3, 0xDA, 0xE0, 0xE5, 0xEA, 0xEF, 0xF3, 0xF6, 0xF9, 0xFC, 0xFD, 0xFE,
0xFF, 0xFE, 0xFD, 0xFC, 0xF9, 0xF6, 0xF3, 0xEF, 0xEA, 0xE5, 0xE0, 0xDA, 0xD3, 0xCC, 0xC5, 0xBE,
0xB7, 0xAF, 0xA7, 0x9F, 0x98, 0x90, 0x88, 0x80, 0x79, 0x71, 0x6A, 0x63, 0x5C, 0x56, 0x4F, 0x49,
0x43, 0x3E, 0x39, 0x34, 0x2F, 0x2B, 0x27, 0x23, 0x20, 0x1D, 0x1A, 0x17, 0x14, 0x12, 0x10, 0x0E,
0x0D, 0x0B, 0x0A, 0x08, 0x07, 0x06, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01,
};
// Init Slope: Gaussian slope from dark to background brightness
const uint8_t gau8_initSlope[cu16_TemplateLength * 2] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04,
0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
0x12, 0x13, 0x14, 0x16, 0x17, 0x19, 0x1A, 0x1C, 0x1D, 0x1F, 0x21, 0x22, 0x24, 0x26, 0x27, 0x29,
0x2B, 0x2D, 0x2E, 0x30, 0x32, 0x33, 0x35, 0x37, 0x38, 0x3A, 0x3B, 0x3D, 0x3E, 0x40, 0x41, 0x42,
0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4C, 0x4D, 0x4E, 0x4E, 0x4F, 0x4F, 0x50,
0x50, 0x51, 0x51, 0x52, 0x52, 0x52, 0x52, 0x53, 0x53, 0x53, 0x53, 0x53, 0x54, 0x54, 0x54, 0x54,
0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x55,
};
// Offset Pulse: Gaussian slope from background illumination to full scale brightness
const uint8_t gau8_offsetSlope[cu16_TemplateLength] = {
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x56, 0x56, 0x56, 0x56, 0x57, 0x57, 0x57, 0x58, 0x58, 0x59, 0x59, 0x5A, 0x5A, 0x5B, 0x5C, 0x5D,
0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x65, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76,
0x79, 0x7B, 0x7E, 0x81, 0x84, 0x87, 0x8A, 0x8D, 0x90, 0x93, 0x97, 0x9A, 0x9D, 0xA1, 0xA4, 0xA8,
0xAB, 0xAF, 0xB2, 0xB6, 0xB9, 0xBC, 0xC0, 0xC3, 0xC6, 0xC9, 0xCC, 0xCF, 0xD2, 0xD5, 0xD8, 0xDA,
0xDD, 0xDF, 0xE1, 0xE3, 0xE5, 0xE7, 0xE9, 0xEB, 0xED, 0xEE, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
0xF6, 0xF7, 0xF8, 0xF9, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFD,
0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF,
};
// Full Slope: Gaussian slope from dark to full scale brightness
const uint8_t gau8_fullSlope[cu16_TemplateLength] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0C,
0x0D, 0x0F, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1D, 0x1F, 0x22, 0x25, 0x28, 0x2B, 0x2F, 0x32,
0x36, 0x3A, 0x3E, 0x42, 0x46, 0x4B, 0x50, 0x54, 0x59, 0x5E, 0x63, 0x68, 0x6D, 0x72, 0x77, 0x7C,
0x82, 0x87, 0x8C, 0x91, 0x96, 0x9B, 0xA0, 0xA5, 0xAA, 0xAE, 0xB3, 0xB8, 0xBC, 0xC0, 0xC4, 0xC8,
0xCC, 0xCF, 0xD3, 0xD6, 0xD9, 0xDC, 0xDF, 0xE1, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE, 0xEF, 0xF1,
0xF2, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFD, 0xFD,
0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF,
};
}// clang-format on
components/lightEffect/test/CMakeLists.txt
-5
View File
@@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES cmock utils
)
components/lightEffect/test/testUtils.cpp
-15
View File
@@ -1,15 +0,0 @@
/**
* @file testUtils.cpp
* @author Gustice
* @brief Hardware bound unit-tests
*
* @copyright Copyright (c) 2024
*/
#include "testable.h"
#include "unity.h"
#include <limits.h>
TEST_CASE("No relevant test case", "[utils]") {
TEST_ASSERT_EQUAL(0, 0);
}
components/lightEffect/uTest/CMakeLists.txt
-1
View File
@@ -1 +0,0 @@
unitTestsFrame()
components/lightEffect/uTest/utilsTest.cpp
-59
View File
@@ -1,59 +0,0 @@
/**
* @file TestableUTest.cpp
* @author Gustice
* @brief
*
* @copyright Copyright (c) 2024
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "utils.hpp"
#include "doctest/doctest.h"
#include <iostream>
namespace SingleActiveTests {
class Foo : public SingleActive<Foo> {
public:
int test{};
Foo() : SingleActive() {}
};
template <>
bool Foo::SingleActive<Foo>::active{};
class Bar : public SingleActive<Bar> {
public:
int test{};
Bar() : SingleActive() {}
};
template <>
bool Bar::SingleActive<Bar>::active{};
TEST_CASE("Sweet path") {
{ // first instances
Foo dut;
} // destruction
{ // second instances
Foo dut;
} // destruction
{ // third instance
Foo dut1;
Bar dut2; // First instance of second class
} // destruction
CHECK(true);
}
TEST_CASE("Too many instances") {
{
Foo dut1;
Foo *pDut2;
CHECK_THROWS_WITH(pDut2 = new Foo, "Instance already active");
}
CHECK(true);
}
}
components/lighting/CMakeLists.txt
-9
View File
@@ -1,9 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
REQUIRES freeRtosApi
project_bases
esp_common
esp_driver_gpio
esp_driver_i2c
)
components/lighting/include/i2cPort.hpp
-50
View File
@@ -1,50 +0,0 @@
/**
* @file i2cPort.hpp
* @author Gustice
* @brief C++ Wrapper for I2C-interface
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "portBase.hpp"
#include <vector>
/**
* @brief I2C-Master Class
* @details More recent implementation of IDF-based I2C master
*/
class I2cMaster : public PortBase {
public:
class Slave {
public:
enum ClockRate {
_100k = 100000,
_400k = 400000,
};
Slave(I2cMaster &interface, uint8_t addr, ClockRate rate = _100k);
~Slave();
bool writeTo(const std::vector<uint8_t> &data);
std::vector<uint8_t> readFrom(const std::vector<uint8_t> &address, unsigned size);
protected:
const uint8_t Addr;
I2cMaster &Interface;
i2c_master_dev_handle_t _devHandle;
};
I2cMaster(i2c_port_t port, gpio_num_t sda, gpio_num_t scl);
~I2cMaster() = default;
bool probe(uint8_t addr);
const i2c_port_t Port;
private:
friend class Slave;
i2c_master_bus_handle_t _busHandle;
};
components/lighting/include/pwmExpanderPca9685.hpp
-39
View File
@@ -1,39 +0,0 @@
/**
* @file pwmExpanderPca9685.hpp
* @author Gustice
* @brief PWM-Expander PCA9685
* @details https://www.nxp.com/docs/en/data-sheet/PCA9685.pdf
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "i2cPort.hpp"
#include <array>
#include <memory>
#include <optional>
/**
* @brief I2C-Connected LED-Driver with 16 ports
* @note This module can also be used to generate Servo-Motor signals
*/
class PmwExpanderPca9685 {
public:
static constexpr int PwmChannels = 16;
using GrayValues = std::array<uint16_t, PwmChannels>;
PmwExpanderPca9685(I2cMaster &port, bool inverted = false, uint8_t address = 0x40); // 0x40 default Address
void sendImage(GrayValues &grayValues);
void reset();
void setPwmFreq(float frequency, bool inverted);
private:
I2cMaster::Slave _port;
const uint8_t _address;
const size_t _count = 16;
// 16 LED-Channels with 4 bytes each + 4 byte overhead
std::vector<uint8_t> _data;
bool write(uint8_t reg, uint8_t data);
std::optional<uint8_t> read(uint8_t reg);
};
components/lighting/src/i2cPort.cpp
-74
View File
@@ -1,74 +0,0 @@
/**
* @file i2cPort.cpp
* @author Gustice
* @brief C++ Wrapper for I2C-interface
*
* @copyright Copyright (c) 2020
*/
#include "i2cPort.hpp"
#include "esp_log.h"
const int TxBufDisabled = 0; /*!< I2C master doesn't need buffer */
const int RxBufDisabled = 0; /*!< I2C master doesn't need buffer */
constexpr int I2C_TOOL_TIMEOUT_VALUE_MS = 50;
#define ACK_CHECK_EN 0x1 /*!< I2C master will check ack from slave*/
#define ACK_CHECK_DIS 0x0 /*!< I2C master will not check ack from slave */
I2cMaster::I2cMaster(i2c_port_t port, gpio_num_t sda, gpio_num_t scl) : Port(port) {
i2c_master_bus_config_t i2c_bus_config{
.i2c_port = port,
.sda_io_num = sda,
.scl_io_num = scl,
.clk_source = I2C_CLK_SRC_DEFAULT,
.glitch_ignore_cnt = 7,
};
i2c_bus_config.flags.enable_internal_pullup = 1;
ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_config, &_busHandle));
}
bool I2cMaster::probe(uint8_t addr) {
esp_err_t ret = i2c_master_probe(_busHandle, addr, I2C_TOOL_TIMEOUT_VALUE_MS);
return ret == ESP_OK;
}
I2cMaster::Slave::Slave(I2cMaster &interface, uint8_t addr, ClockRate rate) : Addr(addr), Interface(interface) {
i2c_device_config_t i2c_dev_conf{
.device_address = addr,
.scl_speed_hz = rate,
};
ESP_ERROR_CHECK(i2c_master_bus_add_device(interface._busHandle, &i2c_dev_conf, &_devHandle));
}
I2cMaster::Slave::~Slave() {
i2c_master_bus_rm_device(_devHandle);
}
bool I2cMaster::Slave::writeTo(const std::vector<uint8_t> &data) {
esp_err_t ret = i2c_master_transmit(_devHandle, data.data(), data.size(), I2C_TOOL_TIMEOUT_VALUE_MS);
if (ret != ESP_OK) {
if (ret == ESP_ERR_TIMEOUT) {
ESP_LOGW("I2C", "Bus is busy");
}
return false;
}
return true;
}
std::vector<uint8_t> I2cMaster::Slave::readFrom(const std::vector<uint8_t> &address, unsigned size) {
if (size == 0) {
return {};
}
std::vector<uint8_t> buffer(size);
esp_err_t ret = i2c_master_transmit_receive(_devHandle, address.data(), address.size(), buffer.data(), buffer.size(), I2C_TOOL_TIMEOUT_VALUE_MS);
if (ret != ESP_OK) {
if (ret == ESP_ERR_TIMEOUT) {
ESP_LOGW("I2C", "Bus is busy");
}
return {};
}
return buffer;
}
constexpr int DisableBuffer = 0; /*!< I2C master doesn't need buffers */
components/lighting/src/pwmExpanderPca9685.cpp
-117
View File
@@ -1,117 +0,0 @@
/**
* @file pwmExpanderPca9685.cpp
* @author Gustice
* @brief PWM-Expander PCA9685
*
* @copyright Copyright (c) 2024
*/
#include "pwmExpanderPca9685.hpp"
#include "esp_log.h"
#include <cmath>
#include <unistd.h> // for usleepCommand
enum Pca9685Codes {
PCA9685_MODE1 = 0x00,
PCA9685_MODE2 = 0x01,
Led0_ON_L = 0x06,
Led0_ON_H = 0x07,
Led0_OFF_L = 0x08,
Led0_OFF_H = 0x09,
// Led1_...Led15
AllLedON_L = 0xFA,
AllLedON_H = 0xFB,
AllLedOFF_L = 0xFC,
AllLedOFF_H = 0xFD,
PCA9685_PRESCALE = 0xFE,
};
enum Pca9685_Mode1Bits {
Mode1_Sleep = 0x10,
Mode1_AutoIncrement = 0x20,
Mode1_Restart = 0x80,
};
enum Pca9685_Mode2Bits {
Mode2_Invert = 0x10,
Mode2_OutDriver = 0x04,
};
constexpr int LedPortRegisterWidth = 2 * 2;
constexpr int BitResolution = 12;
constexpr int PwmMaxValue = 4096 - 1;
PmwExpanderPca9685::PmwExpanderPca9685(I2cMaster &port, bool inverted, uint8_t address)
: _port(port, address, I2cMaster::Slave::_400k), _address(address & 0x7F) {
_data.resize(PwmChannels * LedPortRegisterWidth + 1);
reset();
setPwmFreq(400, inverted);
}
void PmwExpanderPca9685::reset(void) {
uint8_t mode = Mode1_Restart | Mode1_AutoIncrement;
write(PCA9685_MODE1, mode);
usleep(10000); // 10 ms
}
void PmwExpanderPca9685::setPwmFreq(float frequency, bool inverted) {
frequency *= 0.9f; // Correct for overshoot in the frequency setting (see issue #11).
float prescaleLevel = 25000000;
prescaleLevel /= PwmMaxValue;
prescaleLevel /= frequency;
prescaleLevel -= 1;
uint8_t prescale = (uint8_t)std::floor(prescaleLevel + 0.5f);
uint8_t oldMode = read(PCA9685_MODE1).value_or(0);
uint8_t newMode = (oldMode & 0x7F) | Mode1_Sleep; // sleep + Autoincrement
write(PCA9685_MODE1, newMode); // go to sleep
write(PCA9685_PRESCALE, prescale); // set the prescaler
write(PCA9685_MODE1, oldMode);
if (inverted) {
write(PCA9685_MODE2, Mode2_OutDriver | Mode2_Invert);
} else {
write(PCA9685_MODE2, Mode2_OutDriver);
}
usleep(5000); // 5 ms
// This sets the MODE1 register to turn on auto increment.
write(PCA9685_MODE1, oldMode | Mode1_Restart | Mode1_AutoIncrement);
}
void PmwExpanderPca9685::sendImage(GrayValues &grayValues) {
// Try to distribute load peaks over full duty cycle
// OUT1 ..###______###____###______###____###__..
// OUT2 ..__###______###____###______###____###..
// OUT3 ..____###______###______###____###_____..
// ...
int idx = 0;
int step = UINT16_MAX / 4 / PwmChannels; // max 90 deg phase shift
int curStep = step;
_data[idx++] = Led0_ON_L;
for (size_t i = 0; i < _count; i++) {
curStep = curStep + step;
uint16_t dur = (grayValues[i] + curStep) >> 4;
uint on = curStep >> 4;
// On-Cnt
_data[idx++] = (uint8_t)on;
_data[idx++] = (uint8_t)(on >> 8);
// Off-Cnt
_data[idx++] = (uint8_t)dur;
_data[idx++] = (uint8_t)(dur >> 8);
}
_port.writeTo(_data);
}
bool PmwExpanderPca9685::write(uint8_t reg, uint8_t word) {
std::vector<uint8_t> data{reg, word};
return _port.writeTo(data);
}
std::optional<uint8_t> PmwExpanderPca9685::read(uint8_t reg) {
auto value = _port.readFrom({reg}, 1);
if (value.size() == 0) {
return std::nullopt;
}
return {value.front()};
}
components/movement/CMakeLists.txt
-11
View File
@@ -1,11 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
REQUIRES freeRtosApi
project_bases
board_io
esp_common
esp_driver_gpio
esp_driver_ledc
esp_driver_gptimer
)
components/movement/include/StepperDrv8833.hpp
-43
View File
@@ -1,43 +0,0 @@
/**
* @file StepperDrv8833.hpp
* @author Gustice
* @brief Software-driver for Stepper driver DRV8833
* @details https://www.ti.com/lit/ds/symlink/drv8833.pdf?ts=1726872460958&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252Fde-de%252FDRV8833
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "stepperDrv.hpp"
#include <array>
#include <vector>
class StepperDriverDrv8833 : public StepperDriver {
public:
struct Pins {
ledc_timer_t timer;
std::array<ledc_channel_t, 4> channels;
std::array<gpio_num_t, 4> pins;
};
StepperDriverDrv8833(Pins pins, int resolution, float fullscale);
StepCplx fullStep(int8_t cnt) override;
StepCplx step(int8_t cnt) override;
StepCplx setPos(uint8_t pos) override;
uint8_t getSubPos() {
return _position;
}
private:
PwmPort _pwmA1;
PwmPort _pwmA2;
PwmPort _pwmB1;
PwmPort _pwmB2;
std::vector<uint8_t> _outA1;
std::vector<uint8_t> _outA2;
std::vector<uint8_t> _outB1;
std::vector<uint8_t> _outB2;
void setOutput(uint8_t pos) override;
const uint16_t FullScale;
};
components/movement/include/gpTimer.hpp
-82
View File
@@ -1,82 +0,0 @@
/**
* @file gpTimer.hpp
* @author Gustice
* @brief ESP-hardware-timer class
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "driver/gptimer.h"
#include "esp_attr.h"
#include "esp_log.h"
#include "portBase.hpp"
/**
* @brief Base class for tasks
*/
class HwTimerBase : public PortBase {
public:
enum Mode {
OneShot = 0,
Periodic
};
void setup(int thresh, Mode mode);
void start();
void stop();
protected:
gptimer_handle_t gpTimer{};
HwTimerBase(gptimer_alarm_cb_t callback);
~HwTimerBase();
};
/**
* @brief Simple Timer without callback
*/
class HwTimer : public HwTimerBase {
public:
using CallSignature = bool (*)(HwTimer &);
HwTimer(CallSignature call)
: HwTimerBase(CallFrame), _call{call} {
}
private:
CallSignature _call;
static bool IRAM_ATTR CallFrame(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *_this) {
auto &tmr = *reinterpret_cast<HwTimer *>(_this);
return tmr._call(tmr);
}
};
/**
* @brief Timer with callback parameter
* @tparam T Type of task parameter on call
*/
template <typename T>
class HwTimerT : public HwTimerBase {
using CallSignatureT = bool (*)(HwTimerT<T> &, T);
public:
HwTimerT(CallSignatureT call, const T &param)
: HwTimerBase(CallFrame), _param(call, param) {
}
private:
template <typename TS>
struct Param {
CallSignatureT call;
const TS &arg;
};
static bool IRAM_ATTR CallFrame(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *_this) {
auto &tmr = *reinterpret_cast<HwTimerT *>(_this);
auto &param = tmr._param;
return param.call(tmr, param.arg);
}
Param<T> _param;
};
components/movement/include/profileGenerator.hpp
-333
View File
@@ -1,333 +0,0 @@
#pragma once
#include "esp_log.h"
#include "stepperConfig.hpp"
#include <Task.hpp>
#include <cmath>
#include <functional>
#include <vector>
class ProfileBuffer {
public:
static constexpr int SliceSize = 128;
static constexpr int BufferSize = 16;
using Segment = std::array<uint8_t, SliceSize>;
using Buffer = std::array<Segment, BufferSize>;
ProfileBuffer() : _semaphore(BufferSize) {}
void reset() {
_idxReader = 0;
_idxWriter = 0;
_written = 0;
_read = 0;
_minDiff = BufferSize;
_idxProcess = _scratchpad.size() - 1;
_writeFinished = false;
}
void append(Segment set, bool isFinal = false) {
// _semaphore.give();
_writeFinished = isFinal;
_scratchpad.at(_idxWriter) = set;
_idxWriter++;
if (_idxWriter >= _scratchpad.size()) {
_idxWriter = 0;
}
_written++;
_minDiff = std::min(_minDiff, _written - _read);
}
const Segment *get() {
// _semaphore.take();
_idxProcess = _idxReader;
_idxReader++;
if (_idxReader >= _scratchpad.size()) {
_idxReader = 0;
}
_read++;
_minDiff = std::min(_minDiff, _written - _read);
return &_scratchpad[_idxProcess];
}
bool reachedFinal() {
return _writeFinished && (_read == _written);
}
bool canWrite() {
return _idxWriter != _idxProcess;
}
bool canStart() {
return (_written > (BufferSize / 2));
}
uint32_t getStats() {
return _minDiff;
}
uint32_t getDiff() {
return _written - _read;
}
uint32_t getRead() {
return _read;
}
private:
Buffer _scratchpad{};
fos::Semaphore _semaphore;
uint32_t _idxReader{};
uint32_t _idxWriter{};
uint32_t _written{};
uint32_t _read{};
uint32_t _minDiff{BufferSize};
uint32_t _idxProcess = _scratchpad.size() - 1;
bool _writeFinished{};
};
class ProfileGenerator {
public:
enum Profile {
Smooth = 0,
BuildUp,
RapidStart,
JumpIn,
};
ProfileGenerator(StepperConfig &config, ProfileBuffer &buffer, float dT)
: _config(config), _transformer(config, buffer), _dT(dT), _aMax(1), _wMax(1) {
}
void setDynamic(float a, float w) {
_aMax = a;
_wMax = w;
}
void createProfile(Profile profile, float delta) {
init();
switch (profile) {
default:
case Profile::Smooth:
createSmoothStep(delta);
break;
case Profile::BuildUp:
createBuildUpStep(delta);
break;
case Profile::RapidStart:
createRapidStartSwingInEnd(delta);
break;
case Profile::JumpIn:
createJumpInTarget(delta);
break;
}
_transformer.finish();
}
private:
struct Point {
float p;
float w;
float t;
};
class Transformer {
public:
Transformer(StepperConfig &config, ProfileBuffer &profile)
: _config(config), _profile(profile) {
add(0);
}
void add(float p) {
auto f = p / stp;
f = f - std::floor(f);
_last = (uint8_t)(f * _config.resolution);
_temp[_idx] = _last;
_idx++;
if (_idx >= _temp.size()) {
awaitCanWrite();
_profile.append(_temp);
ESP_LOGD("Profile", "add slice, canStart %d", _profile.canStart());
_idx = 0;
}
}
void finish() {
while (_idx < _temp.size()) {
_temp[_idx] = _last;
_idx++;
}
awaitCanWrite();
_profile.append(_temp, true);
ESP_LOGD("Profile", "add final slice");
_idx = 0;
}
void awaitCanWrite() {
while (!_profile.canWrite()) {
fos::Task::delayMs(200);
ESP_LOGD("Profile", "waiting... diff=%lu read=%lu canStart %d",
_profile.getDiff(), _profile.getRead(), _profile.canStart());
}
}
private:
StepperConfig &_config;
ProfileBuffer &_profile;
const float stp = _config.stepRad * 4;
const float res = stp / _config.resolution;
ProfileBuffer::Segment _temp{};
uint32_t _idx{};
uint8_t _last;
};
StepperConfig &_config;
Transformer _transformer;
float _dT;
float _aMax;
float _wMax;
float _t;
// std::vector<float> _pVec;
// std::vector<float> _wVec;
// std::vector<float> _tVec;
float _pBack;
float _wBack;
float _tBack;
void createSmoothStep(float delta) {
// already solved in simple step
smoothSubStep(delta, _aMax, _wMax);
}
void createBuildUpStep(float delta) {
// t0..t1: increasing swing
buildUpSwing(_aMax / 4, _wMax, 3);
auto pnt = getStopDistance(_aMax, _wMax);
// t1..t2: movement to until almost destination
moveUntil(_wMax, delta - pnt.p);
// t2..r3: deceleration until destination
accelUntil(-_aMax, _wMax, [](Point pnt) { return pnt.w < 0; });
}
void createRapidStartSwingInEnd(float delta) {
auto wMax = _wMax;
// t0..t1: acceleration to max velocity
accelUntil(_aMax * 2, 0, [wMax](Point pnt) { return pnt.w > (wMax * 2); });
// t1..r2: deceleration until moving speed
accelUntil(-_aMax, _wMax * 2, [wMax](Point pnt) { return pnt.w < wMax; });
// t2..t3: movement to until destination (override)
moveUntil(_wMax, delta);
// t3..t4: deceleration
accelUntil(-_aMax, _wMax, [](Point pnt) { return pnt.w < 0; });
float pCen = delta + (_pBack - delta) / 2;
accelUntil(-_aMax, 0, [pCen](Point pnt) { return pnt.p < pCen; });
accelUntil(_aMax, _wBack, [](Point pnt) { return pnt.w > 0; });
}
void createJumpInTarget(float delta) {
float jumpInRange = std::numbers::pi / 3;
float deltaPre = delta - jumpInRange;
smoothSubStep(deltaPre, _aMax, _wMax);
std::vector<float> jumpInSteps{jumpInRange / 2, jumpInRange / 3, jumpInRange / 6};
float nextPoint = deltaPre;
for (auto &&step : jumpInSteps) {
nextPoint = nextPoint + step;
smoothSubStep(nextPoint, _aMax * 10, _wMax * 2);
}
}
void init() {
_pBack = 0;
_wBack = 0;
_tBack = 0;
_t = 0;
}
void append(Point pnt) {
// _pVec.push_back(pnt.p);
// _wVec.push_back(pnt.w);
// _tVec.push_back(pnt.t);
_pBack = pnt.p;
_wBack = pnt.w;
_transformer.add(pnt.p);
}
void finish() {
}
Point getStopDistance(float a, float w) {
float tDec = w / a;
float pDec = a * std::pow(tDec, 2) / 2;
return {pDec, w, tDec};
}
void accelUntil(float a, float wInit, std::function<bool(Point)> checkCbk) {
float t{};
auto pX = _pBack;
while (true) {
float w = wInit + a * t;
float p = pX + wInit * t + a * std::pow(t, 2) / 2;
if (checkCbk(Point{p, w, t})) {
break;
}
append(Point{p, w, _t + t});
t = t + _dT;
}
_t = _t + t;
}
void moveUntil(float wM, float pEnd) {
float t{};
auto pX = _pBack;
while (true) {
float p = pX + wM * t;
if (p > pEnd) {
break;
}
append(Point{p, wM, _t + t});
t = t + _dT;
}
_t = _t + t;
}
void buildUpSwing(float a, float vM, int swings) {
float t{};
auto pX = _pBack;
float TwMax = vM / a;
float tau = 2 * std::numbers::pi;
float sTau = swings * tau;
while (true) {
t = t + _dT;
float env = a * t;
float p = std::sin(sTau * t / TwMax) * env * TwMax / sTau;
float w = (p - _pBack) / _dT;
if (w > _wMax) {
break;
}
append(Point{p, w, _t + t});
}
_t = _t + t;
}
void smoothSubStep(float delta, float aM, float wM) {
auto pnt = getStopDistance(aM, wM);
if (pnt.p < delta / 2) {
// t0..t1: acceleration to max velocity
accelUntil(aM, 0, [wM](Point pnt) { return pnt.w > wM; });
// t1..t2: movement to until almost destination
moveUntil(wM, delta - pnt.p);
// t2..r3: deceleration until destination
accelUntil(-aM, wM, [](Point pnt) { return pnt.w < 0; });
} else {
float pCen = delta + (_pBack - delta) / 2;
// t0..t1: acceleration until center is reached
accelUntil(-aM, 0, [pCen](Point pnt) { return pnt.p < pCen; });
// t2..r3: deceleration until destination
accelUntil(-aM, wM, [](Point pnt) { return pnt.w < 0; });
}
}
};
components/movement/include/pwmPort.hpp
-34
View File
@@ -1,34 +0,0 @@
/**
* @file pwmPort.hpp
* @author Gustice
* @brief C++ Wrapper for PWM-output
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "driver/gpio.h"
#include "driver/ledc.h"
#include "portBase.hpp"
#include <cstdint>
/**
* @brief PWM-Class
* @details Provides Write to PWM-Port
*/
class PwmPort : public PortBase {
public:
PwmPort(ledc_timer_t timer, ledc_channel_t channel, gpio_num_t output, ledc_timer_bit_t resolution, uint32_t frequency);
~PwmPort() = default;
void write(float duty);
void writeRaw(uint16_t duty);
protected:
const uint32_t FullScale;
const ledc_timer_t _timer;
const ledc_channel_t _channel;
const gpio_num_t _port;
private:
};
components/movement/include/stepperConfig.hpp
-19
View File
@@ -1,19 +0,0 @@
#pragma once
#include <cmath>
#include <numbers>
struct StepperConfig {
StepperConfig(float stepDeg, int microsteps)
: step(stepDeg), resolution(microsteps), resolutionQuad(resolution / 4) {}
/// @brief Step-size in degree (e.g. 1.8 deg)
float step;
/// @brief Step-size in radiant (e.g. 1.8 deg)
float stepRad{(float)(std::numbers::pi * step / 180)};
/// @brief Number of microsteps for four steps
int resolution;
/// @brief Number of microsteps for four steps
int resolutionQuad;
/// @brief Number of Steps for full revolution
int steps{std::lround(360.0F / step)};
};
components/movement/include/stepperDrv.hpp
-36
View File
@@ -1,36 +0,0 @@
/**
* @file stepperDrv.hpp
* @author Gustice
* @brief Abstraction for Stepper driver
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "gpioPort.hpp"
#include "pwmPort.hpp"
#include <array>
#include <vector>
class StepperDriver {
public:
struct StepCplx {
int8_t increment{};
uint8_t subPos{};
};
StepperDriver(int resolution)
: Resolution(resolution), Quad(Resolution / 4) {}
virtual StepCplx fullStep(int8_t cnt) = 0;
virtual StepCplx step(int8_t cnt) = 0;
virtual StepCplx setPos(uint8_t pos) = 0;
uint8_t getSubPos() {
return _position;
}
protected:
const uint8_t Resolution;
const uint8_t Quad;
int8_t _position{};
virtual void setOutput(uint8_t pos) = 0;
};
components/movement/include/stepperMotor.hpp
-305
View File
@@ -1,305 +0,0 @@
/**
* @file stepperMotor.hpp
* @author Gustice
* @brief Stepper Motor device class
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "Semaphore.hpp"
#include "gpTimer.hpp"
#include "gpioPort.hpp"
#include "profileGenerator.hpp"
#include "stepperConfig.hpp"
#include "stepperDrv.hpp"
#include <Task.hpp>
#include <cmath>
#include <memory>
class StepperMotor {
enum Mode {
Idle = 0,
HomingFromSensor, // if home sensor already active
HomingToSensorBegin,
HomingToSensorEnd,
Homing,
Run,
CrawlToEnd,
StartNew,
};
public:
template <int MAX, int PREC>
struct Position {
uint16_t position{};
uint16_t subPos{};
Position &operator+(Position &lhs) {
auto v1 = getFixPoint();
auto v2 = lhs.getFixPoint();
auto v = v1 + v2;
if (v > (MAX << 16)) {
v -= (MAX << 16);
}
position = getPosition(v);
subPos = getSubPos(v);
return *this;
}
Position &operator-(Position &lhs) {
auto v1 = getFixPoint();
auto v2 = lhs.getFixPoint();
auto v = v1 - v2;
if (v < (MAX << 16)) {
v += (MAX << 16);
}
position = getPosition(v);
subPos = getSubPos(v);
return *this;
}
Position &operator+(StepperDriver::StepCplx &pos) {
position += pos.increment;
if (position > MAX) {
position -= MAX;
} else if (position < 0) {
position += MAX;
} else {
// nothing to do here
}
subPos += pos.subPos;
return *this;
}
Position &halv() {
auto v1 = getFixPoint();
auto v = v1 / 2;
position = getPosition(v);
subPos = getSubPos(v);
return *this;
}
float getScaled() {
auto scaled = (float)position / MAX;
// scaled += (float)subPos / (1 << PREC);
return scaled;
}
private:
int32_t getFixPoint() {
int32_t value = (((int32_t)position) << 16) | (subPos << (16 - PREC));
return value;
}
uint16_t getPosition(int32_t value) {
auto pos = (value >> 16) & 0xFFFF;
return pos;
}
uint16_t getSubPos(int32_t value) {
auto pos = ((value & 0xFFFF) >> (16 - PREC));
return pos;
}
};
StepperMotor(StepperConfig &config, StepperDriver &driver, InputPort &initSensor)
: _config(config), _driver(driver), _initSensor(initSensor),
_timer(TimerCallParam, *this),
_buffer{},
_generator(_config, _buffer, 0.001F) {
_timer.setup(1'000, HwTimerBase::Mode::Periodic);
_timer.start();
}
~StepperMotor() {};
void findRef() {
ESP_LOGI("Stepper", "Homing ...");
// if (_initSensor.read()) {
// _mode = Mode::HomingFromSensor;
// ESP_LOGI("Stepper", "First leave HomePos");
// } else {
// _mode = Mode::HomingToSensorBegin;
// ESP_LOGI("Stepper", "Find start of HomePos");
// }
// while (_mode != Mode::Idle) {
// fos::Task::delayTicks(1);
// }
int fullStep = _config.resolution / 4;
_driver.setPos(0);
if (_initSensor.read()) {
ESP_LOGI("Stepper", "Need to move away from home");
// MoveAway
while (_initSensor.read()) {
(void)_driver.step(-fullStep);
fos::Task::delayTicks(1);
}
for (size_t i = 0; i < 8; i++) // Drive another 4 Steps away
{
(void)_driver.step(-fullStep);
fos::Task::delayTicks(1);
}
}
ESP_LOGI("Stepper", "Fast find right side of home sensor");
// Find right Endpoint
while (not _initSensor.read()) {
(void)_driver.step(fullStep);
fos::Task::delayTicks(1);
}
while (_initSensor.read()) { // move away
(void)_driver.step(-fullStep);
fos::Task::delayTicks(1);
}
ESP_LOGI("Stepper", "Find right side of home sensor");
while (not _initSensor.read()) {
(void)_driver.step(1);
fos::Task::delayTicks(1);
}
int pos{};
resetPosition();
ESP_LOGI("Stepper", "Find end of sensor");
while (_initSensor.read()) {
(void)_driver.step(1);
pos++;
fos::Task::delayTicks(1);
}
for (size_t i = 0; i < 32; i++) // Drive another 4 Steps away
{
(void)_driver.step(1);
pos++;
fos::Task::delayTicks(1);
}
ESP_LOGI("Stepper", "Find left side of home sensor");
while (not _initSensor.read()) {
(void)_driver.step(-1);
pos--;
fos::Task::delayTicks(1);
}
ESP_LOGI("Stepper", "Move back to mid position %d", pos / 2);
for (size_t i = 0; i < pos / 2; i++) {
(void)_driver.step(-1);
fos::Task::delayTicks(1);
}
ESP_LOGI("Stepper", "Reset position");
resetPosition();
}
void demoFullTurn() {
ESP_LOGI("Stepper", "Running %i * %i steps for full turn", _config.resolution, _config.steps);
ESP_LOGI("Stepper", "Start is %f.2", getScaledPos());
for (size_t i = 0; i < _config.resolutionQuad * _config.steps; i++) {
auto delta = _driver.step(1);
_indexPos = _indexPos + delta;
fos::Task::delayTicks(1);
}
ESP_LOGI("Stepper", "End is %f.2", getScaledPos());
}
void createDemoProfile();
void moveBy(float angle);
void moveBy(float angle, uint8_t profile, float accel, float speed);
void newProfile() {
_subStep = 0;
_mode = StartNew;
}
bool isIdle() {
return _mode == Mode::Idle;
}
float getScaledPos() {
return _indexPos.getScaled();
}
void resetPosition() {
_indexPos = Position<50, 5>();
}
private:
StepperConfig &_config;
StepperDriver &_driver;
InputPort &_initSensor;
HwTimerT<StepperMotor &> _timer;
Mode _mode{};
ProfileBuffer _buffer;
ProfileGenerator _generator;
int32_t _subStep;
const ProfileBuffer::Segment *_pSlice{};
Position<50, 5> _indexPos{};
static bool TimerCallParam(HwTimerT<StepperMotor &> &, StepperMotor &stepper) {
switch (stepper._mode) {
case Mode::HomingFromSensor: {
if (stepper._initSensor.read() == false) {
stepper._mode = HomingToSensorBegin;
break;
}
(void)stepper._driver.step(1);
} break;
case Mode::HomingToSensorBegin: {
if (stepper._initSensor.read()) {
stepper._mode = HomingToSensorEnd;
stepper._indexPos = {0, stepper._driver.getSubPos()};
break;
}
(void)stepper._driver.step(1);
} break;
case Mode::HomingToSensorEnd: {
if (stepper._initSensor.read() == false) {
stepper._mode = Homing;
stepper._indexPos = stepper._indexPos.halv();
break;
}
auto delta = stepper._driver.step(1);
stepper._indexPos = stepper._indexPos + delta;
} break;
case Mode::Homing: {
if (stepper._indexPos.position == 0) {
stepper._mode = Idle;
break;
}
auto delta = stepper._driver.step(-1);
stepper._indexPos = stepper._indexPos + delta;
} break;
case Mode::Run: {
auto stp = stepper._pSlice->at(stepper._subStep);
stepper._subStep++;
if (stepper._subStep >= stepper._pSlice->size()) {
stepper._subStep = 0;
if (stepper._buffer.reachedFinal()) {
stepper._mode = Idle;
} else {
stepper._pSlice = stepper._buffer.get();
}
}
auto delta = stepper._driver.setPos(stp);
stepper._indexPos = stepper._indexPos + delta;
} break;
case Mode::StartNew: {
if (stepper._buffer.canStart()) {
stepper._mode = Run;
stepper._pSlice = stepper._buffer.get();
stepper._subStep = 0;
}
}
case Mode::Idle:
default:
break;
}
return true;
}
};
components/movement/src/gpTimer.cpp
-64
View File
@@ -1,64 +0,0 @@
/**
* @file gpTimer.cpp
* @author Gustice
* @brief HW-Timer class implementation
*
* @copyright Copyright (c) 2024
*/
#include "gpTimer.hpp"
#include "esp_log.h"
HwTimerBase::HwTimerBase(gptimer_alarm_cb_t callback) {
ESP_LOGI("TMR", "Create timer handle");
gptimer_config_t timer_config = {
.clk_src = GPTIMER_CLK_SRC_DEFAULT,
.direction = GPTIMER_COUNT_UP,
.resolution_hz = 1000000, // 1MHz, 1 tick=1us
};
ESP_ERROR_CHECK(gptimer_new_timer(&timer_config, &gpTimer));
gptimer_event_callbacks_t cbs = {
.on_alarm = callback,
};
ESP_ERROR_CHECK(gptimer_register_event_callbacks(gpTimer, &cbs, this));
}
void HwTimerBase::setup(int thresh, Mode mode) {
ESP_LOGI("TMR", "Setup timer");
ESP_ERROR_CHECK(gptimer_enable(gpTimer));
gptimer_alarm_config_t cfg{};
switch (mode) {
case Mode::OneShot:
cfg.alarm_count = thresh;
break;
case Mode::Periodic:
cfg.reload_count = 0,
cfg.alarm_count = thresh;
cfg.flags.auto_reload_on_alarm = true;
break;
default:
ESP_LOGE("TMR", "Invalid mode %d", mode);
break;
}
ESP_ERROR_CHECK(gptimer_set_alarm_action(gpTimer, &cfg));
}
void HwTimerBase::start() {
ESP_ERROR_CHECK(gptimer_start(gpTimer));
}
void HwTimerBase::stop() {
ESP_LOGI("TMR", "Stop timer");
ESP_ERROR_CHECK(gptimer_stop(gpTimer));
}
HwTimerBase::~HwTimerBase() {
stop();
ESP_LOGI("TMR", "Disable timer");
ESP_ERROR_CHECK(gptimer_disable(gpTimer));
ESP_LOGI("TMR", "Delete timer");
ESP_ERROR_CHECK(gptimer_del_timer(gpTimer));
}
components/movement/src/pwmPort.cpp
-48
View File
@@ -1,48 +0,0 @@
/**
* @file pwmPort.cpp
* @author Gustice
* @brief C++ Wrapper for PWM-output
*
* @copyright Copyright (c) 2024
*/
#include "pwmPort.hpp"
#include "esp_log.h"
#include "esp_system.h"
#include <cassert>
#include <cmath>
PwmPort::PwmPort(ledc_timer_t timer, ledc_channel_t channel, gpio_num_t output, ledc_timer_bit_t resolution, uint32_t frequency)
: FullScale((1 << resolution)), _timer(timer), _channel(channel), _port(output) {
ledc_timer_config_t ledc_timer = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = resolution,
.timer_num = timer,
.freq_hz = frequency,
.clk_cfg = LEDC_AUTO_CLK
};
ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
// Prepare and then apply the LEDC PWM channel configuration
ledc_channel_config_t ledc_channel = {
.gpio_num = output,
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = channel,
.intr_type = LEDC_INTR_DISABLE,
.timer_sel = timer,
.duty = 0,
.hpoint = 0,
};
ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));
}
void PwmPort::write(float duty) {
// duty <= 1.0F;
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, _channel, duty * FullScale));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, _channel));
}
void PwmPort::writeRaw(uint16_t duty) {
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, _channel, duty));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, _channel));
}
components/movement/src/stepperDrv8833.cpp
-141
View File
@@ -1,141 +0,0 @@
/**
* @file stepperDrv8833.cpp
* @author Gustice
* @brief Software-driver for Stepper driver DRV8833
*
* @copyright Copyright (c) 2024
*/
#include "stepperDrv8833.hpp"
#include "esp_log.h"
#include <climits>
#include <cmath>
void populateLookUps(int resolution,
std::vector<uint8_t> &a1, std::vector<uint8_t> &a2,
std::vector<uint8_t> &b1, std::vector<uint8_t> &b2,
uint16_t fullscale)
{
float step = 2.0F * std::numbers::pi / resolution;
const uint16_t Maximum = 1 << LEDC_TIMER_7_BIT;
for (size_t i = 0; i < resolution; i++) {
auto cos = std::cos(step * i);
if (cos > 0)
{
// 1 : 0 = Forward
// 1 : PWM = Forward PWM, slow decay
a1.push_back(Maximum);
a2.push_back(Maximum - (cos * fullscale));
} else {
// 0 : 1 = Reverse
// PWM : 1 = Reverse PWM, slow decay
a1.push_back(Maximum - (-cos * fullscale));
a2.push_back(Maximum);
}
auto sin = std::sin(step * i);
if (sin > 0)
{
// 1 : 0 = Forward
// 1 : PWM = Forward PWM, slow decay
b1.push_back(Maximum);
b2.push_back(Maximum - (sin * fullscale));
} else {
// 0 : 1 = Reverse
// PWM : 1 = Reverse PWM, slow decay
b1.push_back(Maximum - ((-sin * fullscale)));
b2.push_back(Maximum);
}
};
}
StepperDriverDrv8833::StepperDriverDrv8833(Pins pins, int resolution, float fullscale)
: StepperDriver(resolution),
_pwmA1(pins.timer, pins.channels[0], pins.pins[0], LEDC_TIMER_7_BIT, 20000),
_pwmA2(pins.timer, pins.channels[1], pins.pins[1], LEDC_TIMER_7_BIT, 20000),
_pwmB1(pins.timer, pins.channels[2], pins.pins[2], LEDC_TIMER_7_BIT, 20000),
_pwmB2(pins.timer, pins.channels[3], pins.pins[3], LEDC_TIMER_7_BIT, 20000),
FullScale((1 << LEDC_TIMER_7_BIT) * std::max(0.0F, std::min(1.0F, fullscale)))
{
if ((Resolution % 4) != 0) {
ESP_LOGE("Stepper", "Resolution must be multiple of 4");
}
populateLookUps(resolution, _outA1, _outA2, _outB1, _outB2, FullScale);
ESP_LOGD("Stepper", "Output Data:");
ESP_LOG_BUFFER_HEXDUMP("Stepper", _outA1.data(), _outA1.size(), ESP_LOG_DEBUG);
ESP_LOG_BUFFER_HEXDUMP("Stepper", _outA2.data(), _outA2.size(), ESP_LOG_DEBUG);
ESP_LOG_BUFFER_HEXDUMP("Stepper", _outB1.data(), _outB1.size(), ESP_LOG_DEBUG);
ESP_LOG_BUFFER_HEXDUMP("Stepper", _outB2.data(), _outB2.size(), ESP_LOG_DEBUG);
step(0);
}
StepperDriverDrv8833::StepCplx StepperDriverDrv8833::fullStep(int8_t cnt) {
if (cnt > 0) {
cnt = 1;
} else {
cnt = -1;
}
int pos = (_position / Quad + cnt) % 4;
pos = pos * Quad;
return setPos(pos);
}
StepperDriverDrv8833::StepCplx StepperDriverDrv8833::step(int8_t cnt) {
if (cnt == 0) {
return {0, (uint8_t)_position};
}
if (cnt > Resolution) {
// ESP_LOGE("Stepper", "microstep exceeds four steps");
}
if (cnt > Quad) {
// ESP_LOGW("Stepper", "microstep exceeds quadrature step");
}
int8_t increment{};
auto pos = _position + cnt;
if (pos < 0) {
increment--;
pos += Resolution;
} else if (pos >= Resolution) {
increment++;
pos -= Resolution;
} else {
// in that case ... nothing
}
setOutput(pos);
return {increment, (uint8_t)_position};
}
StepperDriverDrv8833::StepCplx StepperDriverDrv8833::setPos(uint8_t pos) {
pos = (pos) % Resolution;
int8_t increment{};
if (pos - _position < 0) {
increment--;
} else if (pos - _position > Resolution) {
increment++;
} else {
// in that case ... nothing
}
setOutput(pos);
return {increment, (uint8_t)_position};
}
void StepperDriverDrv8833::setOutput(uint8_t pos) {
if (pos >= Resolution) {
// ESP_LOGE("Stepper", "d exceeds micro-stepping size");
}
_position = pos;
_pwmA1.writeRaw(_outA1[pos]);
_pwmA2.writeRaw(_outA2[pos]);
_pwmB1.writeRaw(_outB1[pos]);
_pwmB2.writeRaw(_outB2[pos]);
}
components/movement/src/stepperMotor.cpp
-42
View File
@@ -1,42 +0,0 @@
/**
* @brief stepperMotor.cpp
* @author Gustice
* @brief Stepper Motor device class
*
* @copyright Copyright (c) 2024
*/
#include "stepperMotor.hpp"
#include "esp_log.h"
#include <cmath>
#include <functional>
#include <vector>
void StepperMotor::moveBy(float angle) {
_buffer.reset();
newProfile();
_generator.createProfile(ProfileGenerator::Profile::Smooth, angle);
// ESP_LOGD("Stepper", "TookTicks for %d data points", profile.steps.size());
// ESP_LOG_BUFFER_HEXDUMP("Stepper", profile.steps.data(), profile.steps.size(), ESP_LOG_DEBUG);
}
void StepperMotor::moveBy(float angle, uint8_t idx, float accel, float speed) {
// long start = xTaskGetTickCount();
ESP_LOGI("Stepper", "Running %.1f with prof=%i a=%.2f w=%.2f",
angle * 3 / std::numbers::pi, idx, accel, speed);
_buffer.reset();
newProfile();
_generator.setDynamic(accel, speed);
_generator.createProfile(static_cast<ProfileGenerator::Profile>(idx), angle);
while (!isIdle())
{
fos::Task::delayMs(200);
}
ESP_LOGI("Profile", "processing finished ...");
// long ticks = xTaskGetTickCount() - start;
// ESP_LOGD("Stepper", "TookTicks %lu ( %lu ms) for %d data points", ticks, ticks * portTICK_PERIOD_MS, profile.steps.size());
// ESP_LOG_BUFFER_HEXDUMP("Stepper", profile.steps.data(), profile.steps.size(), ESP_LOG_DEBUG);
}
components/nvsUtils/CMakeLists.txt
-5
View File
@@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
REQUIRES project_bases nvs_flash esp_common
)
components/nvsUtils/include/nvsFunctions.hpp
-38
View File
@@ -1,38 +0,0 @@
/**
* @file nvsFunctions.hpp
* @author Gustice
* @brief NVS-Diagnosis utility
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <string>
class NvsApi {
public:
/// @brief Init and mount file system
/// @param mount rooted SubType of partition eg "nvs"
static void init(std::string mount = std::string{"nvs"});
/// @brief Get instance, ensure initialization
/// @param mount rooted SubType of partition eg "nvs"
/// @return Instance reference
static NvsApi &getInstance(std::string mount = std::string{"nvs"});
void setValue(const std::string &key, const std::string &value);
std::string getValue(const std::string &key);
// Disable move and assignment
NvsApi(NvsApi &other) = delete;
void operator=(const NvsApi &) = delete;
protected:
NvsApi(std::string mount);
~NvsApi();
private:
static NvsApi *_instance;
const std::string _mountingPoint;
};
components/nvsUtils/src/nvsDefines.hpp
-41
View File
@@ -1,41 +0,0 @@
/**
* @file nvsDefines.hpp
* @author Gustice
* @brief Defines and record types
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "nvs.h"
#include <array>
#include <map>
#include <string>
#include <tuple>
static std::tuple<
std::map<nvs_type_t, const char *>,
std::map<std::string, nvs_type_t>>
CreateNvsDictionaries() {
std::array<std::pair<nvs_type_t, const char *>, 11> defines{
{{NVS_TYPE_I8, "i8"},
{NVS_TYPE_U8, "u8"},
{NVS_TYPE_U16, "u16"},
{NVS_TYPE_I16, "i16"},
{NVS_TYPE_U32, "u32"},
{NVS_TYPE_I32, "i32"},
{NVS_TYPE_U64, "u64"},
{NVS_TYPE_I64, "i64"},
{NVS_TYPE_STR, "str"},
{NVS_TYPE_BLOB, "blob"},
{NVS_TYPE_ANY, "any"}}};
std::map<nvs_type_t, const char *> k2s;
std::map<std::string, nvs_type_t> s2k;
for (auto &&e : defines) {
k2s.emplace(e.first, e.second);
s2k.emplace(e.second, e.first);
}
return {k2s, s2k};
}
components/nvsUtils/src/nvsFunctions.cpp
-316
View File
@@ -1,316 +0,0 @@
/**
* @file cmd_nvs.cpp
* @author Gustice
* @brief NVS-Diagnosis utility (derived from ESP-IDF Console-Example)
*
* @copyright Copyright (c) 2024
*/
#include "nvsFunctions.hpp"
#include "esp_err.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "nvs.h"
#include "nvsIo.hpp"
#include "nvs_flash.h"
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "nvsDefines.hpp"
static void initializeNvs() {
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// 1.OTA app partition table has a smaller NVS partition size than the non-OTA
// partition table. This size mismatch may cause NVS initialization to fail.
// 2.NVS partition contains data in new format and cannot be recognized by this version of code.
// If this happens, we erase NVS partition and initialize NVS again.
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
}
NvsApi *NvsApi::_instance = nullptr;
NvsApi::NvsApi(std::string mount) : _mountingPoint(mount) {
initializeNvs();
}
NvsApi::~NvsApi() {
}
NvsApi &NvsApi::getInstance(std::string mount) {
if (_instance == nullptr) {
init(mount);
}
return *_instance;
}
void NvsApi::init(std::string mount) {
if (_instance != nullptr) {
return;
}
_instance = new NvsApi(mount);
}
const auto [TypeStrMap, StrTypeMap] = CreateNvsDictionaries();
static char activeNameSpace[16] = "storage";
static const char *TAG = "NVS";
static nvs_type_t confStr2Type(const char *type) {
if (auto search = StrTypeMap.find(type); search != StrTypeMap.end()) {
return search->second;
}
ESP_LOGW(TAG, "type '%s' not found", type);
return NVS_TYPE_ANY;
}
static const char *confType2Str(nvs_type_t type) {
if (auto search = TypeStrMap.find(type); search != TypeStrMap.end()) {
return search->second;
}
ESP_LOGW(TAG, "type %d not found", type);
return "Unknown";
}
struct SetArgs {
struct arg_str *key;
struct arg_str *type;
struct arg_str *value;
struct arg_end *end;
};
struct GetArgs {
struct arg_str *key;
struct arg_str *type;
struct arg_end *end;
};
struct EraseArgs {
struct arg_str *key;
struct arg_end *end;
};
struct EraseNameSpaceArgs {
struct arg_str *nameSpace;
struct arg_end *end;
};
struct NameSpaceArgs {
struct arg_str *nameSpace;
struct arg_end *end;
};
struct ListArgs {
struct arg_str *partition;
struct arg_str *nameSpace;
struct arg_str *type;
struct arg_end *end;
};
static esp_err_t setValueInNvs(const char *key, const char *strType, const char *strValue) {
nvs_type_t type = confStr2Type(strType);
if (type == NVS_TYPE_ANY) {
ESP_LOGE(TAG, "Type '%s' is undefined", strType);
return ESP_ERR_NVS_TYPE_MISMATCH;
}
try {
NvsIo nvs(activeNameSpace, NVS_READWRITE);
esp_err_t err = ESP_FAIL;
if (type == NVS_TYPE_I8) {
err = nvs.setValueByStr<int8_t>(key, strValue);
} else if (type == NVS_TYPE_U8) {
err = nvs.setValueByStr<uint8_t>(key, strValue);
} else if (type == NVS_TYPE_I16) {
err = nvs.setValueByStr<int16_t>(key, strValue);
} else if (type == NVS_TYPE_U16) {
err = nvs.setValueByStr<uint16_t>(key, strValue);
} else if (type == NVS_TYPE_I32) {
err = nvs.setValueByStr<int32_t>(key, strValue);
} else if (type == NVS_TYPE_U32) {
err = nvs.setValueByStr<uint32_t>(key, strValue);
} else if (type == NVS_TYPE_I64) {
err = nvs.setValueByStr<int64_t>(key, strValue);
} else if (type == NVS_TYPE_U64) {
err = nvs.setValueByStr<uint64_t>(key, strValue);
} else if (type == NVS_TYPE_STR) {
err = nvs.setString(key, strValue);
} else if (type == NVS_TYPE_BLOB) {
err = nvs.setBlob(key, strValue);
}
if (err != ESP_OK) {
return err;
}
err = nvs.commit();
if (err == ESP_OK) {
ESP_LOGI(TAG, "Value stored under key '%s'", key);
}
return ESP_OK;
} catch (const std::exception &e) {
ESP_LOGE(TAG, "%s", e.what());
}
return ESP_FAIL;
}
void NvsApi::setValue(const std::string &key, const std::string &value) {
if (setValueInNvs(key.c_str(), "str", value.c_str()) != ESP_OK) {
ESP_LOGE(TAG, "setValue failed");
}
}
std::string NvsApi::getValue(const std::string &key) {
try {
NvsIo nvs(activeNameSpace, NVS_READONLY);
auto opt = nvs.getString(key.c_str());
auto value = opt.value();
return value;
} catch (const std::bad_optional_access &e) {
ESP_LOGE(TAG, "Value '%s' not defined", key.c_str());
} catch (const std::exception &e) {
ESP_LOGE(TAG, "%s", e.what());
}
return "";
}
static esp_err_t showValueFromNvs(const char *key, const char *strType) {
nvs_type_t type = confStr2Type(strType);
if (type == NVS_TYPE_ANY) {
ESP_LOGE(TAG, "Type '%s' is undefined", strType);
return ESP_ERR_NVS_TYPE_MISMATCH;
}
try {
NvsIo nvs(activeNameSpace, NVS_READONLY);
if (type == NVS_TYPE_I8) {
auto opt = nvs.getInt8(key);
printf("%d\n", opt.value());
} else if (type == NVS_TYPE_U8) {
auto opt = nvs.getUint8(key);
printf("%u\n", opt.value());
} else if (type == NVS_TYPE_I16) {
auto opt = nvs.getInt16(key);
printf("%u\n", opt.value());
} else if (type == NVS_TYPE_U16) {
auto opt = nvs.getUint16(key);
printf("%u\n", opt.value());
} else if (type == NVS_TYPE_I32) {
auto opt = nvs.getInt32(key);
printf("%" PRIi32 "\n", opt.value());
} else if (type == NVS_TYPE_U32) {
auto opt = nvs.getUint32(key);
printf("%" PRIu32 "\n", opt.value());
} else if (type == NVS_TYPE_I64) {
auto opt = nvs.getInt64(key);
printf("%lld\n", opt.value());
} else if (type == NVS_TYPE_U64) {
auto opt = nvs.getUint64(key);
printf("%llu\n", opt.value());
} else if (type == NVS_TYPE_STR) {
auto opt = nvs.getString(key);
printf("%s\n", opt.value().c_str());
} else if (type == NVS_TYPE_BLOB) {
auto opt = nvs.getBlob(key);
auto value = opt.value();
for (int i = 0; i < value.size(); i++) {
printf("%02x", value[i]);
}
printf("\n");
}
return ESP_OK;
} catch (const std::bad_optional_access &e) {
ESP_LOGE(TAG, "%s", "Value not defined");
} catch (const std::exception &e) {
ESP_LOGE(TAG, "%s", e.what());
}
return ESP_FAIL;
}
static esp_err_t erase(const char *key) {
try {
NvsIo nvs(activeNameSpace, NVS_READWRITE);
esp_err_t err = nvs.erase(key);
if (err != ESP_OK) {
return err;
}
err = nvs.commit();
if (err != ESP_OK) {
return err;
}
ESP_LOGI(TAG, "Value with key '%s' erased", key);
return ESP_OK;
} catch (const std::exception &e) {
ESP_LOGE(TAG, "%s", e.what());
}
return ESP_FAIL;
}
static esp_err_t eraseAllIn(const char *name) {
try {
NvsIo nvs(name, NVS_READWRITE);
esp_err_t err = nvs.clear();
if (err != ESP_OK) {
return err;
}
err = nvs.commit();
if (err != ESP_OK) {
return err;
}
ESP_LOGI(TAG, "Namespace '%s' was %s erased", name, (err == ESP_OK) ? "" : "not");
return ESP_OK;
} catch (const std::exception &e) {
ESP_LOGE(TAG, "%s", e.what());
}
return ESP_FAIL;
}
static int list(const char *part, const char *name, const char *strType) {
nvs_type_t type = confStr2Type(strType);
nvs_iterator_t it = NULL;
esp_err_t result = nvs_entry_find(part, NULL, type, &it);
if (result == ESP_ERR_NVS_NOT_FOUND) {
ESP_LOGE(TAG, "No such entry was found");
return 1;
}
if (result != ESP_OK) {
ESP_LOGE(TAG, "NVS error: %s", esp_err_to_name(result));
return 1;
}
do {
nvs_entry_info_t info;
nvs_entry_info(it, &info);
result = nvs_entry_next(&it);
if ((strlen(name) > 0) && (strcmp(info.namespace_name, name) != 0)) {
continue;
}
printf("namespace '%s', key '%s', type '%s' \n",
info.namespace_name, info.key, confType2Str(info.type));
} while (result == ESP_OK);
if (result != ESP_ERR_NVS_NOT_FOUND) { // the last iteration ran into an internal error
ESP_LOGE(TAG, "NVS error %s at current iteration, stopping.", esp_err_to_name(result));
return 1;
}
return 0;
}
components/nvsUtils/src/nvsIo.cpp
-167
View File
@@ -1,167 +0,0 @@
/**
* @file nvsIo.cpp
* @author Gustice
* @brief Read-Write access to specific NVS partition
*
* @copyright Copyright (c) 2024
*/
#include "nvsIo.hpp"
#include "esp_err.h"
#include "esp_log.h"
#include <cstring>
#include <memory>
static const char *TAG = "NVS";
static esp_err_t storeBlob(nvs_handle_t nvs, const char *key, const char *str_values) {
uint8_t value;
size_t str_len = strlen(str_values);
size_t blob_len = str_len / 2;
if (str_len % 2) {
ESP_LOGE(TAG, "Blob data must contain even number of characters");
return ESP_ERR_NVS_TYPE_MISMATCH;
}
char *blob = (char *)malloc(blob_len);
if (blob == NULL) {
return ESP_ERR_NO_MEM;
}
for (int i = 0, j = 0; i < str_len; i++) {
char ch = str_values[i];
if (ch >= '0' && ch <= '9') {
value = ch - '0';
} else if (ch >= 'A' && ch <= 'F') {
value = ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'f') {
value = ch - 'a' + 10;
} else {
ESP_LOGE(TAG, "Blob data contain invalid character");
free(blob);
return ESP_ERR_NVS_TYPE_MISMATCH;
}
if (i & 1) {
blob[j++] += value;
} else {
blob[j] = value << 4;
}
}
esp_err_t err = nvs_set_blob(nvs, key, blob, blob_len);
free(blob);
if (err == ESP_OK) {
err = nvs_commit(nvs);
}
return err;
}
template <>
esp_err_t NvsIo::setValueByStr<int8_t>(const char *key, const char *strValue) {
int32_t value = strtol(strValue, NULL, 0);
if (value < INT8_MIN || value > INT8_MAX || errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setInt8(key, (int8_t)value);
}
template <>
esp_err_t NvsIo::setValueByStr<uint8_t>(const char *key, const char *strValue) {
uint32_t value = strtoul(strValue, NULL, 0);
if (value > UINT8_MAX || errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setUint8(key, (uint8_t)value);
}
template <>
esp_err_t NvsIo::setValueByStr<int16_t>(const char *key, const char *strValue) {
int32_t value = strtol(strValue, NULL, 0);
if (value < INT16_MIN || value > INT16_MAX || errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setInt16(key, (int16_t)value);
}
template <>
esp_err_t NvsIo::setValueByStr<uint16_t>(const char *key, const char *strValue) {
uint32_t value = strtoul(strValue, NULL, 0);
if (value > UINT16_MAX || errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setUint16(key, (uint16_t)value);
}
template <>
esp_err_t NvsIo::setValueByStr<int32_t>(const char *key, const char *strValue) {
int32_t value = strtol(strValue, NULL, 0);
if (errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setInt32(key, value);
}
template <>
esp_err_t NvsIo::setValueByStr<uint32_t>(const char *key, const char *strValue) {
uint32_t value = strtoul(strValue, NULL, 0);
if (errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setUint32(key, value);
}
template <>
esp_err_t NvsIo::setValueByStr<int64_t>(const char *key, const char *strValue) {
int64_t value = strtoll(strValue, NULL, 0);
if (errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setInt64(key, value);
}
template <>
esp_err_t NvsIo::setValueByStr<uint64_t>(const char *key, const char *strValue) {
uint64_t value = strtoull(strValue, NULL, 0);
if (errno == ERANGE) {
throw CoreException(ErrMsg_TooLong);
}
return setUint64(key, value);
}
esp_err_t NvsIo::setString(const char *key, const char *strValue) {
return nvs_set_str(_nvs, key, strValue);
}
esp_err_t NvsIo::setBlob(const char *key, const char *strValue) {
return storeBlob(_nvs, key, strValue);
}
std::optional<std::string> NvsIo::getString(const char *key) {
size_t len;
if (nvs_get_str(_nvs, key, NULL, &len) != ESP_OK) {
return {std::nullopt};
}
auto str = std::make_unique<char[]>(len);
if ((nvs_get_str(_nvs, key, str.get(), &len)) != ESP_OK) {
return {std::nullopt};
}
return {str.get()};
}
std::optional<std::vector<char>> NvsIo::getBlob(const char *key) {
size_t len;
if (nvs_get_blob(_nvs, key, NULL, &len) != ESP_OK) {
return {std::nullopt};
}
auto blob = std::make_unique<char[]>(len);
if (nvs_get_blob(_nvs, key, blob.get(), &len) != ESP_OK) {
return {std::nullopt};
}
std::vector<char> vec;
vec.reserve(len);
vec.insert(vec.end(), blob.get(), blob.get() + len);
return {vec};
}
components/nvsUtils/src/nvsIo.hpp
-149
View File
@@ -1,149 +0,0 @@
/**
* @file nvsIo.hpp
* @author Gustice
* @brief Read-Write access to specific NVS partition
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "nvs.h"
#include "coreExcept.hpp"
#include <optional>
#include <string>
#include <vector>
class NvsIo {
const char *ErrMsg_TooLong = "Value is too long";
public:
NvsIo(const char *nameSpace, nvs_open_mode_t mode) {
if (nvs_open(nameSpace, mode, &_nvs) != ESP_OK) {
throw CoreException("Unable to open NVS");
}
}
~NvsIo() {
nvs_close(_nvs);
}
esp_err_t commit() {
return nvs_commit(_nvs);
}
template <typename T>
esp_err_t setValueByStr(const char *key, const char *strValue);
esp_err_t setInt8(const char *key, int8_t value) {
return nvs_set_i8(_nvs, key, value);
}
esp_err_t setUint8(const char *key, uint8_t value) {
return nvs_set_u8(_nvs, key, value);
}
esp_err_t setInt16(const char *key, int16_t value) {
return nvs_set_i16(_nvs, key, value);
}
esp_err_t setUint16(const char *key, uint16_t value) {
return nvs_set_u16(_nvs, key, value);
}
esp_err_t setInt32(const char *key, int32_t value) {
return nvs_set_i32(_nvs, key, value);
}
esp_err_t setUint32(const char *key, uint32_t value) {
return nvs_set_u32(_nvs, key, value);
}
esp_err_t setInt64(const char *key, int64_t value) {
return nvs_set_i64(_nvs, key, value);
}
esp_err_t setUint64(const char *key, uint64_t value) {
return nvs_set_u64(_nvs, key, value);
}
esp_err_t setString(const char *key, const char *strValue);
esp_err_t setBlob(const char *key, const char *strValue);
std::optional<int8_t> getInt8(const char *key) {
int8_t value;
if (nvs_get_i8(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<uint8_t> getUint8(const char *key) {
uint8_t value;
if (nvs_get_u8(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<int16_t> getInt16(const char *key) {
int16_t value;
if (nvs_get_i16(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<uint16_t> getUint16(const char *key) {
uint16_t value;
if (nvs_get_u16(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<int32_t> getInt32(const char *key) {
int32_t value;
if (nvs_get_i32(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<uint32_t> getUint32(const char *key) {
uint32_t value;
if (nvs_get_u32(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<int64_t> getInt64(const char *key) {
int64_t value;
if (nvs_get_i64(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<uint64_t> getUint64(const char *key) {
uint64_t value;
if (nvs_get_u64(_nvs, key, &value) != ESP_OK) {
return {std::nullopt};
}
return {value};
}
std::optional<std::string> getString(const char *key);
std::optional<std::vector<char>> getBlob(const char *key);
esp_err_t erase(const char *key) {
return nvs_erase_key(_nvs, key);
}
/// @brief Clear all entries in given namespace
esp_err_t clear() {
return nvs_erase_all(_nvs);
}
private:
nvs_handle_t _nvs;
};
template <>
esp_err_t NvsIo::setValueByStr<int8_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<uint8_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<int16_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<uint16_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<int32_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<uint32_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<int64_t>(const char *key, const char *strValue);
template <>
esp_err_t NvsIo::setValueByStr<uint64_t>(const char *key, const char *strValue);
components/project_bases/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include" "defines"
)
components/project_bases/include/constraints.hpp
-43
View File
@@ -1,43 +0,0 @@
/**
* @file utils.hpp
* @author Gustice
* @brief Template
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <cassert>
#include <exception>
#include <cstdint>
/**
* @brief Base for constructs that allow only one concurrently active instance
*
* @tparam T
* @note needs a `T * T::SingleActive<T>::active{};` definition in source
*/
template <typename T>
class SingleActive {
static bool active;
public:
/// @brief Constructor, memorizes if already on instance was successfully build
SingleActive() {
if (active) {
throw "Instance already active";
}
assert(active == false && "Constructor my only be run if no instance active");
active = true;
}
/// @brief Destructor, clears memory of existing instance
~SingleActive() {
assert(active == true && "Destructor my only be run on active instance");
active = false;
}
// Disable move and assignment
SingleActive(SingleActive &other) = delete;
void operator=(const SingleActive &) = delete;
};
components/project_bases/include/coreExcept.hpp
-25
View File
@@ -1,25 +0,0 @@
/**
* @file coreExcept.hpp
* @author Gustice
* @brief Template
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <exception>
/**
* @brief Simple exception
*/
class CoreException : public std::exception {
char const *Text;
public:
/// @brief Constructor with simple pointer to text
CoreException(char const *text) : Text(text) {
}
/// @brief error message getter
char const *what() const throw() override { return Text; }
};
components/project_bases/include/portBase.hpp
-15
View File
@@ -1,15 +0,0 @@
/**
* @file portBase.hpp
* @author Gustice
* @brief Base-class for all hardware ports
*
* @copyright Copyright (c) 2024
*/
#pragma once
class PortBase { // Forbid Copy and Move assignments
public:
PortBase(/* args */) {};
PortBase(const PortBase &other) = delete;
PortBase &operator=(const PortBase &other) = delete;
};
components/project_bases/include/simpleStreams.hpp
-80
View File
@@ -1,80 +0,0 @@
/**
* @file utils.hpp
* @author Gustice
* @brief Template
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include <cassert>
#include <exception>
#include <string>
#include <vector>
#include <cstdint>
/**
* @brief Common interface for character streams
*/
class CharStream {
public:
/// @brief Read method
/// @return string
virtual std::string read() = 0;
/// @brief Write character
/// @param c character to write
virtual void write(char c) = 0;
/// @brief Write string
/// @param str string to write
virtual void write(std::string str) = 0;
};
/**
* @brief Common interface
*/
class ByteStream {
/// @brief Read method
/// @return series of bytes
virtual std::vector<uint8_t> read() = 0;
/// @brief write single byte
/// @param b byte to write
virtual void write(uint8_t b) = 0;
/// @brief write series of bytes
/// @param data series to write
virtual void write(std::vector<uint8_t> data) = 0;
};
/**
* @brief Base for constructs that allow only one concurrently active instance
*
* @tparam T
* @note needs a `T * T::SingleActive<T>::active{};` definition in source
*/
template <typename T>
class SingleActive {
static bool active;
public:
/// @brief Constructor, memorizes if already on instance was successfully build
SingleActive() {
if (active) {
throw "Instance already active";
}
assert(active == false && "Constructor my only be run if no instance active");
active = true;
}
/// @brief Destructor, clears memory of existing instance
~SingleActive() {
assert(active == true && "Destructor my only be run on active instance");
active = false;
}
// Disable move and assignment
SingleActive(SingleActive &other) = delete;
void operator=(const SingleActive &) = delete;
};
components/project_bases/src/dummy.cpp
-9
View File
@@ -1,9 +0,0 @@
/**
* @file dummy.cpp
* @author Gustice
* @brief Silence toolchain
*
* @copyright Copyright (c) 2024
*/
#include "portBase.hpp"
components/sockets/CMakeLists.txt
-5
View File
@@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
REQUIRES esp_netif lwip project_bases freeRtosApi mqtt
)
components/sockets/include/etherCommon.hpp
-196
View File
@@ -1,196 +0,0 @@
/**
* @file etherCommon.hpp
* @author Gustice
* @brief Helper Functions for Ethernet usage
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "esp_log.h"
#include "esp_netif.h"
#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include <array>
#include <cstring>
#include <lwip/netdb.h>
#include <string>
#if defined(CONFIG_LWIP_NETBUF_RECVINFO)
constexpr bool NETBUF_RECVINFO = true;
#else
constexpr bool NETBUF_RECVINFO = false;
#endif
#if defined(CONFIG_EXAMPLE_IPV4)
constexpr bool USE_IPV4 = true;
#else
constexpr bool USE_IPV4 = false;
#endif
#if defined(CONFIG_EXAMPLE_IPV6)
constexpr bool USE_IPV6 = true;
#else
constexpr bool USE_IPV6 = false;
#endif
class Ip {
public:
Ip(uint32_t ipV4) {
_address.word = ipV4;
}
Ip(esp_ip4_addr_t ipV4) {
_address.word = ipV4.addr;
}
Ip(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) {
_address.bytes[0] = b0;
_address.bytes[1] = b1;
_address.bytes[2] = b2;
_address.bytes[3] = b3;
}
Ip(std::string ipStr) {
_address.word = ipaddr_addr(ipStr.c_str());
}
uint8_t operator[](int index) const { return _address.bytes[index]; };
uint32_t asWord() const { return _address.word; }
std::string asString() const { return inet_ntoa(_address.word); }
private:
union {
uint8_t bytes[4]; // IPv4 address
uint32_t word;
} _address;
};
class Mac {
public:
Mac(uint8_t val[NETIF_MAX_HWADDR_LEN]) {
std::memcpy(bytes.begin(), val, NETIF_MAX_HWADDR_LEN);
}
uint8_t operator[](int index) const {
return bytes[index];
};
std::string asString() const {
char buffer[64];
sprintf(buffer, "%02x:%02x:%02x:%02x:%02x:%02x", bytes[0], bytes[1],
bytes[2], bytes[3], bytes[4], bytes[5]);
return {buffer};
}
const std::array<uint8_t, NETIF_MAX_HWADDR_LEN> &asArray() const {
return bytes;
}
private:
std::array<uint8_t, NETIF_MAX_HWADDR_LEN> bytes; // IPv4 address
};
/**
* @brief IP-set class
*/
struct IpInfo {
/// @brief IP address
Ip address{0u};
/// @brief IP subnet
Ip subnet{0u};
/// @brief Gateway IP
Ip gateway{0u};
/// @brief MAC-Address
Mac macAddress;
/// @brief Get broadcast address from IP and subnet
/// @return
Ip getBradcastAddress() const {
auto sn = address.asWord() | ~subnet.asWord();
return Ip(sn);
}
};
struct IpAdr {
public:
IpAdr(std::string ipStr, uint16_t port);
IpAdr(uint32_t ip, uint16_t port);
IpAdr(uint16_t port);
IpAdr(sockaddr_in ipV4data);
static constexpr int IpProtocol = IPPROTO_IP; // IPPROTO_IPV6 for version 6
static constexpr int ProtocolFamily = AF_INET; // AF_INET6 for version 6
/// @brief StackFamily e.g. AF_INET or AF_INET6
sa_family_t getProtocolFamily() const { return addrStore.ss_family; }
std::string getIp() {
struct sockaddr_in *ipV4 = (struct sockaddr_in *)&addrStore;
return inet_ntoa(ipV4->sin_addr.s_addr);
}
uint16_t getPort() const {
struct sockaddr_in *ipV4 = (struct sockaddr_in *)&addrStore;
return ntohs(ipV4->sin_port);
};
struct sockaddr *asSockAddrPtr() const { return (struct sockaddr *)&addrStore; }
static constexpr int Size = sizeof(sockaddr_storage);
private:
struct sockaddr_storage addrStore;
};
struct IpAdrV6 {
public:
IpAdrV6(std::string ipStr, uint16_t port);
IpAdrV6(in6_addr ip, uint16_t port);
IpAdrV6(uint16_t port);
IpAdrV6(sockaddr_in6 ipV6data);
static constexpr int IpProtocol = IPPROTO_IPV6;
static constexpr int ProtocolFamily = AF_INET6;
/// @brief StackFamily e.g. AF_INET or AF_INET6
sa_family_t getProtocolFamily() const { return addrStore.ss_family; }
std::string getIp() {
struct sockaddr_in6 *ipV6 = (struct sockaddr_in6 *)&addrStore;
return inet6_ntoa(ipV6->sin6_addr);
}
uint16_t getPort() const {
struct sockaddr_in6 *ipV6 = (struct sockaddr_in6 *)&addrStore;
return ntohs(ipV6->sin6_port);
};
struct sockaddr *asSockAddrPtr() const { return (struct sockaddr *)&addrStore; }
static constexpr int Size = sizeof(sockaddr_storage);
private:
struct sockaddr_storage addrStore;
};
/**
* @brief Simplified abstraction for sockets
*/
class SocketBase {
public:
/// @brief Get if stream is active
/// @return true if active
virtual bool isActive() {
return active;
}
IpInfo getIpInfo() {
auto *netIf = esp_netif_get_default_netif();
esp_netif_ip_info_t ip;
uint8_t mac[NETIF_MAX_HWADDR_LEN];
ESP_ERROR_CHECK(esp_netif_get_ip_info(netIf, &ip));
ESP_ERROR_CHECK(esp_netif_get_mac(netIf, mac));
IpInfo ips{
.address = Ip{ip.ip},
.subnet = Ip(ip.netmask),
.gateway = Ip(ip.netmask),
.macAddress = Mac(mac)};
return ips;
}
protected:
bool active;
};
components/sockets/include/mqttClient.hpp
-65
View File
@@ -1,65 +0,0 @@
/**
* @file mqttClient.hpp
* @author Gustice
* @brief Wrapper class for TCP/IP based MQTT APIs
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "esp_event.h"
#include "esp_system.h"
#include "mqtt_client.h"
#include <functional>
#include <string>
#include <string_view>
/**
* @brief MqttClient wrapper (Singleton)
*/
class MqttClient {
public:
/// @brief Init and mount file system
/// @param broker URI to web MQTT broker server
static MqttClient &init(std::string broker, std::string prefix);
void addSubscription(std::string topic, std::function<void(std::string)> call);
void publish(std::string topic, std::string data);
void start();
bool isRunning() { return _state != State::Init; }
/// @brief Get instance, ensure initialization
/// @param broker URI to web MQTT broker server
/// @returnb
static MqttClient &getInstance();
// Disable move and assignment
MqttClient(MqttClient &other) = delete;
void operator=(const MqttClient &) = delete;
// protected:
MqttClient(std::string broker, std::string pefix);
~MqttClient();
private:
enum class State {
Init,
Started,
Disconnected,
Connected
};
struct Subscription {
std::string topic;
std::function<void(std::string)> callback;
bool active{};
int id{};
};
std::string _broker;
std::string _prefix;
State _state{};
static MqttClient *_instance;
esp_mqtt_client_handle_t _client;
std::vector<Subscription> _subscriptions;
static void eventHandler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
};
components/sockets/include/tcpSockets.hpp
-309
View File
@@ -1,309 +0,0 @@
/**
* @file tcpSockets.hpp
* @author Gustice
* @brief Function wrapper for ESP-IDF socket implementation
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "esp_log.h"
#include "etherCommon.hpp"
#include "coreExcept.hpp"
#include <functional>
#include <iostream>
#include <vector>
#include "simpleStreams.hpp"
/**
* @brief TCP-Socket wrapper for ESP-IDF socket implementation
*/
class TcpSocket {
public:
/// @brief Constructor
/// @note Socket not active until call of attach method
/// @param addr Server/Client address
TcpSocket(const IpAdr &addr)
: Local(addr) {
_listenSockId = socket(addr.ProtocolFamily, SOCK_STREAM, addr.IpProtocol);
if (_listenSockId < 0) {
ESP_LOGE("TCP", "Unable to create socket: errno %d", errno);
throw CoreException("Unable to create socket");
}
if (addr.ProtocolFamily == IPPROTO_IP) {
int opt = 1;
setsockopt(_listenSockId, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
}
if constexpr (USE_IPV4 && USE_IPV6) {
int opt = 1;
// Note that by default IPV6 binds to both protocols, it is must be disabled
// if both protocols used at the same time (used in CI)
setsockopt(_listenSockId, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));
}
ESP_LOGI("TCP", "Socket created");
}
/// @brief Destructor
~TcpSocket() {
close(_listenSockId);
}
/// @brief Attach to configured socket
/// @note Blocks until successful or failed
/// @return true if successful
bool bindTo() {
int err = bind(_listenSockId, Local.asSockAddrPtr(), sizeof(sockaddr_storage));
if (err != 0) {
ESP_LOGE("TCP", "Socket unable to bind: errno %d", errno);
ESP_LOGE("TCP", "IPPROTO: %d", Local.ProtocolFamily);
throw CoreException("Socket unable to bind");
}
ESP_LOGI("TCP", "Socket bound, port %d", Local.getPort());
err = listen(_listenSockId, 1);
if (err != 0) {
ESP_LOGE("TCP", "Error occurred during listen: errno %d", errno);
throw CoreException("Error occurred during listen");
}
return true;
}
/// @brief Get socket id for stream-operations
/// @return Id of socket
int getSocketId() {
return _listenSockId;
}
/// @brief Address of this station (server perspective)
const IpAdr &Local;
private:
int _listenSockId;
};
/**
* @brief TCP session
*/
class TcpSession : public SocketBase, public CharStream {
public:
/**
* @brief Configuration structure for Session
*/
struct Config {
int keepAlive;
int keepIdle;
int keepInterval;
int keepCount;
};
/// @brief Constructor
/// @note Constructor blocks
/// @param config Configuration for session
/// @param listener reference to socket
TcpSession(Config &config, TcpSocket &listener) : _other(IPADDR_ANY, 0) {
socklen_t addr_len = _other.Size;
_socket = accept(listener.getSocketId(), _other.asSockAddrPtr(), &addr_len);
if (_socket < 0) {
ESP_LOGE("TCP", "Unable to accept connection: errno %d", errno);
active = false;
throw CoreException("Unable to accept connection");
}
// Set tcp keepalive option
setsockopt(_socket, SOL_SOCKET, SO_KEEPALIVE, &config.keepAlive, sizeof(int));
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPIDLE, &config.keepIdle, sizeof(int));
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPINTVL, &config.keepInterval, sizeof(int));
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPCNT, &config.keepCount, sizeof(int));
std::string addrStr;
if (_other.ProtocolFamily == listener.Local.ProtocolFamily) {
if (_other.getProtocolFamily() == PF_INET) {
addrStr = _other.getIp();
// } else if (_other.addrStore.ss_family == PF_INET6) {
// inet6_ntoa_r(((struct sockaddr_in6 *)&_other.addrStore)->sin6_addr, addrStr, sizeof(addrStr) - 1);
} else {
throw CoreException("Unknown case");
}
} else {
ESP_LOGW("TCP", "Wrong IP-version request");
active = false;
}
ESP_LOGI("TCP", "Socket accepted ip address: %s", addrStr.c_str());
active = true;
}
/// @brief Destructor
~TcpSession() {
if (_socket < 0)
return;
ESP_LOGD("TCP", "Tearing down socket");
shutdown(_socket, 0);
}
/// @brief Get IP of remote
/// @return
IpAdr getSource() {
return _other;
}
/// @brief Read string
/// @note This call blocks until data is received
/// @return read string
std::string read() override {
auto data = readRaw();
if (data.size() == 0) {
return "";
}
std::string ret((const char *)&data.data()[0]);
return ret;
}
/// @brief Write character to socket
/// @param b character to write
void write(char c) override {
if (!isActive()) {
return;
}
int written = send(_socket, &c, 1, 0);
if (written < 0) {
ESP_LOGE("TCP", "Error occurred during sending: errno %d", errno);
}
}
/// @brief Write string to specific socket
/// @param message payload
/// @param dest Destination for message
void write(std::string message) override {
if (!isActive()) {
return;
}
int written = send(_socket, message.c_str(), message.size(), 0);
if (written < 0) {
ESP_LOGE("TCP", "Error occurred during sending: errno %d", errno);
}
}
IpAdr getOther() {
return _other;
}
protected:
int _socket = 0;
IpAdr _other;
std::vector<uint8_t> readRaw() {
uint8_t data[128];
int len = recv(_socket, data, sizeof(data) - 1, 0);
if (len < 0) {
ESP_LOGE("TCP", "Error occurred during receiving: errno %d", errno);
active = false;
return {};
}
data[len] = 0;
if (len == 0) {
ESP_LOGW("TCP", "Connection closed");
active = false;
return {};
}
ESP_LOGD("TCP", "Received %d bytes: %s", len, data);
std::vector<uint8_t> vec(data, data + len + 1);
return vec;
}
};
constexpr TcpSession::Config DefaultTcpConfig{
.keepAlive = 1,
.keepIdle = 5,
.keepInterval = 5,
.keepCount = 3,
};
constexpr uint16_t TelnetPort = 23;
/**
* @brief TCP-Socket for Telnet-Applications
*/
class TelnetServer {
/**
* @brief Specialization of TCP-Session for Telnet
*/
class TelnetSession : public TcpSession {
public:
// Constructor
TelnetSession(Config &config, TcpSocket &listener) : TcpSession(config, listener) {
}
/// @brief Read string
/// @note This call blocks until data is received
/// @return read string
std::string read() override {
auto data = readRaw();
if (data.size() == 0) {
return "";
}
data.pop_back(); // 0-termination is not needed here
int i = 0;
while (data[i] == 0xFF) { // while telnet command
i += 3; // skip this command
}
if (i == data.size()) { // only configuration
send(_socket, data.data(), data.size(), 0);
return "";
}
std::string ret((const char *)&data[i]);
return ret;
}
};
public:
/// @brief Constructor
/// @param addrFamily IPV4 or IPV6
TelnetServer(int addrFamily)
: Local(addrFamily == AF_INET ? IpAdr(INADDR_ANY, TelnetPort) : IpAdr(TelnetPort)),
Config(DefaultTcpConfig) {
}
/**
* @brief Start server
*
* @param initCall Callback for shell init
* @param cyclicCall Callback for cyclic polling
*/
void run(std::function<void(TcpSession &)> initCall, std::function<void(TcpSession &)> cyclicCall) {
TcpSocket socket(Local);
socket.bindTo();
while (true) {
// Run telnet-session as long socket is active else restart socket
ESP_LOGI("Telnet", "Socket waiting for connect");
TelnetSession session(Config, socket);
initCall(session);
while (session.isActive()) {
cyclicCall(session);
}
}
}
private:
IpAdr Local;
TcpSession::Config Config;
};
components/sockets/include/udpSockets.hpp
-309
View File
@@ -1,309 +0,0 @@
/**
* @file udpSockets.hpp
* @author Gustice
* @brief UDP-Socket wrapper for ESP-IDF socket implementation
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "Task.hpp"
#include "esp_log.h"
#include "etherCommon.hpp"
#include "coreExcept.hpp"
#include <cstdarg>
#include <iostream>
#include <string>
#include "simpleStreams.hpp"
constexpr bool UDP_WITH_TIMEOUT = false;
/**
* @brief UDP-Socket wrapper for ESP-IDF socket implementation
*/
class UdpSocket : public ByteStream, public SocketBase {
public:
/// @brief Constructor for UDP-Socket-Server
/// @note Socket not active until call of attach method
/// @param addr Server/Client address
UdpSocket(const IpAdr &addr)
: Local(addr), _other(INADDR_ANY, 0) {
_listenSockId = socket(addr.ProtocolFamily, SOCK_DGRAM, addr.IpProtocol);
if (_listenSockId < 0) {
ESP_LOGE("UDP", "Unable to create socket: errno %d", errno);
throw CoreException("Unable to create socket");
}
ESP_LOGD("UDP", "Socket created");
if constexpr (NETBUF_RECVINFO && !USE_IPV6) {
int enable = 1;
lwip_setsockopt(_listenSockId, IPPROTO_IP, IP_PKTINFO, &enable, sizeof(enable));
}
if constexpr (USE_IPV4 && USE_IPV6) {
if (addr.ProtocolFamily == AF_INET6) {
// Note that by default IPV6 binds to both protocols, it is must be disabled
// if both protocols used at the same time (used in CI)
int opt = 1;
setsockopt(_listenSockId, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
setsockopt(_listenSockId, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));
}
}
if constexpr (UDP_WITH_TIMEOUT) { // Set timeout if desired
struct timeval timeout {
.tv_sec = 10,
.tv_usec = 0,
};
setsockopt(_listenSockId, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
}
}
/// @brief Destructor
~UdpSocket() {
active = false;
ESP_LOGD("UDP", "Shutting down socket and restarting...");
shutdown(_listenSockId, 0);
close(_listenSockId);
}
/// @brief Attach to configured socket
/// @note Blocks until successful or failed
/// @return true if successful
bool bindTo() {
active = false;
int err = bind(_listenSockId, Local.asSockAddrPtr(), sizeof(sockaddr_storage));
if (err < 0) {
ESP_LOGE("UDP", "Socket unable to bind: errno %d", errno);
throw CoreException("Socket unable to bind");
}
ESP_LOGI("UDP", "Socket bound, port %d", Local.getPort());
if constexpr (NETBUF_RECVINFO && !USE_IPV6) {
_iov.iov_base = _rxBuffer;
_iov.iov_len = sizeof(_rxBuffer);
_msg.msg_control = _cmsg_buf;
_msg.msg_controllen = sizeof(_cmsg_buf);
_msg.msg_flags = 0;
_msg.msg_iov = &_iov;
_msg.msg_iovlen = 1;
_msg.msg_name = _other.asSockAddrPtr();
_msg.msg_namelen = _other.Size;
}
active = true;
return active;
}
/// @brief Read from socket
/// @note This call blocks until data is received
/// @return read bytes
std::vector<uint8_t> read() override {
char buffer[256];
int len = 0;
if constexpr (NETBUF_RECVINFO && !USE_IPV6) {
len = recvmsg(_listenSockId, &_msg, 0);
} else {
socklen_t socklen = _other.Size;
len = recvfrom(_listenSockId, buffer, sizeof(buffer) - 1, 0, _other.asSockAddrPtr(), &socklen);
}
if (len < 0) {
ESP_LOGE("UDP", "recvfrom failed: errno %d", errno);
return {};
}
std::string addrStr;
// Get the sender's ip address as string
if (Local.ProtocolFamily == PF_INET) {
addrStr = _other.getIp();
if constexpr (NETBUF_RECVINFO && !USE_IPV6) {
struct cmsghdr *cmsgtmp;
for (cmsgtmp = CMSG_FIRSTHDR(&_msg); cmsgtmp != NULL; cmsgtmp = CMSG_NXTHDR(&_msg, cmsgtmp)) {
if (cmsgtmp->cmsg_level == IPPROTO_IP && cmsgtmp->cmsg_type == IP_PKTINFO) {
struct in_pktinfo *pktinfo;
pktinfo = (struct in_pktinfo *)CMSG_DATA(cmsgtmp);
ESP_LOGI("UDP", "dest ip: %s", inet_ntoa(pktinfo->ipi_addr));
}
}
}
} // else if (Local.ProtocolFamily == PF_INET6) {
// inet6_ntoa_r(((struct sockaddr_in6 *)&_other.addrStore)->sin6_addr, addrStr, sizeof(addrStr) - 1);
// }
ESP_LOGD("UDP", "Received %d bytes from %s:", len, addrStr.c_str());
std::vector<uint8_t> ret(buffer, buffer + len);
return ret;
}
/// @brief Write character to socket
/// @param b character to write
void write(uint8_t b) override {}
/// @brief Write bytes to socket
/// @param data payload as series of bytes
void write(std::vector<uint8_t> data) override {
write(&data[0], data.size());
}
/// @brief Write string to specific socket
/// @param message payload
/// @param dest Destination for message
void write(std::string &message, IpAdr *dest = nullptr) {
auto data = message.c_str();
write((uint8_t *)data, message.size() + 1, dest);
}
/// @brief Write string to specific socket or to last source
/// @param data payload
/// @param size size of data
/// @param addr Destination for message (if nullptr it will be send to last source)
void write(uint8_t *data, uint size, IpAdr *dest = nullptr) {
int err;
if (dest == nullptr) {
err = sendto(_listenSockId, data, size, 0, _other.asSockAddrPtr(), sizeof(sockaddr_storage));
} else {
struct sockaddr_in *ipV4 = (struct sockaddr_in *)dest->asSockAddrPtr();
// ESP_LOGI("UDP", "EthIP: %s", inet_ntoa(ipV4->sin_addr.s_addr));
// ESP_LOGI("UDP", "PORT: %i", ntohs(ipV4->sin_port));
err = sendto(_listenSockId, data, size, 0, dest->asSockAddrPtr(), sizeof(sockaddr_storage));
}
if (err < 0) {
ESP_LOGE("UDP", "Error occurred during sending: errno %d", errno);
active = false;
}
}
/// @brief Standard destination address
const IpAdr &Local;
/// @brief query if stream is still active
/// @return true if active
bool isValid() {
return _listenSockId >= 0;
}
IpAdr getOther() {
return _other;
}
private:
int _listenSockId; // os handle for socket
IpAdr _other; // Remote Station
char _rxBuffer[128];
// Only used if NETBUF_RECVINFO is active
iovec _iov;
msghdr _msg;
u8_t _cmsg_buf[CMSG_SPACE(sizeof(struct in_pktinfo))];
};
/**
* @brief
* @details according to RFC-5424
* https://datatracker.ietf.org/doc/html/rfc5424
*/
class Syslog {
public:
static constexpr uint16_t SyslogPort = 514;
static constexpr std::string_view NilValue = "-";
enum class Severity {
Emergency = 0,
Alert = 1,
Critical = 2,
Error = 3,
Warning = 4,
Notice = 5,
Informational = 6,
Debug = 7,
};
static constexpr uint8_t SeverityMask = 0x000F;
enum class Facility {
kern = 0 << 3,
User = 1 << 3,
Mail = 2 << 3,
Daemon = 3 << 3,
Auth = 4 << 3,
Syslog = 5 << 3,
Lpr = 6 << 3,
News = 7 << 3,
Uucp = 8 << 3,
Cron = 9 << 3,
Authpriv = 10 << 3,
Ftp = 11 << 3,
Ntp = 12 << 3,
LogAudit = 13 << 3,
LogAlert = 14 << 3,
Clock = 15 << 3,
Local0 = 16 << 3,
Local1 = 17 << 3,
Local2 = 18 << 3,
Local3 = 19 << 3,
Local4 = 20 << 3,
Local5 = 21 << 3,
Local6 = 22 << 3,
Local7 = 23 << 3,
};
static void log(Severity severity, std::string message) {
if (_Socket == nullptr) {
return;
}
char buffer[512];
// V T H A P M D Msg
// alternatively with BOM flag UTF8 \xEF\xBB\xBF
auto pos = sprintf(buffer, "<%i>1 - %s %s - - - %s",
static_cast<int>(_Facility) | static_cast<int>(severity),
_HostName.c_str(),
_AppName.c_str(),
message.c_str());
_Socket->write((uint8_t *)buffer, pos, &_Target);
}
template <typename...Params>
static void logv(Severity severity, const char *fmt, Params&&... args) {
if (_Socket == nullptr) {
return;
}
// if (severity > _severityThresh) {
// return;
// }
char buffer[512];
// V T H A P M D Msg
// alternatively with BOM flag UTF8 \xEF\xBB\xBF
auto pos = sprintf(buffer, "<%i>1 - %s %s - - - ",
static_cast<int>(_Facility) | static_cast<int>(severity),
_HostName.c_str(),
_AppName.c_str());
pos += sprintf(&buffer[pos], fmt, std::forward<Params> (args)...);
_Socket->write((uint8_t *)buffer, pos, &_Target);
}
static void setupTask(IpAdr target) {
if (_Socket) {
return;
}
ESP_LOGI("UDP", "Starting syslog session to %s", target.getIp().c_str());
_Facility = Facility::Syslog;
_HostName = "ESP";
_AppName = "App";
_Target = IpAdr{target.getIp(), SyslogPort};
static fos::Task syslogTask(SyslogTask, "SysLog", 4096);
}
private:
static void SyslogTask();
static Facility _Facility;
static std::string _HostName;
static std::string _AppName;
static UdpSocket *_Socket;
static IpAdr _Target;
static Severity _severityThresh;
};
components/sockets/src/etherCommon.cpp
-68
View File
@@ -1,68 +0,0 @@
/**
* @file etherCommon.cpp
* @author Gustice
* @brief Helper Functions for Ethernet usage
*
* @copyright Copyright (c) 2024
*/
#include "etherCommon.hpp"
#include <cassert>
IpAdr::IpAdr(std::string ipStr, uint16_t port)
: IpAdr(ipaddr_addr(ipStr.c_str()), port) {
}
IpAdr::IpAdr(uint32_t ip, uint16_t port) {
struct sockaddr_in *ipV4 = (struct sockaddr_in *)&addrStore;
ipV4->sin_len = sizeof(sockaddr_in);
ipV4->sin_addr.s_addr = ip;
ipV4->sin_family = AF_INET;
ipV4->sin_port = htons(port);
}
IpAdr::IpAdr(uint16_t port) {
struct sockaddr_in *ipV4 = (struct sockaddr_in *)&addrStore;
ipV4->sin_len = sizeof(sockaddr_in);
ipV4->sin_addr.s_addr = INADDR_ANY;
ipV4->sin_family = AF_INET;
ipV4->sin_port = htons(port);
}
IpAdr::IpAdr(sockaddr_in ipV4data) {
struct sockaddr_storage *store = (struct sockaddr_storage *)&ipV4data;
assert(ipV4data.sin_family == AF_INET);
addrStore = *store;
}
IpAdrV6::IpAdrV6(std::string ipStr, uint16_t port) {
struct sockaddr_in6 *ipV6 = (struct sockaddr_in6 *)&addrStore;
ipV6->sin6_len = sizeof(sockaddr_in6);
inet6_aton(ipStr.c_str(), &ipV6->sin6_addr);
ipV6->sin6_family = AF_INET6;
ipV6->sin6_port = htons(port);
}
IpAdrV6::IpAdrV6(in6_addr ip, uint16_t port) {
struct sockaddr_in6 *ipV6 = (struct sockaddr_in6 *)&addrStore;
ipV6->sin6_len = sizeof(sockaddr_in6);
memcpy(&ip, &ipV6->sin6_addr, sizeof(in6_addr));
ipV6->sin6_family = AF_INET6;
ipV6->sin6_port = htons(port);
}
IpAdrV6::IpAdrV6(uint16_t port) {
struct sockaddr_in6 *ipV6 = (struct sockaddr_in6 *)&addrStore;
ipV6->sin6_len = sizeof(sockaddr_in6);
// ip6_addr_set_any()
bzero(&ipV6->sin6_addr.un, sizeof(ipV6->sin6_addr.un));
ipV6->sin6_family = AF_INET6;
ipV6->sin6_port = htons(port);
}
IpAdrV6::IpAdrV6(sockaddr_in6 ipV6data) {
struct sockaddr_storage *store = (struct sockaddr_storage *)&ipV6data;
assert(ipV6data.sin6_family == AF_INET);
addrStore = *store;
}
components/sockets/src/mqttClient.cpp
-150
View File
@@ -1,150 +0,0 @@
/**
* @file mqttClient.cpp
* @author Gustice
* @brief Wrapper class for TCP/IP based MQTT APIs
*
* @copyright Copyright (c) 2024
*/
#include "mqttClient.hpp"
#include "esp_log.h"
#include "mqtt_client.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
MqttClient *MqttClient::_instance = nullptr;
const char *TAG = "Mqtt";
static void log_error_if_nonzero(const char *message, int error_code) {
if (error_code != 0) {
ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
}
}
void MqttClient::eventHandler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
ESP_LOGI(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id);
esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
esp_mqtt_client_handle_t client = event->client;
MqttClient &instance = *((MqttClient *)handler_args);
int msg_id;
switch ((esp_mqtt_event_id_t)event_id) {
case MQTT_EVENT_CONNECTED:
instance._state = State::Connected;
ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
for (auto &s : instance._subscriptions) {
msg_id = esp_mqtt_client_subscribe(client, s.topic.c_str(), 1);
ESP_LOGI(TAG, "sent subscribe successful: topic='%s', msg_id=%d", s.topic.c_str(), msg_id);
}
break;
case MQTT_EVENT_DISCONNECTED:
instance._state = State::Disconnected;
ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
break;
case MQTT_EVENT_SUBSCRIBED:
ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
break;
case MQTT_EVENT_UNSUBSCRIBED:
ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
break;
case MQTT_EVENT_PUBLISHED:
ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
break;
case MQTT_EVENT_DATA: {
bool found = false;
std::string topic(event->topic, event->topic_len);
for (auto &s : instance._subscriptions) {
if (s.topic == topic) {
found = true;
s.callback(std::string(event->data, event->data_len));
}
}
if (!found) {
ESP_LOGW(TAG, "Unrecognized Topic");
printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
printf("DATA=%.*s\r\n", event->data_len, event->data);
}
} break;
case MQTT_EVENT_ERROR:
ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno);
ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
}
break;
default:
ESP_LOGI(TAG, "Other event id:%d", event->event_id);
break;
}
}
MqttClient::MqttClient(std::string broker, std::string prefix)
: _broker("mqtt://" + broker), _prefix(prefix) {
// esp_log_level_set("*", ESP_LOG_INFO);
// esp_log_level_set(TAG, ESP_LOG_VERBOSE);
// esp_log_level_set("mqtt_client", ESP_LOG_VERBOSE);
// esp_log_level_set("transport_base", ESP_LOG_VERBOSE);
// esp_log_level_set("esp-tls", ESP_LOG_VERBOSE);
// esp_log_level_set("transport", ESP_LOG_VERBOSE);
// esp_log_level_set("outbox", ESP_LOG_VERBOSE);
esp_mqtt_client_config_t mqtt_cfg{};
mqtt_cfg.broker.address.uri = _broker.c_str();
_client = esp_mqtt_client_init(&mqtt_cfg);
/* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
esp_mqtt_client_register_event(_client, (esp_mqtt_event_id_t)ESP_EVENT_ANY_ID, eventHandler, this);
}
MqttClient::~MqttClient() {
for (auto &s : _subscriptions) {
auto msg_id = esp_mqtt_client_unsubscribe(_client, s.topic.c_str());
ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
}
esp_mqtt_client_disconnect(_client);
}
MqttClient &MqttClient::getInstance() {
if (_instance == nullptr) {
throw "No instance created";
}
return *_instance;
}
MqttClient &MqttClient::init(std::string broker, std::string prefix) {
if (_instance != nullptr) {
return *_instance;
}
_instance = new MqttClient(broker, prefix);
return *_instance;
}
void MqttClient::addSubscription(std::string topic, std::function<void(std::string)> call) {
std::string fullTopic = _prefix + "/" + topic;
_subscriptions.emplace_back(fullTopic, call, false, 0);
// ToDo ensure each topic is only present once
}
void MqttClient::start() {
ESP_LOGI(TAG, "Starting MQTT client");
_state = State::Started;
esp_mqtt_client_start(_client);
}
void MqttClient::publish(std::string topic, std::string data) {
if (_state != State::Connected) {
ESP_LOGW(TAG, "not connected, cannot publish s=%i", (int)_state);
return;
}
std::string fullTopic = _prefix + "/" + topic;
int msg_id = esp_mqtt_client_publish(_client, fullTopic.c_str(), data.c_str(), data.size(), 1, 0);
ESP_LOGI(TAG, "sent publish of topic '%s' successful, msg_id=%d", fullTopic.c_str(), msg_id);
}
components/sockets/src/tcpSockets.cpp
-9
View File
@@ -1,9 +0,0 @@
/**
* @file tcpSockets.cpp
* @author Gustice
* @brief Function frames for handling sockets
*
* @copyright Copyright (c) 2024
*/
#include "tcpSockets.hpp"
components/sockets/src/udpSocekts.cpp
-36
View File
@@ -1,36 +0,0 @@
/**
* @file udpSockets.cpp
* @author Gustice
* @brief Function frames for handling sockets
*
* @copyright Copyright (c) 2024
*/
#include "udpSockets.hpp"
UdpSocket * Syslog::_Socket;
Syslog::Facility Syslog::_Facility;
std::string Syslog::_HostName;
std::string Syslog::_AppName;
IpAdr Syslog::_Target(INADDR_ANY, 0);
Syslog::Severity Syslog::_severityThresh = Syslog::Severity::Informational;
void Syslog::SyslogTask() {
ESP_LOGI("SysLog", "Starting Syslog Task");
try {
while (true) {
IpAdr ip(INADDR_ANY, SyslogPort);
UdpSocket socket(ip);
_Socket = &socket;
socket.bindTo();
while (socket.isActive()) {
(void)socket.read();
// ignore all incomming data
}
}
_Socket = nullptr;
} catch (const std::exception &e) {
ESP_LOGE("SysLog", "%s", e.what());
}
}
components/tftpShell/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
idf_component_register(
SRC_DIRS "extern"
INCLUDE_DIRS "include" "extern"
)
components/tftpShell/extern/embedded_cli.c
Vendored
-1156
View File
File diff suppressed because it is too large Load Diff
components/tftpShell/extern/embedded_cli.h
Vendored
-312
View File
@@ -1,312 +0,0 @@
#ifndef EMBEDDED_CLI_H
#define EMBEDDED_CLI_H
#ifdef __cplusplus
extern "C" {
#else
#include <stdbool.h>
#endif
// cstdint is available only since C++11, so use C header
#include <stdint.h>
// used for proper alignment of cli buffer
#if UINTPTR_MAX == 0xFFFF
#define CLI_UINT uint16_t
#elif UINTPTR_MAX == 0xFFFFFFFF
#define CLI_UINT uint32_t
#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFu
#define CLI_UINT uint64_t
#else
#error unsupported pointer size
#endif
#define CLI_UINT_SIZE (sizeof(CLI_UINT))
// convert size in bytes to size in terms of CLI_UINTs (rounded up
// if bytes is not divisible by size of single CLI_UINT)
#define BYTES_TO_CLI_UINTS(bytes) \
(((bytes) + CLI_UINT_SIZE - 1)/CLI_UINT_SIZE)
typedef struct CliCommand CliCommand;
typedef struct CliCommandBinding CliCommandBinding;
typedef struct EmbeddedCli EmbeddedCli;
typedef struct EmbeddedCliConfig EmbeddedCliConfig;
struct CliCommand {
/**
* Name of the command.
* In command "set led 1 1" "set" is name
*/
const char *name;
/**
* String of arguments of the command.
* In command "set led 1 1" "led 1 1" is string of arguments
* Is ended with double 0x00 char
* Use tokenize functions to easily get individual tokens
*/
char *args;
};
/**
* Struct to describe binding of command to function and
*/
struct CliCommandBinding {
/**
* Name of command to bind. Should not be NULL.
*/
const char *name;
/**
* Help string that will be displayed when "help <cmd>" is executed.
* Can have multiple lines separated with "\r\n"
* Can be NULL if no help is provided.
*/
const char *help;
/**
* Flag to perform tokenization before calling binding function.
*/
bool tokenizeArgs;
/**
* Pointer to any specific app context that is required for this binding.
* It will be provided in binding callback.
*/
void *context;
/**
* Binding function for when command is received.
* If null, default callback (onCommand) will be called.
* @param cli - pointer to cli that is calling this binding
* @param args - string of args (if tokenizeArgs is false) or tokens otherwise
* @param context
*/
void (*binding)(EmbeddedCli *cli, char *args, void *context);
};
struct EmbeddedCli {
/**
* Should write char to connection
* @param cli - pointer to cli that executed this function
* @param c - actual character to write
*/
void (*writeChar)(EmbeddedCli *cli, char c);
/**
* Called when command is received and command not found in list of
* command bindings (or binding function is null).
* @param cli - pointer to cli that executed this function
* @param command - pointer to received command
*/
void (*onCommand)(EmbeddedCli *cli, CliCommand *command);
/**
* Can be used for any application context
*/
void *appContext;
/**
* Pointer to actual implementation, do not use.
*/
void *_impl;
};
/**
* Configuration to create CLI
*/
struct EmbeddedCliConfig {
/**
* Invitation string. Is printed at the beginning of each line with user
* input
*/
const char *invitation;
/**
* Size of buffer that is used to store characters until they're processed
*/
uint16_t rxBufferSize;
/**
* Size of buffer that is used to store current input that is not yet
* sended as command (return not pressed yet)
*/
uint16_t cmdBufferSize;
/**
* Size of buffer that is used to store previously entered commands
* Only unique commands are stored in buffer. If buffer is smaller than
* entered command (including arguments), command is discarded from history
*/
uint16_t historyBufferSize;
/**
* Maximum amount of bindings that can be added via addBinding function.
* Cli increases takes extra bindings for internal commands:
* - help
*/
uint16_t maxBindingCount;
/**
* Buffer to use for cli and all internal structures. If NULL, memory will
* be allocated dynamically. Otherwise this buffer is used and no
* allocations are made
*/
CLI_UINT *cliBuffer;
/**
* Size of buffer for cli and internal structures (in bytes).
*/
uint16_t cliBufferSize;
/**
* Whether autocompletion should be enabled.
* If false, autocompletion is disabled but you still can use 'tab' to
* complete current command manually.
*/
bool enableAutoComplete;
};
/**
* Returns pointer to default configuration for cli creation. It is safe to
* modify it and then send to embeddedCliNew().
* Returned structure is always the same so do not free and try to use it
* immediately.
* Default values:
* <ul>
* <li>rxBufferSize = 64</li>
* <li>cmdBufferSize = 64</li>
* <li>historyBufferSize = 128</li>
* <li>cliBuffer = NULL (use dynamic allocation)</li>
* <li>cliBufferSize = 0</li>
* <li>maxBindingCount = 8</li>
* <li>enableAutoComplete = true</li>
* </ul>
* @return configuration for cli creation
*/
EmbeddedCliConfig *embeddedCliDefaultConfig(void);
/**
* Returns how many space in config buffer is required for cli creation
* If you provide buffer with less space, embeddedCliNew will return NULL
* This amount will always be divisible by CLI_UINT_SIZE so allocated buffer
* and internal structures can be properly aligned
* @param config
* @return
*/
uint16_t embeddedCliRequiredSize(EmbeddedCliConfig *config);
/**
* Create new CLI.
* Memory is allocated dynamically if cliBuffer in config is NULL.
* After CLI is created, override function pointers to start using it
* @param config - config for cli creation
* @return pointer to created CLI
*/
EmbeddedCli *embeddedCliNew(EmbeddedCliConfig *config);
/**
* Same as calling embeddedCliNew with default config.
* @return
*/
EmbeddedCli *embeddedCliNewDefault(void);
/**
* Receive character and put it to internal buffer
* Actual processing is done inside embeddedCliProcess
* You can call this function from something like interrupt service routine,
* just make sure that you call it only from single place. Otherwise input
* might get corrupted
* @param cli
* @param c - received char
*/
void embeddedCliReceiveChar(EmbeddedCli *cli, char c);
/**
* Process rx/tx buffers. Command callbacks are called from here
* @param cli
*/
void embeddedCliProcess(EmbeddedCli *cli);
/**
* Add specified binding to list of bindings. If list is already full, binding
* is not added and false is returned
* @param cli
* @param binding
* @return true if binding was added, false otherwise
*/
bool embeddedCliAddBinding(EmbeddedCli *cli, CliCommandBinding binding);
/**
* Print specified string and account for currently entered but not submitted
* command.
* Current command is deleted, provided string is printed (with new line) after
* that current command is printed again, so user can continue typing it.
* @param cli
* @param string
*/
void embeddedCliPrint(EmbeddedCli *cli, const char *string);
/**
* Free allocated for cli memory
* @param cli
*/
void embeddedCliFree(EmbeddedCli *cli);
/**
* Perform tokenization of arguments string. Original string is modified and
* should not be used directly (only inside other token functions).
* Individual tokens are separated by single 0x00 char, double 0x00 is put at
* the end of token list. After calling this function, you can use other
* token functions to get individual tokens and token count.
*
* Important: Call this function only once. Otherwise information will be lost if
* more than one token existed
* @param args - string to tokenize (must have extra writable char after 0x00)
* @return
*/
void embeddedCliTokenizeArgs(char *args);
/**
* Return specific token from tokenized string
* @param tokenizedStr
* @param pos (counted from 1)
* @return token
*/
const char *embeddedCliGetToken(const char *tokenizedStr, uint16_t pos);
/**
* Same as embeddedCliGetToken but works on non-const buffer
* @param tokenizedStr
* @param pos (counted from 1)
* @return token
*/
char *embeddedCliGetTokenVariable(char *tokenizedStr, uint16_t pos);
/**
* Find token in provided tokens string and return its position (counted from 1)
* If no such token is found - 0 is returned.
* @param tokenizedStr
* @param token - token to find
* @return position (increased by 1) or zero if no such token found
*/
uint16_t embeddedCliFindToken(const char *tokenizedStr, const char *token);
/**
* Return number of tokens in tokenized string
* @param tokenizedStr
* @return number of tokens
*/
uint16_t embeddedCliGetTokenCount(const char *tokenizedStr);
#ifdef __cplusplus
}
#endif
#endif //EMBEDDED_CLI_H
components/tftpShell/extern/license
Vendored
-21
View File
@@ -1,21 +0,0 @@
MIT License
Copyright (c) 2021 Sviatoslav Kokurin (funbiscuit)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
components/tftpShell/extern/readme.md
Vendored
-7
View File
@@ -1,7 +0,0 @@
# Embedded CLI
Implementation is taken from `funbiscuit` @ [github](https://github.com/funbiscuit/embedded-cli)
- Only source and header where integrated.
- Full project is included in `external/embedded-cli`
components/tftpShell/include/cliWrapper.hpp
-161
View File
@@ -1,161 +0,0 @@
/**
* @file cliWrapper.hpp
* @author Gustice
* @brief Wrapping Command-Line-Interfaces with custom endpoints
* @details Command-Line-Interface is based on the implementation of
* https://github.com/funbiscuit/embedded-cli
*
* @copyright Copyright (c) 2024
*/
#pragma once
#include "embedded_cli.h"
#include <esp_log.h>
#include <functional>
#include <memory>
#include "simpleStreams.hpp"
/* Module configuration */
static constexpr int CLI_RX_BUFFER_SIZE = 64;
static constexpr int CLI_CMD_BUFFER_SIZE = 64; // to also accept URLs for Updates
static constexpr int CLI_HISTORY_SIZE = 16;
static constexpr int CLI_BINDING_COUNT = 8;
static constexpr std::string_view CliWelcomeString{
"** Smart-DMX-Bridge **\n"
" send 'help' for help-page\n"
" NOTE: Syslog-messages are sent to client of this session\n"};
/**
* @brief Wrapper for c-implementation of CLI
*/
class Cli {
public:
/// @brief Type for callback arguments
using CArgs = std::vector<std::string> &;
/// @brief Type for bind callback
using BindCb = std::function<void(CArgs)>;
/// @brief Type for command callback
using CommandCb = std::function<void(std::string, CArgs)>;
/// @brief Parameter structure for command-binding
struct Binding {
std::string_view name;
std::string_view help_output;
BindCb callback;
};
/// @brief Constructor
/// @param port Reference to serial port
/// @param cmd command callback
Cli(CharStream &port, CommandCb cmd)
: _port(port), _commandCb(cmd) {
EmbeddedCliConfig *config = embeddedCliDefaultConfig();
// NOTE: Note setting cliBuffer allows Cli to allocate needed buffer in correct size
// config->cliBuffer = cliBuffer;
// config->cliBufferSize = CLI_BUFFER_SIZE;
config->rxBufferSize = CLI_RX_BUFFER_SIZE;
config->cmdBufferSize = CLI_CMD_BUFFER_SIZE;
config->historyBufferSize = CLI_HISTORY_SIZE;
config->maxBindingCount = CLI_BINDING_COUNT;
cli = embeddedCliNew(config);
if (cli == NULL) {
ESP_LOGE("CLI", "Cli was not created, requires %d bytes. Check sizes!",
embeddedCliRequiredSize(config));
return;
}
cli->onCommand = genericCallback;
cli->writeChar = writeToken;
// appContext is a user-end variable and is bound to current instance
cli->appContext = this;
}
/// @brief Destructor
~Cli() {
embeddedCliFree(cli);
}
/// @brief Create command binding
bool addBinding(Binding bind) {
BindCb *cb = new BindCb{bind.callback};
CliCommandBinding cBinding{.name = bind.name.begin(),
.help = bind.help_output.begin(),
.tokenizeArgs = true,
// NOTE: this hard reference only works because we only provide
// an add-function without remove
.context = (void *)(cb),
.binding = boundCallback};
return embeddedCliAddBinding(cli, cBinding);
}
/// @brief Static method to generate c-compatible function-pointer for bound-command-callback
/// @details - receives and wraps arguments in string,
/// - determines object according to appContext
/// - calls appropriate method of appropriate object
static void boundCallback(EmbeddedCli *cli, char *args, void *context) {
if (context == nullptr) {
return;
ESP_LOGE("CLI", "No context in callback available");
}
ESP_LOGD("CLI", "Received command:");
BindCb &cb = *((BindCb *)context);
uint len = embeddedCliGetTokenCount(args);
std::vector<std::string> sArgs;
while (len-- > 0) {
const char *const arg = embeddedCliGetToken(args, 1);
ESP_LOGD("CLI", " arg: %s", arg);
sArgs.emplace_back(arg);
// shift position to end of this element to save time
args += sArgs.back().size() + 1; // needs also to be shifted by null-delimiter
}
cb(sArgs);
}
/// @brief Static method to generate c-compatible function-pointer for command-callback
/// @details - receives and wraps arguments in string,
/// - determines object according to appContext
/// - calls command-callback of appropriate object
static void genericCallback(EmbeddedCli *cli, CliCommand *command) {
std::string name(command->name);
ESP_LOGI("CLI", "Received generic command: %s", name.c_str());
embeddedCliTokenizeArgs(command->args);
std::vector<std::string> sArgs;
for (int i = 1; i <= embeddedCliGetTokenCount(command->args); ++i) {
sArgs.emplace_back(embeddedCliGetToken(command->args, i));
ESP_LOGI("CLI", " arg %d : %s", i, sArgs.back().c_str());
}
auto &commandCb = static_cast<Cli *>(cli->appContext)->_commandCb;
commandCb(name, sArgs);
}
/// @brief Process buffer and trigger commands
void process() {
auto r = _port.read();
for (auto &&c : r) {
embeddedCliReceiveChar(cli, c);
}
embeddedCliProcess(cli);
}
/// @brief publicly exposed write method
void write(std::string output) {
_port.write(output);
}
private:
/// @brief Reference to hardware port
CharStream &_port;
/// @brief Callback for generic command
CommandCb _commandCb;
EmbeddedCli *cli = nullptr;
/// @brief Write callback
static void writeToken(EmbeddedCli *embeddedCli, char c) {
static_cast<Cli *>(embeddedCli->appContext)->_port.write(c);
}
};
components/utils/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
idf_component_register(
SRC_DIRS "src"
INCLUDE_DIRS "include"
)
components/utils/include/countDown.hpp
-36
View File
@@ -1,36 +0,0 @@
/**
* @file countDown.hpp
* @author Gustice
* @brief Classes for typical index manipulation
*
* @copyright Copyright (c) 2020
*/
#pragma once
class CountDown {
public:
CountDown(unsigned max) : Max(max) {}
void Tick() {
_cnt++;
if (_cnt >= Max) {
_cnt = 0;
_pFlag = true;
}
}
bool GetVolatileFlag() {
if (!_pFlag)
return false;
// Reset _pFlag in any case, so it only be consumed once
// hence volatile
_pFlag = false;
return true;
}
private:
const unsigned Max;
unsigned _cnt;
bool _pFlag;
};
components/utils/include/rotatingIndex.hpp
-58
View File
@@ -1,58 +0,0 @@
/**
* @file rotatingIndex.hpp
* @author Gustice
* @brief Classes for typical index manipulation
*
* @copyright Copyright (c) 2020
*/
#pragma once
#include <cstdint>
/**
* @brief Index with automatic revolution back to start position
* @details Useful for Buffer-Pointer, or similar tasks
*/
class RotatingIndex {
public:
/// @brief Value at witch the index rotates back to beginning
const uint16_t MaxIndex;
/// @brief Constructor for rotating index
/// @brief output index will be set to 0 if incremented value reaches Maximum
/// @param max Maximum index for overflow-condition
RotatingIndex(uint16_t max) : MaxIndex(max) { _index = 0; }
/// @brief Get the current index and inkrement index afterwards
/// @return uint16_t current index
uint16_t getIndexAndIncrement(void) {
auto retVal = _index;
_index++;
if (_index >= MaxIndex) {
_index = 0;
}
return retVal;
};
/// @brief Get the current index without incrementing the index
/// @return uint16_t current index
uint16_t getIndex(void) { return _index; }
/// @brief Check if next get will lead to overflow condition
bool peekRevolution(void) {
if (MaxIndex == 0)
return true;
if (_index >= MaxIndex - 1) {
return true;
}
return false;
}
/// @brief Reset Index to 0
void resetIndex(void) { _index = 0; }
private:
/// Current Index
uint16_t _index;
};
components/utils/src/dummy.cpp
-8
View File
@@ -1,8 +0,0 @@
/**
* @file dummy.cpp
* @author Gustice
* @brief Silence toolchain
*
* @copyright Copyright (c) 2024
*/
core
+1 -1
Submodule core updated: 03852f4beb...3041a17851
dependencies.lock
+1 -1
View File
@@ -10,6 +10,6 @@ dependencies:
source:
type: idf
version: 5.3.0
manifest_hash: 98a89ad95a9bf328a52537968b9e16f59396acd948940746898355de27de317f
manifest_hash: 736e193f01d8a1ca4afaed91b473283f46d56db468270aee2f055b9425257e7f
target: esp32c6
version: 1.0.0
sdkconfig
+56
View File
@@ -1972,6 +1972,62 @@ CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT=30
CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y
# CONFIG_WIFI_PROV_STA_FAST_SCAN is not set
# end of Wi-Fi Provisioning Manager
#
# mDNS
#
CONFIG_MDNS_MAX_INTERFACES=3
CONFIG_MDNS_MAX_SERVICES=10
CONFIG_MDNS_TASK_PRIORITY=1
CONFIG_MDNS_ACTION_QUEUE_LEN=16
CONFIG_MDNS_TASK_STACK_SIZE=4096
# CONFIG_MDNS_TASK_AFFINITY_NO_AFFINITY is not set
CONFIG_MDNS_TASK_AFFINITY_CPU0=y
CONFIG_MDNS_TASK_AFFINITY=0x0
CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS=2000
CONFIG_MDNS_TIMER_PERIOD_MS=100
# CONFIG_MDNS_NETWORKING_SOCKET is not set
# CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES is not set
# CONFIG_MDNS_ENABLE_DEBUG_PRINTS is not set
CONFIG_MDNS_ENABLE_CONSOLE_CLI=y
# CONFIG_MDNS_RESPOND_REVERSE_QUERIES is not set
CONFIG_MDNS_MULTIPLE_INSTANCE=y
#
# MDNS Predefined interfaces
#
CONFIG_MDNS_PREDEF_NETIF_STA=y
CONFIG_MDNS_PREDEF_NETIF_AP=y
CONFIG_MDNS_PREDEF_NETIF_ETH=y
# end of MDNS Predefined interfaces
# end of mDNS
#
# LittleFS
#
# CONFIG_LITTLEFS_SDMMC_SUPPORT is not set
CONFIG_LITTLEFS_MAX_PARTITIONS=3
CONFIG_LITTLEFS_PAGE_SIZE=256
CONFIG_LITTLEFS_OBJ_NAME_LEN=64
CONFIG_LITTLEFS_READ_SIZE=128
CONFIG_LITTLEFS_WRITE_SIZE=128
CONFIG_LITTLEFS_LOOKAHEAD_SIZE=128
CONFIG_LITTLEFS_CACHE_SIZE=512
CONFIG_LITTLEFS_BLOCK_CYCLES=512
CONFIG_LITTLEFS_USE_MTIME=y
# CONFIG_LITTLEFS_USE_ONLY_HASH is not set
# CONFIG_LITTLEFS_HUMAN_READABLE is not set
CONFIG_LITTLEFS_MTIME_USE_SECONDS=y
# CONFIG_LITTLEFS_MTIME_USE_NONCE is not set
# CONFIG_LITTLEFS_SPIFFS_COMPAT is not set
# CONFIG_LITTLEFS_FLUSH_FILE_EVERY_WRITE is not set
# CONFIG_LITTLEFS_FCNTL_GET_PATH is not set
# CONFIG_LITTLEFS_MULTIVERSION is not set
# CONFIG_LITTLEFS_MALLOC_STRATEGY_DISABLE is not set
CONFIG_LITTLEFS_MALLOC_STRATEGY_DEFAULT=y
# CONFIG_LITTLEFS_MALLOC_STRATEGY_INTERNAL is not set
CONFIG_LITTLEFS_ASSERTS=y
# end of LittleFS
# end of Component config
# CONFIG_IDF_EXPERIMENTAL_FEATURES is not set