Darkages/SpotMicroESP32-Leika
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🍡 Adds sweeping for servo

Browse Source
This commit is contained in:
Rune Harlyk
2024-06-10 21:16:53 +02:00
committed by Rune Harlyk
parent d951bc13c8
commit 813dde318c
7 changed files with 279 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/src/lib/stores/socket.ts
+6 -4
View File
@@ -1,10 +1,12 @@
import { writable } from 'svelte/store'; import { writable } from 'svelte/store';
const socketEvents = ['open', 'close', 'error', 'message', 'unresponsive'] as const;
type SocketEvent = (typeof socketEvents)[number];
function createWebSocket() { function createWebSocket() {
let listeners = new Map<string, Set<(data?: unknown) => void>>(); let listeners = new Map<string, Set<(data?: unknown) => void>>();
const { subscribe, set } = writable(false); const { subscribe, set } = writable(false);
const socketEvents = ['open', 'close', 'error', 'message', 'unresponsive'] as const; const reconnectTimeoutTime = 5000;
type SocketEvent = (typeof socketEvents)[number];
let unresponsiveTimeoutId: number; let unresponsiveTimeoutId: number;
let reconnectTimeoutId: number; let reconnectTimeoutId: number;
let ws: WebSocket; let ws: WebSocket;
@@ -21,7 +23,7 @@ function createWebSocket() {
clearTimeout(unresponsiveTimeoutId); clearTimeout(unresponsiveTimeoutId);
clearTimeout(reconnectTimeoutId); clearTimeout(reconnectTimeoutId);
listeners.get(reason)?.forEach((listener) => listener(event)); listeners.get(reason)?.forEach((listener) => listener(event));
reconnectTimeoutId = setTimeout(connect, 1000); reconnectTimeoutId = setTimeout(connect, reconnectTimeoutTime);
} }
function connect() { function connect() {
@@ -74,7 +76,7 @@ function createWebSocket() {
function resetUnresponsiveCheck() { function resetUnresponsiveCheck() {
clearTimeout(unresponsiveTimeoutId); clearTimeout(unresponsiveTimeoutId);
unresponsiveTimeoutId = setTimeout(() => disconnect('unresponsive'), 2000); unresponsiveTimeoutId = setTimeout(() => disconnect('unresponsive'), reconnectTimeoutTime);
} }
function send(msg: unknown) { function send(msg: unknown) {
app/src/routes/peripherals/servo/servo.svelte
+8 -1
View File
@@ -1,6 +1,13 @@
<script lang="ts"> <script lang="ts">
import type { Servo } from "$lib/models"; import type { Servo } from "$lib/models";
import { createEventDispatcher } from "svelte";
export let servo: Servo; export let servo: Servo;
const dispatch = createEventDispatcher();
const sweep = () => {
dispatch('sweep', {channel: servo.channel});
};
</script> </script>
<div> <div>
@@ -19,5 +26,5 @@
<span class="text-sm text-gray-500 dark:text-gray-400 absolute start-1/2 -translate-x-1/2 rtl:translate-x-1/2 -bottom-6">90</span> <span class="text-sm text-gray-500 dark:text-gray-400 absolute start-1/2 -translate-x-1/2 rtl:translate-x-1/2 -bottom-6">90</span>
<span class="text-sm text-gray-500 dark:text-gray-400 absolute end-0 -bottom-6">180</span> <span class="text-sm text-gray-500 dark:text-gray-400 absolute end-0 -bottom-6">180</span>
</div> </div>
<button class="btn btn-neutral btn-sm">Sweep range</button> <button class="btn btn-neutral btn-sm" on:click={sweep}>Sweep range</button>
</div> </div>
app/src/routes/peripherals/servo/servos.svelte
+93 -42
View File
@@ -1,51 +1,102 @@
<script lang="ts"> <script lang="ts">
import SettingsCard from "$lib/components/SettingsCard.svelte"; import SettingsCard from '$lib/components/SettingsCard.svelte';
import type { ServoConfiguration } from "$lib/models"; import type { ServoConfiguration, Servo } from '$lib/models';
import MotorOutline from '~icons/mdi/motor-outline'; import MotorOutline from '~icons/mdi/motor-outline';
import Servo from './servo.svelte'; import ServoController from './servo.svelte';
import { api } from "$lib/api"; import { api } from '$lib/api';
import Spinner from "$lib/components/Spinner.svelte"; import Spinner from '$lib/components/Spinner.svelte';
import { socket } from '$lib/stores';
import { onMount } from 'svelte';
let servo_config: ServoConfiguration let servo_config: ServoConfiguration;
let servos: Servo[];
let last_servo_config: ServoConfiguration;
$: updateServoConfig(servo_config) let isLoading = true;
const updateServoConfig = async (servo_config: ServoConfiguration) => { $: updateServoConfig(servo_config, servos);
let result = await api.post('/api/servo/configuration', servo_config)
}
const getServoConfig = async () => { const updateServoConfig = async (servo_config: ServoConfiguration, servos: Servo[]) => {
let result = await api.get<ServoConfiguration>('/api/servo/configuration') if (!servo_config) return;
if (result.isOk()) { const changes: { [key: string]: any } = {};
servo_config = result.inner for (const key of Object.keys(servo_config)) {
return result.inner if (key == 'servos') {
} for (let i = 0; i < servo_config.servos.length; i++) {
} for (const servo_key of Object.keys(servo_config.servos[i])) {
if (
JSON.stringify(servo_config.servos[i][servo_key as keyof Servo]) !==
JSON.stringify(last_servo_config.servos[i][servo_key as keyof Servo])
) {
if (!changes.servos) changes.servos = [];
if (!changes.servos[i]) changes.servos[i] = {};
changes.servos[i][servo_key as keyof Servo] =
servo_config.servos[i][servo_key as keyof Servo];
changes.servos[i].channel = servo_config.servos[i].channel;
}
}
}
continue;
}
if (
JSON.stringify(servo_config[key as keyof ServoConfiguration]) !==
JSON.stringify(last_servo_config[key as keyof ServoConfiguration])
) {
changes[key as keyof ServoConfiguration] = servo_config[key as keyof ServoConfiguration];
}
}
if (Object.keys(changes).length > 0) {
socket.sendEvent('servoConfiguration', changes);
last_servo_config = structuredClone(servo_config);
}
};
const sweep = (event:any) => {
let channel = event.detail.channel;
socket.sendEvent('servoConfiguration', {servos:[{channel, sweep: true}]});
};
onMount(() => {
socket.on('servoConfiguration', (data: ServoConfiguration) => {
isLoading = false;
servo_config = data;
servos = data.servos;
last_servo_config = structuredClone(data);
});
});
</script> </script>
<SettingsCard collapsible={false}> <SettingsCard collapsible={false}>
<MotorOutline slot="icon" class="lex-shrink-0 mr-2 h-6 w-6 self-end" /> <MotorOutline slot="icon" class="lex-shrink-0 mr-2 h-6 w-6 self-end" />
<span slot="title">Servo</span> <span slot="title">Servo</span>
{#await getServoConfig() } {#if isLoading}
<Spinner /> <Spinner />
{:then _} {:else}
<div class="flex flex-col"> <div class="flex flex-col">
<h2 class="text-lg">General servo configuration</h2> <h2 class="text-lg">General servo configuration</h2>
<span class="mb-1 flex justify-between items-center"> <span class="mb-1 flex justify-between items-center">
Servo Oscillator Frequency <input type="number" bind:value={servo_config.servo_oscillator_frequency} class="input input-bordered input-sm max-w-xs"/> Servo Oscillator Frequency <input
</span> type="number"
<span class="flex justify-between items-center mb-1"> bind:value={servo_config.servo_oscillator_frequency}
Servo PWM Frequency <input type="number" bind:value={servo_config.servo_pwm_frequency} class="input input-bordered input-sm max-w-xs"/> class="input input-bordered input-sm max-w-xs"
</span> />
<span class="flex justify-between items-center gap-1"> </span>
Is active <input type="checkbox" bind:value={servo_config.is_active} class="toggle"/> <span class="flex justify-between items-center mb-1">
</span> Servo PWM Frequency <input
</div> type="number"
<div class="divider"></div> bind:value={servo_config.servo_pwm_frequency}
{#each servo_config.servos as servo} class="input input-bordered input-sm max-w-xs"
<Servo {servo} /> />
<div class="divider"></div> </span>
{/each} <span class="flex justify-between items-center gap-1">
{/await} Is active <input type="checkbox" bind:checked={servo_config.is_active} class="toggle" />
</SettingsCard> </span>
</div>
<div class="divider"></div>
{#each servos as servo}
<ServoController bind:servo on:sweep={sweep} />
<div class="divider"></div>
{/each}
{/if}
</SettingsCard>
esp32/features.ini
+2
View File
@@ -9,6 +9,8 @@ build_flags =
-D FT_DOWNLOAD_FIRMWARE=0 -D FT_DOWNLOAD_FIRMWARE=0
-D FT_ANALYTICS=1 -D FT_ANALYTICS=1
-D FT_MOTION=0 -D FT_MOTION=0
; Hardware specific
-D FT_IMU=0 -D FT_IMU=0
-D FT_MAG=0 -D FT_MAG=0
-D FT_BMP=0 -D FT_BMP=0
esp32/lib/ESP32-sveltekit/ESP32SvelteKit.cpp
+3
View File
@@ -240,6 +240,9 @@ void IRAM_ATTR ESP32SvelteKit::_loop() {
#endif #endif
#if FT_ENABLED(FT_MOTION) #if FT_ENABLED(FT_MOTION)
_motionService.loop(); _motionService.loop();
#endif
#if FT_ENABLED(FT_SERVO)
_servoController.loop();
#endif #endif
vTaskDelay(20 / portTICK_PERIOD_MS); vTaskDelay(20 / portTICK_PERIOD_MS);
} }
esp32/lib/ESP32-sveltekit/ServoController.h
+166 -61
View File
@@ -1,55 +1,62 @@
#include <Adafruit_PWMServoDriver.h>
#include <EventEndpoint.h> #include <EventEndpoint.h>
#include <FSPersistence.h> #include <FSPersistence.h>
#include <HttpEndpoint.h> #include <HttpEndpoint.h>
#include <SecurityManager.h> #include <SecurityManager.h>
#include <StatefulService.h> #include <StatefulService.h>
#include <Adafruit_PWMServoDriver.h>
#define SERVO_CONFIG_FILE "/config/servoConfig.json" #define SERVO_CONFIG_FILE "/config/servoConfig.json"
#define SERVO_CONFIGURATION_SETTINGS_PATH "/api/servo/configuration" #define SERVO_CONFIGURATION_SETTINGS_PATH "/api/servo/configuration"
#define EVENT_CONFIGURATION_SETTINGS "servoConfiguration"
#ifndef FACTORY_SERVO_NUM #ifndef FACTORY_SERVO_NUM
#define FACTORY_SERVO_NUM 12 #define FACTORY_SERVO_NUM 12
#endif #endif
#ifndef FACTORY_SERVO_PWM_FREQUENCY #ifndef FACTORY_SERVO_PWM_FREQUENCY
#define FACTORY_SERVO_PWM_FREQUENCY 50 #define FACTORY_SERVO_PWM_FREQUENCY 50
#endif #endif
#ifndef FACTORY_SERVO_OSCILLATOR_FREQUENCY #ifndef FACTORY_SERVO_OSCILLATOR_FREQUENCY
#define FACTORY_SERVO_OSCILLATOR_FREQUENCY 27000000 #define FACTORY_SERVO_OSCILLATOR_FREQUENCY 27000000
#endif #endif
#ifndef FACTORY_SERVO_CENTER_ANGLE #ifndef FACTORY_SERVO_CENTER_ANGLE
#define FACTORY_SERVO_CENTER_ANGLE 90 #define FACTORY_SERVO_CENTER_ANGLE 90
#endif #endif
struct servo_t #define SERVO_STATE_SPEED_MS 20
{ #define SERVO_MIN 150 // This is the 'minimum' pulse length count (out of 4096)
#define SERVO_MAX 650 // This is the 'maximum' pulse length count (out of 4096)
enum SERVO_STATE { SERVO_STATE_ACTIVE, SERVO_STATE_SWEEPING_FORWARD, SERVO_STATE_SWEEPING_BACKWARD };
struct servo_t {
String name; String name;
int8_t channel; int8_t channel;
bool inverted; bool inverted;
int16_t angle; int16_t angle;
int16_t center_angle; int16_t center_angle;
SERVO_STATE state;
}; };
class ServoConfiguration { class ServoConfiguration {
public: public:
int32_t servo_oscillator_frequency {FACTORY_SERVO_OSCILLATOR_FREQUENCY}; int32_t servo_oscillator_frequency{FACTORY_SERVO_OSCILLATOR_FREQUENCY};
int32_t servo_pwm_frequency {FACTORY_SERVO_PWM_FREQUENCY}; int32_t servo_pwm_frequency{FACTORY_SERVO_PWM_FREQUENCY};
std::vector<servo_t> servos_config; std::vector<servo_t> servos_config;
bool is_active {false}; bool is_active{true};
const int8_t servo_invert[12] = {-1, 1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1};
static void read(ServoConfiguration &settings, JsonObject &root) { static void read(ServoConfiguration &settings, JsonObject &root) {
root["is_active"] = settings.is_active; root["is_active"] = settings.is_active;
root["servo_pwm_frequency"] = settings.servo_pwm_frequency; root["servo_pwm_frequency"] = settings.servo_pwm_frequency;
root["servo_oscillator_frequency"] = settings.servo_oscillator_frequency; root["servo_oscillator_frequency"] =
settings.servo_oscillator_frequency;
JsonArray servos = root["servos"].to<JsonArray>(); JsonArray servos = root["servos"].to<JsonArray>();
for (auto &servo : settings.servos_config) for (auto &servo : settings.servos_config) {
{
JsonObject servo_config = servos.add<JsonObject>(); JsonObject servo_config = servos.add<JsonObject>();
servo_config["name"] = servo.name; servo_config["name"] = servo.name;
@@ -57,84 +64,182 @@ class ServoConfiguration {
servo_config["inverted"] = servo.inverted; servo_config["inverted"] = servo.inverted;
servo_config["angle"] = servo.angle; servo_config["angle"] = servo.angle;
servo_config["center_angle"] = servo.center_angle; servo_config["center_angle"] = servo.center_angle;
servo_config["state"] = servo.state;
} }
} }
static StateUpdateResult update(JsonObject &root, ServoConfiguration &settings) { static StateUpdateResult update(JsonObject &root,
settings.is_active = root["is_active"] | false; ServoConfiguration &settings) {
settings.servo_pwm_frequency = root["servo_pwm_frequency"] | FACTORY_SERVO_PWM_FREQUENCY; settings.is_active = root["is_active"] | settings.is_active;
settings.servo_oscillator_frequency = root["servo_oscillator_frequency"] | FACTORY_SERVO_OSCILLATOR_FREQUENCY; settings.servo_pwm_frequency =
settings.servos_config.clear(); root["servo_pwm_frequency"] | settings.servo_pwm_frequency;
settings.servo_oscillator_frequency =
root["servo_oscillator_frequency"] |
settings.servo_oscillator_frequency;
JsonArray servos = root["servos"]; JsonArray servos = root["servos"];
if (root["servos"].is<JsonArray>())
{
int i = 0;
for (auto servo : servos)
{
JsonObject servo_config = servo.as<JsonObject>();
servo_t new_servo;
new_servo.name = servo_config["name"].as<String>(); if (!root["servos"].is<JsonArray>() && settings.servos_config.empty()) {
new_servo.channel = servo_config["channel"]; ESP_LOGI("ControllerSettings", "No servos found, adding default servos");
new_servo.inverted = servo_config["inverted"];
new_servo.angle = servo_config["angle"];
new_servo.center_angle = servo_config["center_angle"];
settings.servos_config.push_back(new_servo);
i++;
}
} else {
for (int8_t i = 0; i < FACTORY_SERVO_NUM; i++) { for (int8_t i = 0; i < FACTORY_SERVO_NUM; i++) {
ESP_LOGI("WiFiSettings", "Adding servo %d", i); ESP_LOGI("ControllerSettings", "Adding servo %d", i);
settings.servos_config.push_back(servo_t { settings.servos_config.push_back(
.name = "Servo " + String(i), servo_t{.name = "Servo " + String(i),
.channel = i, .channel = i,
.inverted = 1, .inverted = 1,
.angle = 0, .angle = 0,
.center_angle = FACTORY_SERVO_CENTER_ANGLE .center_angle = FACTORY_SERVO_CENTER_ANGLE
}); // ,
// .state = SERVO_STATE_ACTIVE
});
} }
return StateUpdateResult::CHANGED;
} }
for (auto new_servo_json : servos) {
JsonObject servo_config = new_servo_json.as<JsonObject>();
int8_t channel = servo_config["channel"] | -1;
servo_t *servo =
get_servo_by_channel(settings.servos_config, channel);
if (servo != nullptr) {
servo->name = servo_config["name"].as<String>() || servo->name;
if (servo_config["inverted"])
servo->inverted = servo_config["inverted"];
if (servo_config["angle"].is<int16_t>()) {
servo->angle = servo_config["angle"].as<int16_t>();
servo->state = SERVO_STATE_ACTIVE;
}
if (servo_config["center_angle"].is<int16_t>())
servo->center_angle =
servo_config["center_angle"].as<int16_t>();
if (servo_config["sweep"])
servo->state = SERVO_STATE_SWEEPING_FORWARD;
continue;
}
servo_t new_servo;
new_servo.name = servo_config["name"].as<String>();
new_servo.channel = channel;
new_servo.inverted = servo_config["inverted"];
new_servo.angle = servo_config["angle"];
new_servo.center_angle = servo_config["center_angle"];
// new_servo.state = servo_config["state"];
settings.servos_config.push_back(new_servo);
}
return StateUpdateResult::CHANGED; return StateUpdateResult::CHANGED;
}; };
static servo_t *get_servo_by_channel(std::vector<servo_t> &servos_config,
int8_t channel_id) {
for (auto &servo : servos_config) {
if (servo.channel == channel_id) {
return &servo;
}
}
return nullptr;
}
}; };
class ServoController : public Adafruit_PWMServoDriver, public StatefulService<ServoConfiguration> { class ServoController : public Adafruit_PWMServoDriver,
public StatefulService<ServoConfiguration> {
public: public:
ServoController(PsychicHttpServer *server, FS *fs, SecurityManager *securityManager, EventSocket *socket) ServoController(PsychicHttpServer *server, FS *fs,
: Adafruit_PWMServoDriver(), _server(server), SecurityManager *securityManager, EventSocket *socket)
: Adafruit_PWMServoDriver(),
_server(server),
_securityManager(securityManager), _securityManager(securityManager),
_httpEndpoint(ServoConfiguration::read, ServoConfiguration::update, _eventEndpoint(ServoConfiguration::read, ServoConfiguration::update,
this, server, SERVO_CONFIGURATION_SETTINGS_PATH, this, socket, EVENT_CONFIGURATION_SETTINGS),
securityManager, AuthenticationPredicates::IS_ADMIN), _fsPersistence(ServoConfiguration::read, ServoConfiguration::update,
// _eventEndpoint(ServoConfiguration::read, ServoConfiguration::update, this, fs, SERVO_CONFIG_FILE) {
// this, socket, EVENT_CONFIGURATION_SETTINGS), addUpdateHandler([&](const String &originId) { updateServos(); },
_fsPersistence(ServoConfiguration::read, ServoConfiguration::update, this, fs, SERVO_CONFIG_FILE) { false);
} }
void configure() { void configure() {
_httpEndpoint.begin(); _eventEndpoint.begin();
_fsPersistence.readFromFS(); _fsPersistence.readFromFS();
setOscillatorFrequency(_state.servo_oscillator_frequency); setOscillatorFrequency(_state.servo_oscillator_frequency);
setPWMFreq(_state.servo_pwm_frequency); setPWMFreq(_state.servo_pwm_frequency);
ESP_LOGI("ServoController", "Configured with oscillator frequency %d and PWM frequency %d", _state.servo_oscillator_frequency, _state.servo_pwm_frequency); deactivate();
ESP_LOGI("ServoController",
"Configured with oscillator frequency %d and PWM frequency %d",
_state.servo_oscillator_frequency, _state.servo_pwm_frequency);
} }
void deactivate() { void deactivate() {
if (!is_active) return;
_state.is_active = false; _state.is_active = false;
is_active = false;
sleep(); sleep();
} }
void activate() { void activate() {
if (is_active) return;
_state.is_active = true; _state.is_active = true;
sleep(); is_active = true;
wakeup();
}
void updateActiveState() { _state.is_active ? activate() : deactivate(); }
void updateServos() {
updateActiveState();
if (!is_active) return;
for (auto &servo : _state.servos_config) {
setAngle(&servo);
}
}
void setAngle(servo_t* servo) {
int8_t channel = servo->channel;
bool invert = servo->inverted;
int16_t angle = invert ? 180 - servo->angle : servo->angle;
ESP_LOGV("ServoController", "Setting servo %d to angle %d", channel, angle);
setPWM(channel, 0, angleToPwm(angle));
}
uint16_t angleToPwm(int angle) {
return map(angle, 0, 180, SERVO_MIN, SERVO_MAX);
}
void updateServoState() {
for (auto &servo : _state.servos_config) {
if (servo.state == SERVO_STATE::SERVO_STATE_ACTIVE) {
continue;
} else if (servo.state == SERVO_STATE::SERVO_STATE_SWEEPING_FORWARD) {
servo.angle += 1;
if (servo.angle >= 180) {
servo.state = SERVO_STATE::SERVO_STATE_SWEEPING_BACKWARD;
}
} else if (servo.state == SERVO_STATE::SERVO_STATE_SWEEPING_BACKWARD) {
servo.angle -= 1;
if (servo.angle <= 0) {
servo.state = SERVO_STATE::SERVO_STATE_ACTIVE;
}
}
setAngle(&servo);
}
}
void loop() {
if (int currentMillis = millis(); !_lastUpdate || (currentMillis - _lastUpdate) >= ServoInterval) {
_lastUpdate = currentMillis;
updateServoState();
}
} }
private: private:
PsychicHttpServer *_server; PsychicHttpServer *_server;
SecurityManager *_securityManager; SecurityManager *_securityManager;
HttpEndpoint<ServoConfiguration> _httpEndpoint; EventEndpoint<ServoConfiguration> _eventEndpoint;
// EventEndpoint<ServoConfiguration> _eventEndpoint;
FSPersistence<ServoConfiguration> _fsPersistence; FSPersistence<ServoConfiguration> _fsPersistence;
bool is_active{true};
unsigned long _lastUpdate;
constexpr static int ServoInterval = 100;
}; };
esp32/platformio.ini
+1 -1
View File
@@ -69,7 +69,7 @@ build_flags =
${factory_settings.build_flags} ${factory_settings.build_flags}
${features.build_flags} ${features.build_flags}
${build_settings.build_flags} ${build_settings.build_flags}
-D CORE_DEBUG_LEVEL=3 -D CORE_DEBUG_LEVEL=4
-D register= -D register=
-std=gnu++17 -std=gnu++17
build_unflags = -std=gnu++11 build_unflags = -std=gnu++11