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';
const socketEvents = ['open', 'close', 'error', 'message', 'unresponsive'] as const;
type SocketEvent = (typeof socketEvents)[number];
function createWebSocket() {
let listeners = new Map<string, Set<(data?: unknown) => void>>();
const { subscribe, set } = writable(false);
const socketEvents = ['open', 'close', 'error', 'message', 'unresponsive'] as const;
type SocketEvent = (typeof socketEvents)[number];
const reconnectTimeoutTime = 5000;
let unresponsiveTimeoutId: number;
let reconnectTimeoutId: number;
let ws: WebSocket;
@@ -21,7 +23,7 @@ function createWebSocket() {
clearTimeout(unresponsiveTimeoutId);
clearTimeout(reconnectTimeoutId);
listeners.get(reason)?.forEach((listener) => listener(event));
reconnectTimeoutId = setTimeout(connect, 1000);
reconnectTimeoutId = setTimeout(connect, reconnectTimeoutTime);
}
function connect() {
@@ -74,7 +76,7 @@ function createWebSocket() {
function resetUnresponsiveCheck() {
clearTimeout(unresponsiveTimeoutId);
unresponsiveTimeoutId = setTimeout(() => disconnect('unresponsive'), 2000);
unresponsiveTimeoutId = setTimeout(() => disconnect('unresponsive'), reconnectTimeoutTime);
}
function send(msg: unknown) {
app/src/routes/peripherals/servo/servo.svelte
+8 -1
View File
@@ -1,6 +1,13 @@
<script lang="ts">
import type { Servo } from "$lib/models";
import { createEventDispatcher } from "svelte";
export let servo: Servo;
const dispatch = createEventDispatcher();
const sweep = () => {
dispatch('sweep', {channel: servo.channel});
};
</script>
<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 end-0 -bottom-6">180</span>
</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>
app/src/routes/peripherals/servo/servos.svelte
+93 -42
View File
@@ -1,51 +1,102 @@
<script lang="ts">
import SettingsCard from "$lib/components/SettingsCard.svelte";
import type { ServoConfiguration } from "$lib/models";
import MotorOutline from '~icons/mdi/motor-outline';
import Servo from './servo.svelte';
import { api } from "$lib/api";
import Spinner from "$lib/components/Spinner.svelte";
import SettingsCard from '$lib/components/SettingsCard.svelte';
import type { ServoConfiguration, Servo } from '$lib/models';
import MotorOutline from '~icons/mdi/motor-outline';
import ServoController from './servo.svelte';
import { api } from '$lib/api';
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) => {
let result = await api.post('/api/servo/configuration', servo_config)
}
$: updateServoConfig(servo_config, servos);
const getServoConfig = async () => {
let result = await api.get<ServoConfiguration>('/api/servo/configuration')
if (result.isOk()) {
servo_config = result.inner
return result.inner
}
}
const updateServoConfig = async (servo_config: ServoConfiguration, servos: Servo[]) => {
if (!servo_config) return;
const changes: { [key: string]: any } = {};
for (const key of Object.keys(servo_config)) {
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>
<SettingsCard collapsible={false}>
<MotorOutline slot="icon" class="lex-shrink-0 mr-2 h-6 w-6 self-end" />
<span slot="title">Servo</span>
<MotorOutline slot="icon" class="lex-shrink-0 mr-2 h-6 w-6 self-end" />
<span slot="title">Servo</span>
{#await getServoConfig() }
<Spinner />
{:then _}
<div class="flex flex-col">
<h2 class="text-lg">General servo configuration</h2>
<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"/>
</span>
<span class="flex justify-between items-center mb-1">
Servo PWM Frequency <input type="number" bind:value={servo_config.servo_pwm_frequency} class="input input-bordered input-sm max-w-xs"/>
</span>
<span class="flex justify-between items-center gap-1">
Is active <input type="checkbox" bind:value={servo_config.is_active} class="toggle"/>
</span>
</div>
<div class="divider"></div>
{#each servo_config.servos as servo}
<Servo {servo} />
<div class="divider"></div>
{/each}
{/await}
</SettingsCard>
{#if isLoading}
<Spinner />
{:else}
<div class="flex flex-col">
<h2 class="text-lg">General servo configuration</h2>
<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"
/>
</span>
<span class="flex justify-between items-center mb-1">
Servo PWM Frequency <input
type="number"
bind:value={servo_config.servo_pwm_frequency}
class="input input-bordered input-sm max-w-xs"
/>
</span>
<span class="flex justify-between items-center gap-1">
Is active <input type="checkbox" bind:checked={servo_config.is_active} class="toggle" />
</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_ANALYTICS=1
-D FT_MOTION=0
; Hardware specific
-D FT_IMU=0
-D FT_MAG=0
-D FT_BMP=0
esp32/lib/ESP32-sveltekit/ESP32SvelteKit.cpp
+3
View File
@@ -240,6 +240,9 @@ void IRAM_ATTR ESP32SvelteKit::_loop() {
#endif
#if FT_ENABLED(FT_MOTION)
_motionService.loop();
#endif
#if FT_ENABLED(FT_SERVO)
_servoController.loop();
#endif
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 <FSPersistence.h>
#include <HttpEndpoint.h>
#include <SecurityManager.h>
#include <StatefulService.h>
#include <Adafruit_PWMServoDriver.h>
#define SERVO_CONFIG_FILE "/config/servoConfig.json"
#define SERVO_CONFIGURATION_SETTINGS_PATH "/api/servo/configuration"
#define EVENT_CONFIGURATION_SETTINGS "servoConfiguration"
#ifndef FACTORY_SERVO_NUM
#define FACTORY_SERVO_NUM 12
#define FACTORY_SERVO_NUM 12
#endif
#ifndef FACTORY_SERVO_PWM_FREQUENCY
#define FACTORY_SERVO_PWM_FREQUENCY 50
#define FACTORY_SERVO_PWM_FREQUENCY 50
#endif
#ifndef FACTORY_SERVO_OSCILLATOR_FREQUENCY
#define FACTORY_SERVO_OSCILLATOR_FREQUENCY 27000000
#define FACTORY_SERVO_OSCILLATOR_FREQUENCY 27000000
#endif
#ifndef FACTORY_SERVO_CENTER_ANGLE
#define FACTORY_SERVO_CENTER_ANGLE 90
#define FACTORY_SERVO_CENTER_ANGLE 90
#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;
int8_t channel;
bool inverted;
int16_t angle;
int16_t center_angle;
bool inverted;
int16_t angle;
int16_t center_angle;
SERVO_STATE state;
};
class ServoConfiguration {
public:
int32_t servo_oscillator_frequency {FACTORY_SERVO_OSCILLATOR_FREQUENCY};
int32_t servo_pwm_frequency {FACTORY_SERVO_PWM_FREQUENCY};
int32_t servo_oscillator_frequency{FACTORY_SERVO_OSCILLATOR_FREQUENCY};
int32_t servo_pwm_frequency{FACTORY_SERVO_PWM_FREQUENCY};
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) {
root["is_active"] = settings.is_active;
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>();
for (auto &servo : settings.servos_config)
{
for (auto &servo : settings.servos_config) {
JsonObject servo_config = servos.add<JsonObject>();
servo_config["name"] = servo.name;
@@ -57,84 +64,182 @@ class ServoConfiguration {
servo_config["inverted"] = servo.inverted;
servo_config["angle"] = servo.angle;
servo_config["center_angle"] = servo.center_angle;
servo_config["state"] = servo.state;
}
}
static StateUpdateResult update(JsonObject &root, ServoConfiguration &settings) {
settings.is_active = root["is_active"] | false;
settings.servo_pwm_frequency = root["servo_pwm_frequency"] | FACTORY_SERVO_PWM_FREQUENCY;
settings.servo_oscillator_frequency = root["servo_oscillator_frequency"] | FACTORY_SERVO_OSCILLATOR_FREQUENCY;
settings.servos_config.clear();
static StateUpdateResult update(JsonObject &root,
ServoConfiguration &settings) {
settings.is_active = root["is_active"] | settings.is_active;
settings.servo_pwm_frequency =
root["servo_pwm_frequency"] | settings.servo_pwm_frequency;
settings.servo_oscillator_frequency =
root["servo_oscillator_frequency"] |
settings.servo_oscillator_frequency;
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>();
new_servo.channel = servo_config["channel"];
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 {
if (!root["servos"].is<JsonArray>() && settings.servos_config.empty()) {
ESP_LOGI("ControllerSettings", "No servos found, adding default servos");
for (int8_t i = 0; i < FACTORY_SERVO_NUM; i++) {
ESP_LOGI("WiFiSettings", "Adding servo %d", i);
settings.servos_config.push_back(servo_t {
.name = "Servo " + String(i),
.channel = i,
.inverted = 1,
.angle = 0,
.center_angle = FACTORY_SERVO_CENTER_ANGLE
});
ESP_LOGI("ControllerSettings", "Adding servo %d", i);
settings.servos_config.push_back(
servo_t{.name = "Servo " + String(i),
.channel = i,
.inverted = 1,
.angle = 0,
.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;
};
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:
ServoController(PsychicHttpServer *server, FS *fs, SecurityManager *securityManager, EventSocket *socket)
: Adafruit_PWMServoDriver(), _server(server),
ServoController(PsychicHttpServer *server, FS *fs,
SecurityManager *securityManager, EventSocket *socket)
: Adafruit_PWMServoDriver(),
_server(server),
_securityManager(securityManager),
_httpEndpoint(ServoConfiguration::read, ServoConfiguration::update,
this, server, SERVO_CONFIGURATION_SETTINGS_PATH,
securityManager, AuthenticationPredicates::IS_ADMIN),
// _eventEndpoint(ServoConfiguration::read, ServoConfiguration::update,
// this, socket, EVENT_CONFIGURATION_SETTINGS),
_fsPersistence(ServoConfiguration::read, ServoConfiguration::update, this, fs, SERVO_CONFIG_FILE) {
_eventEndpoint(ServoConfiguration::read, ServoConfiguration::update,
this, socket, EVENT_CONFIGURATION_SETTINGS),
_fsPersistence(ServoConfiguration::read, ServoConfiguration::update,
this, fs, SERVO_CONFIG_FILE) {
addUpdateHandler([&](const String &originId) { updateServos(); },
false);
}
void configure() {
_httpEndpoint.begin();
_eventEndpoint.begin();
_fsPersistence.readFromFS();
setOscillatorFrequency(_state.servo_oscillator_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() {
if (!is_active) return;
_state.is_active = false;
is_active = false;
sleep();
}
void activate() {
if (is_active) return;
_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:
PsychicHttpServer *_server;
SecurityManager *_securityManager;
HttpEndpoint<ServoConfiguration> _httpEndpoint;
// EventEndpoint<ServoConfiguration> _eventEndpoint;
EventEndpoint<ServoConfiguration> _eventEndpoint;
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}
${features.build_flags}
${build_settings.build_flags}
-D CORE_DEBUG_LEVEL=3
-D CORE_DEBUG_LEVEL=4
-D register=
-std=gnu++17
build_unflags = -std=gnu++11