Refactor project structure and update display logic
Reorganized source files into new directories for config, drivers, sensors, emotion engine, and UI. Removed legacy assets and code related to previous eye animation implementation. Added new display and touch drivers, emotion manager, shake detector, and UI components. Updated CMake project name to 'irobot_display'.
This commit is contained in:
@@ -5,4 +5,4 @@
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
add_compile_options("-Wno-format")
|
||||
project(example_qspi_with_ram)
|
||||
project(irobot_display)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@@ -1,257 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2023 Alastair Aitchison, Playful Technology, (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _ANIMATIONS_h
|
||||
#define _ANIMATIONS_h
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
class IAnimation {
|
||||
public:
|
||||
virtual float GetValue() = 0;
|
||||
virtual float GetValue(unsigned long overWriteMillis) = 0;
|
||||
virtual unsigned long GetElapsed() = 0;
|
||||
|
||||
private:
|
||||
virtual float Calculate(unsigned long elapsedMillis) = 0;
|
||||
};
|
||||
|
||||
class AnimationBase : IAnimation {
|
||||
public:
|
||||
AnimationBase(unsigned long interval) : Interval(interval), StarTime(millis()) {}
|
||||
|
||||
unsigned long Interval;
|
||||
unsigned long StarTime;
|
||||
|
||||
virtual void Restart() {
|
||||
StarTime = millis();
|
||||
}
|
||||
float GetValue() override final {
|
||||
return GetValue(GetElapsed());
|
||||
}
|
||||
float GetValue(unsigned long elapsedMillis) override final {
|
||||
return Calculate(elapsedMillis);
|
||||
}
|
||||
unsigned long GetElapsed() override {
|
||||
return static_cast<unsigned long> (millis() - StarTime);
|
||||
}
|
||||
|
||||
protected:
|
||||
float Calculate(unsigned long elapsedMillis) override { return 0.0; }
|
||||
};
|
||||
|
||||
class DeltaAnimation : public AnimationBase {
|
||||
public:
|
||||
unsigned long StarTime;
|
||||
DeltaAnimation(unsigned long interval) : AnimationBase(interval) {};
|
||||
float Calculate(unsigned long elapsedMillis) {
|
||||
if (elapsedMillis < Interval) {
|
||||
return 0.0f;
|
||||
}
|
||||
else {
|
||||
return 1.0f;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
class StepAnimation : public AnimationBase {
|
||||
public:
|
||||
unsigned long Interval;
|
||||
unsigned long StarTime;
|
||||
bool IsActive = true;
|
||||
StepAnimation(unsigned long interval) : AnimationBase(interval) {};
|
||||
|
||||
float Calculate(unsigned long elapsedMillis) {
|
||||
if (elapsedMillis < Interval) {
|
||||
return 0.0f;
|
||||
}
|
||||
return 1.0f;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
class RampAnimation : public AnimationBase {
|
||||
public:
|
||||
|
||||
unsigned long StarTime;
|
||||
bool IsActive = true;
|
||||
|
||||
RampAnimation(unsigned long interval) : AnimationBase(interval) {};
|
||||
|
||||
float Calculate(unsigned long elapsedMillis) {
|
||||
if (elapsedMillis < Interval) {
|
||||
return static_cast<float>(elapsedMillis) / Interval;
|
||||
}
|
||||
return 1.0f;
|
||||
};
|
||||
};
|
||||
|
||||
class TriangleAnimation : public AnimationBase {
|
||||
public:
|
||||
|
||||
TriangleAnimation(unsigned long interval) : AnimationBase(interval) {
|
||||
_t0 = interval / 2;
|
||||
_t1 = interval - _t0;
|
||||
}
|
||||
TriangleAnimation(unsigned long t0, unsigned long t1) : AnimationBase(t0 + t1) {
|
||||
_t0 = t0;
|
||||
_t1 = t1;
|
||||
};
|
||||
float Calculate(unsigned long elapsedMillis) {
|
||||
if (elapsedMillis % Interval < _t0) {
|
||||
return static_cast<float>(elapsedMillis % Interval) / _t0;
|
||||
}
|
||||
return 1.0f - (static_cast<float>(elapsedMillis % Interval) - _t0) / _t1;
|
||||
};
|
||||
unsigned long _t0;
|
||||
unsigned long _t1;
|
||||
};
|
||||
|
||||
|
||||
class TrapeziumAnimation : public AnimationBase {
|
||||
public:
|
||||
TrapeziumAnimation(unsigned long t) : AnimationBase(t) {
|
||||
_t0 = t / 3;
|
||||
_t1 = _t0;
|
||||
_t2 = t - _t0 - _t1;
|
||||
};
|
||||
TrapeziumAnimation(unsigned long t0, unsigned long t1, unsigned long t2) : AnimationBase(t0 + t1 + t2) {
|
||||
_t0 = t0;
|
||||
_t1 = t1;
|
||||
_t2 = t2;
|
||||
};
|
||||
float Calculate(unsigned long elapsedMillis) override {
|
||||
if (elapsedMillis > Interval) return 0.0;
|
||||
if (elapsedMillis < _t0) {
|
||||
return static_cast<float>(elapsedMillis) / _t0;
|
||||
}
|
||||
else if (elapsedMillis < _t0 + _t1) {
|
||||
return 1.0f;
|
||||
}
|
||||
else {
|
||||
return 1.0f - (static_cast<float>(elapsedMillis) - _t1 - _t0) / _t2;
|
||||
}
|
||||
};
|
||||
|
||||
unsigned long _t0;
|
||||
unsigned long _t1;
|
||||
unsigned long _t2;
|
||||
};
|
||||
|
||||
|
||||
class TrapeziumPulseAnimation : public AnimationBase {
|
||||
public:
|
||||
TrapeziumPulseAnimation(unsigned long t) : AnimationBase(t) {
|
||||
_t0 = 0;
|
||||
_t1 = t / 3;
|
||||
_t2 = t - _t0 - _t0;
|
||||
_t3 = _t1;
|
||||
_t4 = 0;
|
||||
};
|
||||
|
||||
TrapeziumPulseAnimation(unsigned long t0, unsigned long t1, unsigned long t2) : AnimationBase(t0 + t1 + t2) {
|
||||
_t0 = 0;
|
||||
_t1 = t0;
|
||||
_t2 = t1;
|
||||
_t3 = t2;
|
||||
_t4 = 0;
|
||||
};
|
||||
|
||||
TrapeziumPulseAnimation(unsigned long t0, unsigned long t1, unsigned long t2, unsigned long t3, unsigned long t4) : AnimationBase(t0 + t1 + t2 + t3 + t4) {
|
||||
_t0 = t0;
|
||||
_t1 = t1;
|
||||
_t2 = t2;
|
||||
_t3 = t3;
|
||||
_t4 = t4;
|
||||
};
|
||||
|
||||
float Calculate(unsigned long elapsedMillis) override {
|
||||
unsigned long elapsed = elapsedMillis % Interval;
|
||||
|
||||
if (elapsed < _t0) {
|
||||
return 0.0;
|
||||
}
|
||||
if (elapsed < _t0 + _t1) {
|
||||
return static_cast<float>(elapsed - _t0) / _t1;
|
||||
}
|
||||
else if (elapsed < _t0 + _t1 + _t2) {
|
||||
return 1.0f;
|
||||
}
|
||||
else if (elapsed < _t0 + _t1 + _t2 + _t3) {
|
||||
return 1.0f - (static_cast<float>(elapsed) - _t2 - _t1 - _t0) / _t3;
|
||||
}
|
||||
return 0.0;
|
||||
};
|
||||
|
||||
void SetInterval(uint16_t t) {
|
||||
_t0 = 0;
|
||||
_t1 = t / 3;
|
||||
_t2 = t - _t0 - _t0;
|
||||
_t3 = _t1;
|
||||
_t4 = 0;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
void SetTriangle(uint16_t t, uint16_t delay) {
|
||||
_t0 = 0;
|
||||
_t1 = t / 2;
|
||||
_t2 = 0;
|
||||
_t3 = _t1;
|
||||
_t4 = delay;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
void SetTriangleCuadrature(uint16_t t, uint16_t delay) {
|
||||
_t0 = delay;
|
||||
_t1 = t / 2;
|
||||
_t2 = 0;
|
||||
_t3 = _t1;
|
||||
_t4 = 0;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
void SetPulse(uint16_t t, uint16_t delay) {
|
||||
_t0 = 0;
|
||||
_t1 = t / 3;
|
||||
_t2 = t - _t0 - _t0;
|
||||
_t3 = _t1;
|
||||
_t4 = delay;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
void SetPulseCuadrature(uint16_t t, uint16_t delay) {
|
||||
_t0 = delay;
|
||||
_t1 = t / 3;
|
||||
_t2 = t - _t0 - _t0;
|
||||
_t3 = _t1;
|
||||
_t4 = 0;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
void SetInterval(uint16_t t0, uint16_t t1, uint16_t t2, uint16_t t3, uint16_t t4) {
|
||||
_t0 = t0;
|
||||
_t1 = t1;
|
||||
_t2 = t2;
|
||||
_t3 = t3;
|
||||
_t4 = t4;
|
||||
Interval = _t0 + _t1 + _t2 + _t3 + _t4;
|
||||
}
|
||||
|
||||
unsigned long _t0;
|
||||
unsigned long _t1;
|
||||
unsigned long _t2;
|
||||
unsigned long _t3;
|
||||
unsigned long _t4;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,69 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2023 Alastair Aitchison, Playful Technology, (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "AsyncTimer.h"
|
||||
|
||||
AsyncTimer::AsyncTimer(unsigned long millisInterval) : AsyncTimer(millisInterval, nullptr) {}
|
||||
|
||||
AsyncTimer::AsyncTimer(unsigned long millisInterval, AsyncTimerCallback onFinish) {
|
||||
Interval = millisInterval;
|
||||
OnFinish = onFinish;
|
||||
}
|
||||
|
||||
void AsyncTimer::Start() {
|
||||
Reset();
|
||||
_isActive = true;
|
||||
}
|
||||
|
||||
void AsyncTimer::Reset() {
|
||||
_startTime = millis();
|
||||
}
|
||||
|
||||
void AsyncTimer::Stop() {
|
||||
_isActive = false;
|
||||
}
|
||||
|
||||
bool AsyncTimer::Update() {
|
||||
if (_isActive == false) return false;
|
||||
|
||||
_isExpired = false;
|
||||
if (static_cast<unsigned long>(millis() - _startTime) >= Interval) {
|
||||
_isExpired = true;
|
||||
if (OnFinish != nullptr) OnFinish();
|
||||
Reset();
|
||||
}
|
||||
return _isExpired;
|
||||
}
|
||||
|
||||
void AsyncTimer::SetIntervalMillis(unsigned long interval) {
|
||||
Interval = interval;
|
||||
}
|
||||
|
||||
unsigned long AsyncTimer::GetStartTime() {
|
||||
return _startTime;
|
||||
}
|
||||
|
||||
unsigned long AsyncTimer::GetElapsedTime() {
|
||||
return millis() - _startTime;
|
||||
}
|
||||
|
||||
unsigned long AsyncTimer::GetRemainingTime() {
|
||||
return Interval - millis() + _startTime;
|
||||
}
|
||||
|
||||
bool AsyncTimer::IsActive() const {
|
||||
return _isActive;
|
||||
}
|
||||
|
||||
bool AsyncTimer::IsExpired() const{
|
||||
return _isExpired;
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2023 Alastair Aitchison, Playful Technology, (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _ASYNCTIMER_h
|
||||
#define _ASYNCTIMER_h
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
typedef void(*AsyncTimerCallback)();
|
||||
|
||||
class AsyncTimer {
|
||||
public:
|
||||
AsyncTimer(unsigned long millisInterval);
|
||||
AsyncTimer(unsigned long millisInterval, AsyncTimerCallback OnFinish);
|
||||
|
||||
void Start();
|
||||
void Reset();
|
||||
void Stop();
|
||||
bool Update();
|
||||
|
||||
void SetIntervalMillis(unsigned long interval);
|
||||
|
||||
unsigned long GetStartTime();
|
||||
unsigned long GetElapsedTime();
|
||||
unsigned long GetRemainingTime();
|
||||
|
||||
bool IsActive() const;
|
||||
bool IsExpired() const;
|
||||
|
||||
unsigned long Interval;
|
||||
|
||||
AsyncTimerCallback OnFinish;
|
||||
|
||||
private:
|
||||
bool _isActive;
|
||||
bool _isExpired;
|
||||
unsigned long _startTime;
|
||||
};
|
||||
#endif
|
||||
@@ -1,32 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "BlinkAssistant.h"
|
||||
#include "Face.h"
|
||||
|
||||
BlinkAssistant::BlinkAssistant(Face& face) : _face(face), Timer(3500) {
|
||||
Timer.Start();
|
||||
}
|
||||
|
||||
void BlinkAssistant::Update() {
|
||||
Timer.Update();
|
||||
|
||||
if (Timer.IsExpired()) {
|
||||
Blink();
|
||||
}
|
||||
}
|
||||
|
||||
void BlinkAssistant::Blink() {
|
||||
_face.LeftEye.BlinkTransformation.Animation.Restart();
|
||||
_face.RightEye.BlinkTransformation.Animation.Restart();
|
||||
Timer.Reset();
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _BLINKASSISTANT_h
|
||||
#define _BLINKASSISTANT_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Animations.h"
|
||||
#include "AsyncTimer.h"
|
||||
|
||||
class Face;
|
||||
|
||||
class BlinkAssistant {
|
||||
protected:
|
||||
Face& _face;
|
||||
|
||||
public:
|
||||
BlinkAssistant(Face& face);
|
||||
|
||||
AsyncTimer Timer;
|
||||
|
||||
void Update();
|
||||
void Blink();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,8 +0,0 @@
|
||||
#ifndef COMMON_h
|
||||
#define COMMON_h
|
||||
|
||||
#include <U8g2lib.h>
|
||||
|
||||
extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
|
||||
|
||||
#endif
|
||||
@@ -1,85 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "Eye.h"
|
||||
|
||||
Eye::Eye(Face& face) : _face(face) {
|
||||
|
||||
this->IsMirrored = false;
|
||||
|
||||
ChainOperators();
|
||||
Variation1.Animation._t0 = 200;
|
||||
Variation1.Animation._t1 = 200;
|
||||
Variation1.Animation._t2 = 200;
|
||||
Variation1.Animation._t3 = 200;
|
||||
Variation1.Animation._t4 = 0;
|
||||
Variation1.Animation.Interval = 800;
|
||||
|
||||
Variation2.Animation._t0 = 0;
|
||||
Variation2.Animation._t1 = 200;
|
||||
Variation2.Animation._t2 = 200;
|
||||
Variation2.Animation._t3 = 200;
|
||||
Variation2.Animation._t4 = 200;
|
||||
Variation2.Animation.Interval = 800;
|
||||
}
|
||||
|
||||
void Eye::ChainOperators() {
|
||||
Transition.Origin = &Config;
|
||||
Transformation.Input = &Config;
|
||||
Variation1.Input = &(Transformation.Output);
|
||||
Variation2.Input = &(Variation1.Output);
|
||||
BlinkTransformation.Input = &(Variation2.Output);
|
||||
FinalConfig = &(BlinkTransformation.Output);
|
||||
}
|
||||
|
||||
void Eye::Update() {
|
||||
Transition.Update();
|
||||
Transformation.Update();
|
||||
Variation1.Update();
|
||||
Variation2.Update();
|
||||
BlinkTransformation.Update();
|
||||
}
|
||||
|
||||
void Eye::Draw() {
|
||||
Update();
|
||||
EyeDrawer::Draw(CenterX, CenterY, FinalConfig);
|
||||
}
|
||||
|
||||
void Eye::ApplyPreset(const EyeConfig config) {
|
||||
Config.OffsetX = this->IsMirrored ? -config.OffsetX : config.OffsetX;
|
||||
Config.OffsetY = -config.OffsetY;
|
||||
Config.Height = config.Height;
|
||||
Config.Width = config.Width;
|
||||
Config.Slope_Top = this->IsMirrored ? config.Slope_Top : -config.Slope_Top;
|
||||
Config.Slope_Bottom = this->IsMirrored ? config.Slope_Bottom : -config.Slope_Bottom;
|
||||
Config.Radius_Top = config.Radius_Top;
|
||||
Config.Radius_Bottom = config.Radius_Bottom;
|
||||
Config.Inverse_Radius_Top = config.Inverse_Radius_Top;
|
||||
Config.Inverse_Radius_Bottom = config.Inverse_Radius_Bottom;
|
||||
|
||||
Transition.Animation.Restart();
|
||||
}
|
||||
|
||||
void Eye::TransitionTo(const EyeConfig config) {
|
||||
Transition.Destin.OffsetX = this->IsMirrored ? -config.OffsetX : config.OffsetX;
|
||||
Transition.Destin.OffsetY = -config.OffsetY;
|
||||
Transition.Destin.Height = config.Height;
|
||||
Transition.Destin.Width = config.Width;
|
||||
Transition.Destin.Slope_Top = this->IsMirrored ? config.Slope_Top : -config.Slope_Top;
|
||||
Transition.Destin.Slope_Bottom = this->IsMirrored ? config.Slope_Bottom : -config.Slope_Bottom;
|
||||
Transition.Destin.Radius_Top = config.Radius_Top;
|
||||
Transition.Destin.Radius_Bottom = config.Radius_Bottom;
|
||||
Transition.Destin.Inverse_Radius_Top = config.Inverse_Radius_Top;
|
||||
Transition.Destin.Inverse_Radius_Bottom = config.Inverse_Radius_Bottom;
|
||||
|
||||
Transition.Animation.Restart();
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYE_h
|
||||
#define _EYE_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Common.h"
|
||||
#include "Animations.h"
|
||||
#include "EyeConfig.h"
|
||||
#include "EyeDrawer.h"
|
||||
#include "EyeTransition.h"
|
||||
#include "EyeTransformation.h"
|
||||
#include "EyeVariation.h"
|
||||
#include "EyeBlink.h"
|
||||
#include "EyeVariation.h"
|
||||
|
||||
class Face;
|
||||
|
||||
class Eye {
|
||||
protected:
|
||||
Face& _face;
|
||||
|
||||
void Update();
|
||||
void ChainOperators();
|
||||
|
||||
public:
|
||||
Eye(Face& face);
|
||||
|
||||
uint16_t CenterX;
|
||||
uint16_t CenterY;
|
||||
bool IsMirrored = false;
|
||||
|
||||
EyeConfig Config;
|
||||
EyeConfig* FinalConfig;
|
||||
|
||||
EyeTransition Transition;
|
||||
EyeTransformation Transformation;
|
||||
EyeVariation Variation1;
|
||||
EyeVariation Variation2;
|
||||
EyeBlink BlinkTransformation;
|
||||
|
||||
void ApplyPreset(const EyeConfig preset);
|
||||
void TransitionTo(const EyeConfig preset);
|
||||
void Draw();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,41 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "EyeBlink.h"
|
||||
|
||||
|
||||
EyeBlink::EyeBlink() : Animation(40, 100, 40) { }
|
||||
|
||||
void EyeBlink::Update() {
|
||||
auto t = Animation.GetValue();
|
||||
if(Animation.GetElapsed() > Animation.Interval) t = 0.0;
|
||||
Apply(t * t);
|
||||
}
|
||||
|
||||
|
||||
void EyeBlink::Apply(float t) {
|
||||
Output.OffsetX = Input->OffsetX;
|
||||
Output.OffsetY = Input->OffsetY;
|
||||
|
||||
Output.Width = (BlinkWidth - Input->Width) * t + Input->Width;
|
||||
Output.Height = (BlinkHeight - Input->Height) * t + Input->Height;
|
||||
|
||||
Output.Slope_Top = Input->Slope_Top * (1.0 - t);
|
||||
Output.Slope_Bottom = Input->Slope_Bottom * (1.0 - t);
|
||||
Output.Radius_Top = Input->Radius_Top * (1.0 - t);
|
||||
Output.Radius_Bottom = Input->Radius_Bottom * (1.0 - t);
|
||||
Output.Inverse_Radius_Top = Input->Inverse_Radius_Top * (1.0 - t);
|
||||
Output.Inverse_Radius_Bottom = Input->Inverse_Radius_Bottom * (1.0 - t);
|
||||
Output.Inverse_Offset_Top = Input->Inverse_Offset_Top * (1.0 - t);
|
||||
Output.Inverse_Offset_Bottom = Input->Inverse_Offset_Bottom * (1.0 - t);
|
||||
}
|
||||
|
||||
@@ -1,38 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYEBLINK_h
|
||||
#define _EYEBLINK_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Animations.h"
|
||||
#include "EyeConfig.h"
|
||||
|
||||
class EyeBlink {
|
||||
protected:
|
||||
|
||||
public:
|
||||
EyeBlink();
|
||||
|
||||
EyeConfig* Input;
|
||||
EyeConfig Output;
|
||||
|
||||
TrapeziumAnimation Animation;
|
||||
|
||||
int32_t BlinkWidth = 60;
|
||||
int32_t BlinkHeight = 2;
|
||||
|
||||
void Update();
|
||||
void Apply(float t);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,38 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYECONFIG_h
|
||||
#define _EYECONFIG_h
|
||||
|
||||
#include <Arduino.h>
|
||||
struct EyeConfig
|
||||
{
|
||||
int16_t OffsetX;
|
||||
int16_t OffsetY;
|
||||
|
||||
int16_t Height;
|
||||
int16_t Width;
|
||||
|
||||
float Slope_Top;
|
||||
float Slope_Bottom;
|
||||
|
||||
int16_t Radius_Top;
|
||||
int16_t Radius_Bottom;
|
||||
|
||||
int16_t Inverse_Radius_Top;
|
||||
int16_t Inverse_Radius_Bottom;
|
||||
|
||||
int16_t Inverse_Offset_Top;
|
||||
int16_t Inverse_Offset_Bottom;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,212 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2023 Alastair Aitchison, Playful Technology, (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYEDRAWER_h
|
||||
#define _EYEDRAWER_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Common.h"
|
||||
#include "EyeConfig.h"
|
||||
|
||||
enum CornerType {T_R, T_L, B_L, B_R};
|
||||
|
||||
/**
|
||||
* Contains all functions to draw eye based on supplied (expression-based) config
|
||||
*/
|
||||
class EyeDrawer {
|
||||
public:
|
||||
static void Draw(int16_t centerX, int16_t centerY, EyeConfig *config) {
|
||||
// Amount by which corners will be shifted up/down based on requested "slope"
|
||||
int32_t delta_y_top = config->Height * config->Slope_Top / 2.0;
|
||||
int32_t delta_y_bottom = config->Height * config->Slope_Bottom / 2.0;
|
||||
// Full extent of the eye, after accounting for slope added at top and bottom
|
||||
auto totalHeight = config->Height + delta_y_top - delta_y_bottom;
|
||||
// If the requested top/bottom radius would exceed the height of the eye, adjust them downwards
|
||||
if (config->Radius_Bottom > 0 && config->Radius_Top > 0 && totalHeight - 1 < config->Radius_Bottom + config->Radius_Top) {
|
||||
int32_t corrected_radius_top = (float)config->Radius_Top * (totalHeight - 1) / (config->Radius_Bottom + config->Radius_Top);
|
||||
int32_t corrected_radius_bottom = (float)config->Radius_Bottom * (totalHeight - 1) / (config->Radius_Bottom + config->Radius_Top);
|
||||
config->Radius_Top = corrected_radius_top;
|
||||
config->Radius_Bottom = corrected_radius_bottom;
|
||||
}
|
||||
|
||||
// Calculate _inside_ corners of eye (TL, TR, BL, and BR) before any slope or rounded corners are applied
|
||||
int32_t TLc_y = centerY + config->OffsetY - config->Height/2 + config->Radius_Top - delta_y_top;
|
||||
int32_t TLc_x = centerX + config->OffsetX - config->Width/2 + config->Radius_Top;
|
||||
int32_t TRc_y = centerY + config->OffsetY - config->Height/2 + config->Radius_Top + delta_y_top;
|
||||
int32_t TRc_x = centerX + config->OffsetX + config->Width/2 - config->Radius_Top;
|
||||
int32_t BLc_y = centerY + config->OffsetY + config->Height/2 - config->Radius_Bottom - delta_y_bottom;
|
||||
int32_t BLc_x = centerX + config->OffsetX - config->Width/2 + config->Radius_Bottom;
|
||||
int32_t BRc_y = centerY + config->OffsetY + config->Height/2 - config->Radius_Bottom + delta_y_bottom;
|
||||
int32_t BRc_x = centerX + config->OffsetX + config->Width/2 - config->Radius_Bottom;
|
||||
|
||||
// Calculate interior extents
|
||||
int32_t min_c_x = min(TLc_x, BLc_x);
|
||||
int32_t max_c_x = max(TRc_x, BRc_x);
|
||||
int32_t min_c_y = min(TLc_y, TRc_y);
|
||||
int32_t max_c_y = max(BLc_y, BRc_y);
|
||||
|
||||
// Fill eye centre
|
||||
EyeDrawer::FillRectangle(min_c_x, min_c_y, max_c_x, max_c_y, 1);
|
||||
|
||||
// Fill eye outwards to meet edges of rounded corners
|
||||
EyeDrawer::FillRectangle(TRc_x, TRc_y, BRc_x + config->Radius_Bottom, BRc_y, 1); // Right
|
||||
EyeDrawer::FillRectangle(TLc_x - config->Radius_Top, TLc_y, BLc_x, BLc_y, 1); // Left
|
||||
EyeDrawer::FillRectangle(TLc_x, TLc_y - config->Radius_Top, TRc_x, TRc_y, 1); // Top
|
||||
EyeDrawer::FillRectangle(BLc_x, BLc_y, BRc_x, BRc_y + config->Radius_Bottom, 1); // Bottom
|
||||
|
||||
// Draw slanted edges at top of bottom of eyes
|
||||
// +ve Slope_Top means eyes slope downwards towards middle of face
|
||||
if(config->Slope_Top > 0) {
|
||||
EyeDrawer::FillRectangularTriangle(TLc_x, TLc_y-config->Radius_Top, TRc_x, TRc_y-config->Radius_Top, 0);
|
||||
EyeDrawer::FillRectangularTriangle(TRc_x, TRc_y-config->Radius_Top, TLc_x, TLc_y-config->Radius_Top, 1);
|
||||
}
|
||||
else if(config->Slope_Top < 0) {
|
||||
EyeDrawer::FillRectangularTriangle(TRc_x, TRc_y-config->Radius_Top, TLc_x, TLc_y-config->Radius_Top, 0);
|
||||
EyeDrawer::FillRectangularTriangle(TLc_x, TLc_y-config->Radius_Top, TRc_x, TRc_y-config->Radius_Top, 1);
|
||||
}
|
||||
// Draw slanted edges at bottom of eyes
|
||||
if(config->Slope_Bottom > 0) {
|
||||
EyeDrawer::FillRectangularTriangle(BRc_x+config->Radius_Bottom, BRc_y+config->Radius_Bottom, BLc_x-config->Radius_Bottom, BLc_y+config->Radius_Bottom, 0);
|
||||
EyeDrawer::FillRectangularTriangle(BLc_x-config->Radius_Bottom, BLc_y+config->Radius_Bottom, BRc_x+config->Radius_Bottom, BRc_y+config->Radius_Bottom, 1);
|
||||
}
|
||||
else if (config->Slope_Bottom < 0) {
|
||||
EyeDrawer::FillRectangularTriangle(BLc_x-config->Radius_Bottom, BLc_y+config->Radius_Bottom, BRc_x+config->Radius_Bottom, BRc_y+config->Radius_Bottom, 0);
|
||||
EyeDrawer::FillRectangularTriangle(BRc_x+config->Radius_Bottom, BRc_y+config->Radius_Bottom, BLc_x-config->Radius_Bottom, BLc_y+config->Radius_Bottom, 1);
|
||||
}
|
||||
|
||||
// Draw corners (which extend "outwards" towards corner of screen from supplied coordinate values)
|
||||
if(config->Radius_Top > 0) {
|
||||
EyeDrawer::FillEllipseCorner(T_L, TLc_x, TLc_y, config->Radius_Top, config->Radius_Top, 1);
|
||||
EyeDrawer::FillEllipseCorner(T_R, TRc_x, TRc_y, config->Radius_Top, config->Radius_Top, 1);
|
||||
}
|
||||
if(config->Radius_Bottom > 0) {
|
||||
EyeDrawer::FillEllipseCorner(B_L, BLc_x, BLc_y, config->Radius_Bottom, config->Radius_Bottom, 1);
|
||||
EyeDrawer::FillEllipseCorner(B_R, BRc_x, BRc_y, config->Radius_Bottom, config->Radius_Bottom, 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw rounded corners
|
||||
static void FillEllipseCorner(CornerType corner, int16_t x0, int16_t y0, int32_t rx, int32_t ry, uint16_t color) {
|
||||
if (rx < 2) return;
|
||||
if (ry < 2) return;
|
||||
int32_t x, y;
|
||||
int32_t rx2 = rx * rx;
|
||||
int32_t ry2 = ry * ry;
|
||||
int32_t fx2 = 4 * rx2;
|
||||
int32_t fy2 = 4 * ry2;
|
||||
int32_t s;
|
||||
|
||||
if (corner == T_R) {
|
||||
for(x = 0, y = ry, s = 2 * ry2 + rx2 * (1 - 2 * ry); ry2 * x <= rx2 * y; x++) {
|
||||
u8g2.drawHLine(x0, y0 - y, x);
|
||||
if(s >= 0) {
|
||||
s += fx2 * (1 - y);
|
||||
y--;
|
||||
}
|
||||
s += ry2 * ((4 * x) + 6);
|
||||
}
|
||||
for(x = rx, y = 0, s = 2 * rx2 + ry2 * (1 - 2 * rx); rx2 * y <= ry2 * x; y++) {
|
||||
u8g2.drawHLine(x0, y0 - y, x);
|
||||
if (s >= 0) {
|
||||
s += fy2 * (1 - x);
|
||||
x--;
|
||||
}
|
||||
s += rx2 * ((4 * y) + 6);
|
||||
}
|
||||
}
|
||||
|
||||
else if (corner == B_R) {
|
||||
for (x = 0, y = ry, s = 2 * ry2 + rx2 * (1 - 2 * ry); ry2 * x <= rx2 * y; x++) {
|
||||
u8g2.drawHLine(x0, y0 + y -1, x);
|
||||
if (s >= 0) {
|
||||
s += fx2 * (1 - y);
|
||||
y--;
|
||||
}
|
||||
s += ry2 * ((4 * x) + 6);
|
||||
}
|
||||
for (x = rx, y = 0, s = 2 * rx2 + ry2 * (1 - 2 * rx); rx2 * y <= ry2 * x; y++) {
|
||||
u8g2.drawHLine(x0, y0 + y -1, x);
|
||||
if (s >= 0) {
|
||||
s += fy2 * (1 - x);
|
||||
x--;
|
||||
}
|
||||
s += rx2 * ((4 * y) + 6);
|
||||
}
|
||||
}
|
||||
|
||||
else if (corner == T_L) {
|
||||
for (x = 0, y = ry, s = 2 * ry2 + rx2 * (1 - 2 * ry); ry2 * x <= rx2 * y; x++) {
|
||||
u8g2.drawHLine(x0-x, y0 - y, x);
|
||||
if (s >= 0) {
|
||||
s += fx2 * (1 - y);
|
||||
y--;
|
||||
}
|
||||
s += ry2 * ((4 * x) + 6);
|
||||
}
|
||||
for (x = rx, y = 0, s = 2 * rx2 + ry2 * (1 - 2 * rx); rx2 * y <= ry2 * x; y++) {
|
||||
u8g2.drawHLine(x0-x, y0 - y, x);
|
||||
if (s >= 0) {
|
||||
s += fy2 * (1 - x);
|
||||
x--;
|
||||
}
|
||||
s += rx2 * ((4 * y) + 6);
|
||||
}
|
||||
}
|
||||
|
||||
else if (corner == B_L) {
|
||||
for (x = 0, y = ry, s = 2 * ry2 + rx2 * (1 - 2 * ry); ry2 * x <= rx2 * y; x++) {
|
||||
u8g2.drawHLine(x0-x, y0 + y - 1, x);
|
||||
if (s >= 0) {
|
||||
s += fx2 * (1 - y);
|
||||
y--;
|
||||
}
|
||||
s += ry2 * ((4 * x) + 6);
|
||||
}
|
||||
for (x = rx, y = 0, s = 2 * rx2 + ry2 * (1 - 2 * rx); rx2 * y <= ry2 * x; y++) {
|
||||
u8g2.drawHLine(x0-x, y0 + y , x);
|
||||
if (s >= 0) {
|
||||
s += fy2 * (1 - x);
|
||||
x--;
|
||||
}
|
||||
s += rx2 * ((4 * y) + 6);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fill a solid rectangle between specified coordinates
|
||||
static void FillRectangle(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t color) {
|
||||
// Always draw from TL->BR
|
||||
int32_t l = min(x0, x1);
|
||||
int32_t r = max(x0, x1);
|
||||
int32_t t = min(y0, y1);
|
||||
int32_t b = max(y0, y1);
|
||||
int32_t w = r-l;
|
||||
int32_t h = b-t;
|
||||
u8g2.setDrawColor(color);
|
||||
u8g2.drawBox(l, t, w, h);
|
||||
u8g2.setDrawColor(1);
|
||||
}
|
||||
|
||||
static void FillRectangularTriangle(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t color) {
|
||||
u8g2.setDrawColor(color);
|
||||
u8g2.drawTriangle(x0, y0, x1, y1, x1, y0);
|
||||
u8g2.setDrawColor(1);
|
||||
}
|
||||
|
||||
static void FillTriangle(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t color) {
|
||||
u8g2.setDrawColor(color);
|
||||
u8g2.drawTriangle(x0, y0, x1, y1, x2, y2);
|
||||
u8g2.setDrawColor(1);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,398 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2023 Alastair Aitchison, Playful Technology, 2020 Luis Llamas (www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
/**
|
||||
* EyePresets.h
|
||||
* Defines the eye config associated with each emotion
|
||||
*/
|
||||
|
||||
#ifndef _EYEPRESETS_h
|
||||
#define _EYEPRESETS_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "EyeConfig.h"
|
||||
|
||||
static const EyeConfig Preset_Normal = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 40,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 8,
|
||||
.Radius_Bottom = 8,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Happy = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 10,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 10,
|
||||
.Radius_Bottom = 0,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Glee = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 8,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 8,
|
||||
.Radius_Bottom = 0,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 5,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Sad = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 15,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.5,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 1,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Worried = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 25,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.1,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 6,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Worried_Alt = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 35,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.2,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 6,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Focused = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 14,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0.2,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 3,
|
||||
.Radius_Bottom = 1,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Annoyed = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 12,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 0,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Annoyed_Alt = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 5,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 0,
|
||||
.Radius_Bottom = 4,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Surprised = {
|
||||
.OffsetX = -2,
|
||||
.OffsetY = 0,
|
||||
.Height = 45,
|
||||
.Width = 45,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 16,
|
||||
.Radius_Bottom = 16,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Skeptic = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 40,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 10,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Skeptic_Alt = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = -6,
|
||||
.Height = 26,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0.3,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 1,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Frustrated = {
|
||||
.OffsetX = 3,
|
||||
.OffsetY = -5,
|
||||
.Height = 12,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 0,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Unimpressed = {
|
||||
.OffsetX = 3,
|
||||
.OffsetY = 0,
|
||||
.Height = 12,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 1,
|
||||
.Radius_Bottom = 10,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Unimpressed_Alt = {
|
||||
.OffsetX = 3,
|
||||
.OffsetY = -3,
|
||||
.Height = 22,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 1,
|
||||
.Radius_Bottom = 16,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Sleepy = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = -2,
|
||||
.Height = 14,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.5,
|
||||
.Slope_Bottom = -0.5,
|
||||
.Radius_Top = 3,
|
||||
.Radius_Bottom = 3,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Sleepy_Alt = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = -2,
|
||||
.Height = 8,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.5,
|
||||
.Slope_Bottom = -0.5,
|
||||
.Radius_Top = 3,
|
||||
.Radius_Bottom = 3,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Suspicious = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = 0,
|
||||
.Height = 22,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 8,
|
||||
.Radius_Bottom = 3,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Suspicious_Alt = {
|
||||
.OffsetX = 0,
|
||||
.OffsetY = -3,
|
||||
.Height = 16,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0.2,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 6,
|
||||
.Radius_Bottom = 3,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Squint = {
|
||||
.OffsetX = -10,
|
||||
.OffsetY = -3,
|
||||
.Height = 35,
|
||||
.Width = 35,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 8,
|
||||
.Radius_Bottom = 8,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Squint_Alt = {
|
||||
.OffsetX = 5,
|
||||
.OffsetY = 0,
|
||||
.Height = 20,
|
||||
.Width = 20,
|
||||
.Slope_Top = 0,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 5,
|
||||
.Radius_Bottom = 5,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Angry = {
|
||||
.OffsetX = -3,
|
||||
.OffsetY = 0,
|
||||
.Height = 20,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0.3,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 2,
|
||||
.Radius_Bottom = 12,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Furious = {
|
||||
.OffsetX = -2,
|
||||
.OffsetY = 0,
|
||||
.Height = 30,
|
||||
.Width = 40,
|
||||
.Slope_Top = 0.4,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 2,
|
||||
.Radius_Bottom = 8,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Scared = {
|
||||
.OffsetX = -3,
|
||||
.OffsetY = 0,
|
||||
.Height = 40,
|
||||
.Width = 40,
|
||||
.Slope_Top = -0.1,
|
||||
.Slope_Bottom = 0,
|
||||
.Radius_Top = 12,
|
||||
.Radius_Bottom = 8,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
static const EyeConfig Preset_Awe = {
|
||||
.OffsetX = 2,
|
||||
.OffsetY = 0,
|
||||
.Height = 35,
|
||||
.Width = 45,
|
||||
.Slope_Top = -0.1,
|
||||
.Slope_Bottom = 0.1,
|
||||
.Radius_Top = 12,
|
||||
.Radius_Bottom = 12,
|
||||
.Inverse_Radius_Top = 0,
|
||||
.Inverse_Radius_Bottom = 0,
|
||||
.Inverse_Offset_Top = 0,
|
||||
.Inverse_Offset_Bottom = 0
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,61 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "EyeTransformation.h"
|
||||
|
||||
|
||||
EyeTransformation::EyeTransformation() : Animation(200)
|
||||
{
|
||||
}
|
||||
|
||||
void EyeTransformation::Update()
|
||||
{
|
||||
auto t = Animation.GetValue();
|
||||
Current.MoveX = (Destin.MoveX - Origin.MoveX) * t + Origin.MoveX;
|
||||
Current.MoveY = (Destin.MoveY - Origin.MoveY) * t + Origin.MoveY;
|
||||
Current.ScaleX = (Destin.ScaleX - Origin.ScaleX) * t + Origin.ScaleX;
|
||||
Current.ScaleY = (Destin.ScaleY - Origin.ScaleY) * t + Origin.ScaleY;
|
||||
|
||||
Apply();
|
||||
}
|
||||
|
||||
void EyeTransformation::Apply()
|
||||
{
|
||||
Output.OffsetX = Input->OffsetX + Current.MoveX;
|
||||
Output.OffsetY = Input->OffsetY - Current.MoveY;
|
||||
Output.Width = Input->Width * Current.ScaleX;
|
||||
Output.Height = Input->Height * Current.ScaleY;
|
||||
|
||||
Output.Slope_Top = Input->Slope_Top;
|
||||
Output.Slope_Bottom = Input->Slope_Bottom;
|
||||
Output.Radius_Top = Input->Radius_Top;
|
||||
Output.Radius_Bottom = Input->Radius_Bottom;
|
||||
Output.Inverse_Radius_Top = Input->Inverse_Radius_Top;
|
||||
Output.Inverse_Radius_Bottom = Input->Inverse_Radius_Bottom;
|
||||
Output.Inverse_Offset_Top = Input->Inverse_Offset_Top;
|
||||
Output.Inverse_Offset_Bottom = Input->Inverse_Offset_Bottom;
|
||||
}
|
||||
|
||||
void EyeTransformation::SetDestin(Transformation transformation)
|
||||
{
|
||||
Origin.MoveX = Current.MoveX;
|
||||
Origin.MoveY = Current.MoveY;
|
||||
Origin.ScaleX = Current.ScaleX;
|
||||
Origin.ScaleY = Current.ScaleY;
|
||||
|
||||
Destin.MoveX = transformation.MoveX;
|
||||
Destin.MoveY = transformation.MoveY;
|
||||
Destin.ScaleX = transformation.ScaleX;
|
||||
Destin.ScaleY = transformation.ScaleY;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYETRANSFORMATION_h
|
||||
#define _EYETRANSFORMATION_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Animations.h"
|
||||
#include "EyeConfig.h"
|
||||
|
||||
struct Transformation
|
||||
{
|
||||
float MoveX = 0.0;
|
||||
float MoveY = 0.0;
|
||||
float ScaleX = 1.0;
|
||||
float ScaleY = 1.0;
|
||||
};
|
||||
|
||||
class EyeTransformation
|
||||
{
|
||||
public:
|
||||
EyeTransformation();
|
||||
|
||||
EyeConfig* Input;
|
||||
EyeConfig Output;
|
||||
|
||||
Transformation Origin;
|
||||
Transformation Current;
|
||||
Transformation Destin;
|
||||
|
||||
RampAnimation Animation;
|
||||
|
||||
void Update();
|
||||
void Apply();
|
||||
void SetDestin(Transformation transformation);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "EyeTransition.h"
|
||||
|
||||
EyeTransition::EyeTransition() : Animation(500){}
|
||||
|
||||
void EyeTransition::Update() {
|
||||
float t = Animation.GetValue();
|
||||
Apply(t);
|
||||
}
|
||||
|
||||
void EyeTransition::Apply(float t) {
|
||||
Origin->OffsetX = Origin->OffsetX * (1.0 - t) + Destin.OffsetX * t;
|
||||
Origin->OffsetY = Origin->OffsetY * (1.0 - t) + Destin.OffsetY * t;
|
||||
Origin->Height = Origin->Height * (1.0 - t) + Destin.Height * t;
|
||||
Origin->Width = Origin->Width * (1.0 - t) + Destin.Width * t;
|
||||
Origin->Slope_Top = Origin->Slope_Top * (1.0 - t) + Destin.Slope_Top * t;
|
||||
Origin->Slope_Bottom = Origin->Slope_Bottom * (1.0 - t) + Destin.Slope_Bottom * t;
|
||||
Origin->Radius_Top = Origin->Radius_Top * (1.0 - t) + Destin.Radius_Top * t;
|
||||
Origin->Radius_Bottom = Origin->Radius_Bottom * (1.0 - t) + Destin.Radius_Bottom * t;
|
||||
Origin->Inverse_Radius_Top = Origin->Inverse_Radius_Top * (1.0 - t) + Destin.Inverse_Radius_Top * t;
|
||||
Origin->Inverse_Radius_Bottom = Origin->Inverse_Radius_Bottom * (1.0 - t) + Destin.Inverse_Radius_Bottom * t;
|
||||
Origin->Inverse_Offset_Top = Origin->Inverse_Offset_Top * (1.0 - t) + Destin.Inverse_Offset_Top * t;
|
||||
Origin->Inverse_Offset_Bottom = Origin->Inverse_Offset_Bottom * (1.0 - t) + Destin.Inverse_Offset_Bottom * t;
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYETRANSITION_h
|
||||
#define _EYETRANSITION_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Animations.h"
|
||||
#include "EyeConfig.h"
|
||||
|
||||
class EyeTransition {
|
||||
public:
|
||||
EyeTransition();
|
||||
|
||||
EyeConfig* Origin;
|
||||
EyeConfig Destin;
|
||||
|
||||
RampAnimation Animation;
|
||||
|
||||
void Update();
|
||||
void Apply(float t);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "EyeVariation.h"
|
||||
|
||||
EyeVariation::EyeVariation() : Animation(0, 1000, 0, 1000, 0){}
|
||||
|
||||
void EyeVariation::Clear() {
|
||||
Values.OffsetX = 0;
|
||||
Values.OffsetY = 0;
|
||||
Values.Height = 0;
|
||||
Values.Width = 0;
|
||||
Values.Slope_Top = 0;
|
||||
Values.Slope_Bottom = 0;
|
||||
Values.Radius_Top = 0;
|
||||
Values.Radius_Bottom = 0;
|
||||
Values.Inverse_Radius_Top = 0;
|
||||
Values.Inverse_Radius_Bottom = 0;
|
||||
Values.Inverse_Offset_Top = 0;
|
||||
Values.Inverse_Offset_Bottom = 0;
|
||||
}
|
||||
|
||||
void EyeVariation::Update() {
|
||||
auto t = Animation.GetValue();
|
||||
Apply(2.0 * t - 1.0);
|
||||
}
|
||||
|
||||
void EyeVariation::Apply(float t) {
|
||||
Output.OffsetX = Input->OffsetX + Values.OffsetX * t;
|
||||
Output.OffsetY = Input->OffsetY + Values.OffsetY * t;
|
||||
Output.Height = Input->Height + Values.Height * t;;
|
||||
Output.Width = Input->Width + Values.Width * t;
|
||||
Output.Slope_Top = Input->Slope_Top + Values.Slope_Top * t;
|
||||
Output.Slope_Bottom = Input->Slope_Bottom + Values.Slope_Bottom * t;
|
||||
Output.Radius_Top = Input->Radius_Top + Values.Radius_Top * t;
|
||||
Output.Radius_Bottom = Input->Radius_Bottom + Values.Radius_Bottom * t;
|
||||
Output.Inverse_Radius_Top = Input->Inverse_Radius_Top + Values.Inverse_Radius_Top * t;
|
||||
Output.Inverse_Radius_Bottom = Input->Inverse_Radius_Bottom + Values.Inverse_Radius_Bottom * t;
|
||||
Output.Inverse_Offset_Top = Input->Inverse_Offset_Top + Values.Inverse_Offset_Top * t;
|
||||
Output.Inverse_Offset_Bottom = Input->Inverse_Offset_Bottom + Values.Inverse_Offset_Bottom * t;;
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _EYEVARIATION_h
|
||||
#define _EYEVARIATION_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Animations.h"
|
||||
#include "EyeConfig.h"
|
||||
|
||||
class EyeVariation {
|
||||
public:
|
||||
EyeVariation();
|
||||
|
||||
EyeConfig* Input;
|
||||
EyeConfig Output;
|
||||
|
||||
TrapeziumPulseAnimation Animation;
|
||||
|
||||
EyeConfig Values;
|
||||
void Clear();
|
||||
|
||||
void SetInterval(uint16_t t0, uint16_t t1, uint16_t t2, uint16_t t3, uint16_t t4);
|
||||
|
||||
void Update();
|
||||
void Apply(float t);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,93 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
|
||||
#include "Face.h"
|
||||
#include "Common.h"
|
||||
|
||||
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 4, /* data= */ 5);
|
||||
|
||||
Face::Face(uint16_t screenWidth, uint16_t screenHeight, uint16_t eyeSize)
|
||||
: LeftEye(*this), RightEye(*this), Blink(*this), Look(*this), Behavior(*this), Expression(*this) {
|
||||
|
||||
// Unlike almost every other Arduino library (and the I2C address scanner script etc.)
|
||||
// u8g2 uses 8-bit I2C address, so we shift the 7-bit address left by one
|
||||
u8g2.setI2CAddress(0x3C<<1);
|
||||
u8g2.begin();
|
||||
u8g2.clearBuffer();
|
||||
|
||||
Width = screenWidth;
|
||||
Height = screenHeight;
|
||||
EyeSize = eyeSize;
|
||||
|
||||
CenterX = Width / 2;
|
||||
CenterY = Height / 2;
|
||||
|
||||
LeftEye.IsMirrored = true;
|
||||
|
||||
Behavior.Clear();
|
||||
Behavior.Timer.Start();
|
||||
}
|
||||
|
||||
void Face::LookFront() {
|
||||
Look.LookAt(0.0, 0.0);
|
||||
}
|
||||
|
||||
void Face::LookRight() {
|
||||
Look.LookAt(-1.0, 0.0);
|
||||
}
|
||||
|
||||
void Face::LookLeft() {
|
||||
Look.LookAt(1.0, 0.0);
|
||||
}
|
||||
|
||||
void Face::LookTop() {
|
||||
Look.LookAt(0.0, 1.0);
|
||||
}
|
||||
|
||||
void Face::LookBottom() {
|
||||
Look.LookAt(0.0, -1.0);
|
||||
}
|
||||
|
||||
void Face::Wait(unsigned long milliseconds) {
|
||||
unsigned long start;
|
||||
start = millis();
|
||||
while (millis() - start < milliseconds) {
|
||||
Draw();
|
||||
}
|
||||
}
|
||||
|
||||
void Face::DoBlink() {
|
||||
Blink.Blink();
|
||||
}
|
||||
|
||||
void Face::Update() {
|
||||
if(RandomBehavior) Behavior.Update();
|
||||
if(RandomLook) Look.Update();
|
||||
if(RandomBlink) Blink.Update();
|
||||
Draw();
|
||||
}
|
||||
|
||||
void Face::Draw() {
|
||||
// Clear the display
|
||||
u8g2.clearBuffer();
|
||||
// Draw left eye
|
||||
LeftEye.CenterX = CenterX - EyeSize / 2 - EyeInterDistance;
|
||||
LeftEye.CenterY = CenterY;
|
||||
LeftEye.Draw();
|
||||
// Draw right eye
|
||||
RightEye.CenterX = CenterX + EyeSize / 2 + EyeInterDistance;
|
||||
RightEye.CenterY = CenterY;
|
||||
RightEye.Draw();
|
||||
// Transfer the redrawn buffer to the display
|
||||
u8g2.sendBuffer();
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _FACE_h
|
||||
#define _FACE_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "Common.h"
|
||||
#include "Animations.h"
|
||||
#include "EyePresets.h"
|
||||
#include "Eye.h"
|
||||
#include "FaceExpression.h"
|
||||
#include "FaceBehavior.h"
|
||||
#include "LookAssistant.h"
|
||||
#include "BlinkAssistant.h"
|
||||
|
||||
class Face {
|
||||
|
||||
public:
|
||||
Face(uint16_t screenWidth, uint16_t screenHeight, uint16_t eyeSize);
|
||||
|
||||
uint16_t Width;
|
||||
uint16_t Height;
|
||||
uint16_t CenterX;
|
||||
uint16_t CenterY;
|
||||
uint16_t EyeSize;
|
||||
uint16_t EyeInterDistance = 4;
|
||||
|
||||
Eye LeftEye;
|
||||
Eye RightEye;
|
||||
BlinkAssistant Blink;
|
||||
LookAssistant Look;
|
||||
FaceBehavior Behavior;
|
||||
FaceExpression Expression;
|
||||
|
||||
void Update();
|
||||
void DoBlink();
|
||||
|
||||
bool RandomBehavior = true;
|
||||
bool RandomLook = true;
|
||||
bool RandomBlink = true;
|
||||
|
||||
void LookLeft();
|
||||
void LookRight();
|
||||
void LookFront();
|
||||
void LookTop();
|
||||
void LookBottom();
|
||||
void Wait(unsigned long milliseconds);
|
||||
|
||||
protected:
|
||||
void Draw();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,103 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "Face.h"
|
||||
#include "FaceBehavior.h"
|
||||
#include "FaceEmotions.hpp"
|
||||
|
||||
FaceBehavior::FaceBehavior(Face& face) : _face(face), Timer(500) {
|
||||
Timer.Start();
|
||||
Clear();
|
||||
Emotions[(int)eEmotions::Normal] = 1.0;
|
||||
}
|
||||
|
||||
void FaceBehavior::SetEmotion(eEmotions emotion, float value) {
|
||||
Emotions[emotion] = value;
|
||||
}
|
||||
|
||||
float FaceBehavior::GetEmotion(eEmotions emotion) {
|
||||
return Emotions[emotion];
|
||||
}
|
||||
|
||||
void FaceBehavior::Clear() {
|
||||
for (int emotion = 0; emotion < eEmotions::EMOTIONS_COUNT; emotion++) {
|
||||
Emotions[emotion] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
// Use roulette wheel to select a new emotion, based on assigned weights
|
||||
eEmotions FaceBehavior::GetRandomEmotion() {
|
||||
|
||||
// Calculate the total sum of all emotional weights
|
||||
float sum_of_weight = 0;
|
||||
for (int emotion = 0; emotion < eEmotions::EMOTIONS_COUNT; emotion++) {
|
||||
sum_of_weight += Emotions[emotion];
|
||||
}
|
||||
// If no weights have been assigned, default to "normal" emotion
|
||||
if (sum_of_weight == 0) {
|
||||
return eEmotions::Normal;
|
||||
}
|
||||
// Now pick a random number that lies somewhere in the range of total weights
|
||||
float rand = random(0, 1000 * sum_of_weight) / 1000.0;
|
||||
// Loop over emotions and select the one whose probabity distribution contains
|
||||
// the value in which the random number lies
|
||||
float acc = 0;
|
||||
for (int emotion = 0; emotion < eEmotions::EMOTIONS_COUNT; emotion++) {
|
||||
if (Emotions[emotion] == 0) continue;
|
||||
acc += Emotions[emotion];
|
||||
if (rand <= acc) {
|
||||
return (eEmotions)emotion;
|
||||
}
|
||||
}
|
||||
// If something goes wrong in the calculation, return "normal"
|
||||
return eEmotions::Normal;
|
||||
}
|
||||
|
||||
void FaceBehavior::Update() {
|
||||
Timer.Update();
|
||||
|
||||
if (Timer.IsExpired()) {
|
||||
Timer.Reset();
|
||||
eEmotions newEmotion = GetRandomEmotion();
|
||||
if (CurrentEmotion != newEmotion) {
|
||||
GoToEmotion(newEmotion);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FaceBehavior::GoToEmotion(eEmotions emotion) {
|
||||
// Set the currentEmotion to the desired emotion
|
||||
CurrentEmotion = emotion;
|
||||
|
||||
// Call the appropriate expression transition function
|
||||
switch (CurrentEmotion) {
|
||||
case eEmotions::Normal: _face.Expression.GoTo_Normal(); break;
|
||||
case eEmotions::Angry: _face.Expression.GoTo_Angry(); break;
|
||||
case eEmotions::Glee: _face.Expression.GoTo_Glee(); break;
|
||||
case eEmotions::Happy: _face.Expression.GoTo_Happy(); break;
|
||||
case eEmotions::Sad: _face.Expression.GoTo_Sad(); break;
|
||||
case eEmotions::Worried: _face.Expression.GoTo_Worried(); break;
|
||||
case eEmotions::Focused: _face.Expression.GoTo_Focused(); break;
|
||||
case eEmotions::Annoyed: _face.Expression.GoTo_Annoyed(); break;
|
||||
case eEmotions::Surprised: _face.Expression.GoTo_Surprised(); break;
|
||||
case eEmotions::Skeptic: _face.Expression.GoTo_Skeptic(); break;
|
||||
case eEmotions::Frustrated: _face.Expression.GoTo_Frustrated(); break;
|
||||
case eEmotions::Unimpressed: _face.Expression.GoTo_Unimpressed(); break;
|
||||
case eEmotions::Sleepy: _face.Expression.GoTo_Sleepy(); break;
|
||||
case eEmotions::Suspicious: _face.Expression.GoTo_Suspicious(); break;
|
||||
case eEmotions::Squint: _face.Expression.GoTo_Squint(); break;
|
||||
case eEmotions::Furious: _face.Expression.GoTo_Furious(); break;
|
||||
case eEmotions::Scared: _face.Expression.GoTo_Scared(); break;
|
||||
case eEmotions::Awe: _face.Expression.GoTo_Awe(); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _FACEBEHAVIOR_h
|
||||
#define _FACEBEHAVIOR_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "FaceEmotions.hpp"
|
||||
#include "AsyncTimer.h"
|
||||
|
||||
class Face;
|
||||
|
||||
class FaceBehavior
|
||||
{
|
||||
protected:
|
||||
Face& _face;
|
||||
|
||||
public:
|
||||
FaceBehavior(Face& face);
|
||||
|
||||
eEmotions CurrentEmotion;
|
||||
|
||||
float Emotions[eEmotions::EMOTIONS_COUNT];
|
||||
|
||||
AsyncTimer Timer;
|
||||
|
||||
void SetEmotion(eEmotions emotion, float value);
|
||||
float GetEmotion(eEmotions emotion);
|
||||
|
||||
void Clear();
|
||||
void Update();
|
||||
eEmotions GetRandomEmotion();
|
||||
|
||||
void GoToEmotion(eEmotions emotion);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _FACEEMOTIONS_h
|
||||
#define _FACEEMOTIONS_h
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
enum eEmotions {
|
||||
Normal=0,
|
||||
Angry,
|
||||
Glee,
|
||||
Happy,
|
||||
Sad,
|
||||
Worried,
|
||||
Focused,
|
||||
Annoyed,
|
||||
Surprised,
|
||||
Skeptic,
|
||||
Frustrated,
|
||||
Unimpressed,
|
||||
Sleepy,
|
||||
Suspicious,
|
||||
Squint,
|
||||
Furious,
|
||||
Scared,
|
||||
Awe,
|
||||
EMOTIONS_COUNT
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,181 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "FaceExpression.h"
|
||||
#include "Face.h"
|
||||
|
||||
FaceExpression::FaceExpression(Face& face) : _face(face)
|
||||
{
|
||||
}
|
||||
|
||||
void FaceExpression::ClearVariations()
|
||||
{
|
||||
_face.RightEye.Variation1.Clear();
|
||||
_face.RightEye.Variation2.Clear();
|
||||
_face.LeftEye.Variation1.Clear();
|
||||
_face.LeftEye.Variation2.Clear();
|
||||
_face.RightEye.Variation1.Animation.Restart();
|
||||
_face.LeftEye.Variation1.Animation.Restart();
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Normal()
|
||||
{
|
||||
ClearVariations();
|
||||
|
||||
_face.RightEye.Variation1.Values.Height = 3;
|
||||
_face.RightEye.Variation2.Values.Width = 1;
|
||||
_face.LeftEye.Variation1.Values.Height = 2;
|
||||
_face.LeftEye.Variation2.Values.Width = 2;
|
||||
_face.RightEye.Variation1.Animation.SetTriangle(1000, 0);
|
||||
_face.LeftEye.Variation1.Animation.SetTriangle(1000, 0);
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Normal);
|
||||
_face.LeftEye.TransitionTo(Preset_Normal);
|
||||
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Angry()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.Variation1.Values.OffsetY = 2;
|
||||
_face.LeftEye.Variation1.Values.OffsetY = 2;
|
||||
_face.RightEye.Variation1.Animation.SetTriangle(300, 0);
|
||||
_face.LeftEye.Variation1.Animation.SetTriangle(300, 0);
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Angry);
|
||||
_face.LeftEye.TransitionTo(Preset_Angry);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Glee()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.Variation1.Values.OffsetY = 5;
|
||||
_face.LeftEye.Variation1.Values.OffsetY = 5;
|
||||
_face.RightEye.Variation1.Animation.SetTriangle(300, 0);
|
||||
_face.LeftEye.Variation1.Animation.SetTriangle(300, 0);
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Glee);
|
||||
_face.LeftEye.TransitionTo(Preset_Glee);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Happy()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Happy);
|
||||
_face.LeftEye.TransitionTo(Preset_Happy);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Sad()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Sad);
|
||||
_face.LeftEye.TransitionTo(Preset_Sad);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Worried()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Worried);
|
||||
_face.LeftEye.TransitionTo(Preset_Worried_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Focused()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Focused);
|
||||
_face.LeftEye.TransitionTo(Preset_Focused);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Annoyed()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Annoyed);
|
||||
_face.LeftEye.TransitionTo(Preset_Annoyed_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Surprised()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Surprised);
|
||||
_face.LeftEye.TransitionTo(Preset_Surprised);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Skeptic()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Skeptic);
|
||||
_face.LeftEye.TransitionTo(Preset_Skeptic_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Frustrated()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Frustrated);
|
||||
_face.LeftEye.TransitionTo(Preset_Frustrated);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Unimpressed()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Unimpressed);
|
||||
_face.LeftEye.TransitionTo(Preset_Unimpressed_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Sleepy()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Sleepy);
|
||||
_face.LeftEye.TransitionTo(Preset_Sleepy_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Suspicious()
|
||||
{
|
||||
ClearVariations();
|
||||
_face.RightEye.TransitionTo(Preset_Suspicious);
|
||||
_face.LeftEye.TransitionTo(Preset_Suspicious_Alt);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Squint()
|
||||
{
|
||||
ClearVariations();
|
||||
|
||||
_face.LeftEye.Variation1.Values.OffsetX = 6;
|
||||
_face.LeftEye.Variation2.Values.OffsetY = 6;
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Squint);
|
||||
_face.LeftEye.TransitionTo(Preset_Squint_Alt);
|
||||
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Furious()
|
||||
{
|
||||
ClearVariations();
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Furious);
|
||||
_face.LeftEye.TransitionTo(Preset_Furious);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Scared()
|
||||
{
|
||||
ClearVariations();
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Scared);
|
||||
_face.LeftEye.TransitionTo(Preset_Scared);
|
||||
}
|
||||
|
||||
void FaceExpression::GoTo_Awe()
|
||||
{
|
||||
ClearVariations();
|
||||
|
||||
_face.RightEye.TransitionTo(Preset_Awe);
|
||||
_face.LeftEye.TransitionTo(Preset_Awe);
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _FACEEXPRESSION_h
|
||||
#define _FACEEXPRESSION_h
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
class Face;
|
||||
|
||||
class FaceExpression {
|
||||
protected:
|
||||
Face& _face;
|
||||
|
||||
public:
|
||||
FaceExpression(Face& face);
|
||||
|
||||
void ClearVariations();
|
||||
|
||||
void GoTo_Normal();
|
||||
void GoTo_Angry();
|
||||
void GoTo_Glee();
|
||||
void GoTo_Happy();
|
||||
void GoTo_Sad();
|
||||
void GoTo_Worried();
|
||||
void GoTo_Focused();
|
||||
void GoTo_Annoyed();
|
||||
void GoTo_Surprised();
|
||||
void GoTo_Skeptic();
|
||||
void GoTo_Frustrated();
|
||||
void GoTo_Unimpressed();
|
||||
void GoTo_Sleepy();
|
||||
void GoTo_Suspicious();
|
||||
void GoTo_Squint();
|
||||
void GoTo_Furious();
|
||||
void GoTo_Scared();
|
||||
void GoTo_Awe();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,674 +0,0 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
@@ -1,65 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#include "LookAssistant.h"
|
||||
#include "Face.h"
|
||||
#include "EyeTransformation.h"
|
||||
|
||||
LookAssistant::LookAssistant(Face& face) : _face(face), Timer(4000)
|
||||
{
|
||||
Timer.Start();
|
||||
}
|
||||
|
||||
void LookAssistant::LookAt(float x, float y)
|
||||
{
|
||||
int16_t moveX_x;
|
||||
int16_t moveY_x;
|
||||
int16_t moveY_y;
|
||||
float scaleY_x;
|
||||
float scaleY_y;
|
||||
|
||||
// What is this witchcraft...?!
|
||||
moveX_x = -25 * x;
|
||||
moveY_x = -3 * x;
|
||||
moveY_y = 20 * y;
|
||||
scaleY_x = 1.0 - x * 0.2;
|
||||
scaleY_y = 1.0 - (y > 0 ? y : -y) * 0.4;
|
||||
|
||||
transformation.MoveX = moveX_x;
|
||||
transformation.MoveY = moveY_y; //moveY_x + moveY_y;
|
||||
transformation.ScaleX = 1.0;
|
||||
transformation.ScaleY = scaleY_x * scaleY_y;
|
||||
_face.RightEye.Transformation.SetDestin(transformation);
|
||||
|
||||
moveY_x = +3 * x;
|
||||
scaleY_x = 1.0 + x * 0.2;
|
||||
transformation.MoveX = moveX_x;
|
||||
transformation.MoveY = + moveY_y; //moveY_x + moveY_y;
|
||||
transformation.ScaleX = 1.0;
|
||||
transformation.ScaleY = scaleY_x * scaleY_y;
|
||||
_face.LeftEye.Transformation.SetDestin(transformation);
|
||||
|
||||
_face.RightEye.Transformation.Animation.Restart();
|
||||
_face.LeftEye.Transformation.Animation.Restart();
|
||||
}
|
||||
|
||||
void LookAssistant::Update() {
|
||||
Timer.Update();
|
||||
|
||||
if (Timer.IsExpired()) {
|
||||
Timer.Reset();
|
||||
auto x = random(-50, 50);
|
||||
auto y = random(-50, 50);
|
||||
LookAt((float)x / 100, (float)y / 100);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
/***************************************************
|
||||
Copyright (c) 2020 Luis Llamas
|
||||
(www.luisllamas.es)
|
||||
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses
|
||||
****************************************************/
|
||||
|
||||
#ifndef _LOOKASSISTANT_h
|
||||
#define _LOOKASSISTANT_h
|
||||
|
||||
#include <Arduino.h>
|
||||
#include "EyeTransformation.h"
|
||||
#include "AsyncTimer.h"
|
||||
|
||||
class Face;
|
||||
|
||||
class LookAssistant
|
||||
{
|
||||
protected:
|
||||
Face& _face;
|
||||
|
||||
public:
|
||||
LookAssistant(Face& face);
|
||||
|
||||
Transformation transformation;
|
||||
|
||||
AsyncTimer Timer;
|
||||
|
||||
void LookAt(float x, float y);
|
||||
void Update();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
# esp32-eyes
|
||||
Emotive animated eyes on an OLED display, as inspired by Anki Cozmo etc.
|
||||
|
||||
Inspired by the expressive eye animations of the Anki "Cozmo" robot, this Arduino/ESP8266/ESP32 library displays a set of animated eyes on a small 128x64 OLED screen.
|
||||
|
||||
<img src="https://github.com/playfultechnology/esp32-eyes/blob/main/doc/anki-cozmo-faces-3-1024x576.jpg" />
|
||||
|
||||
|
||||
Unlike some libraries which display a set of pre-rendered bitmap images for each frame of animation, this library draws each frame dynamically from a programmatic set of parameters.
|
||||
|
||||
Heavily based on <a href="https://github.com/luisllamasbinaburo/ESP32_Faces/">this library</a>, although with significant adjustments:
|
||||
|
||||
- OLED (using <a href="https://github.com/olikraus/u8g2">u8g2</a>) rather than TFT (based on <a href="https://github.com/Bodmer/TFT_eSPI">eSPI_TFT</a>)
|
||||
- Horizontal rather than vertical alignment
|
||||
- Mirrored left/right eye animations
|
||||
- Automatic or manual blink and look direction
|
||||
|
||||
## Hardware Used
|
||||
- ESP32 with built-in OLED - https://www.aliexpress.com/item/4000065217965.html (though you can use pretty much any Arduino/ESP8266/ESP8266 and attach a generic I2C OLED)
|
||||
- 3x linear potentiometers - https://www.aliexpress.com/item/1005005859787527.html
|
||||
- Joystick module - https://www.aliexpress.com/item/32901984938.html
|
||||
|
||||
<img src="https://github.com/playfultechnology/esp32-eyes/blob/main/doc/Schematic_ESP32-OLED-Eyes.png" />
|
||||
|
||||
## Software Component Structure
|
||||
|
||||
- *Face* is the core object, consisting of left and right eye components, behaviour, expression, a look assistant, and a blink assistant. The outputs of these components are chained together to create the display on each frame:
|
||||
|
||||
- The Face *Behaviour* contains an array of weighted _Emotions_. There are currently 18 emotions, as defined in the enum in FaceEmotions.hpp.
|
||||
Each emotion can have an individual weight assigned to it, as follows:
|
||||
```
|
||||
face->Behavior.SetEmotion(eEmotions::Glee, 1.0);
|
||||
face->Behavior.SetEmotion(eEmotions::Anger, 0.5);
|
||||
```
|
||||
If ```face->RandomBehavior = true;``` (which is the default), then Face will use a roulette-wheel selection to randomly assign a new emotion based on their relative weights.
|
||||
The frequency with which the current emotion is re-evaluated is determined by the value passed to ```face->Behaviour.Timer.SetIntervalMillis();``` , although note that this does not always result in a change, since the same emotion may be selected as is currently active.
|
||||
If no weights have been assigned to any emotion, the face will default to "normal" emotion.
|
||||
|
||||
Note that emotions are _not_ blended together - the face only ever expresses one emotion at a time. The "weight" assigned to each emotion does not specify how they are composited together, but rather it states the relative probability with which any given emotion will be selected.
|
||||
|
||||
- *Expression* handles transitions of the eyes to a selected emotion. Each emotion has a preset configuration that defines the eye height, slope, radius, and offset for each emotion (defined in ```EyePresets.h```), and these are assigned by the corresponding ```GoTo_Emotion()``` function.
|
||||
|
||||
- The Blink assistant handles blinking. If ```face->RandomBlink = true;``` (the default), the eyes will automatically blink, with a frequency determined by the value passed to ```face->Blink.Timer.SetIntervalMillis();```
|
||||
The eyes may be blinked manually by calling ```face->DoBlink();```
|
||||
|
||||
- The Look assistant handles the global position of the eyes around the screen. If ```face->RandomLook = true;``` (the default), the eyes will randomly move around the screen, with a frequency determined by the value passed to ```face->Look.Timer.SetIntervalMillis();```
|
||||
The eyes may be set to look at any position by calling ```face->Look.LookAt(x, y);``` (where x and y range from -1.0 - 1.0)
|
||||
|
||||
|
||||
- Each eye is responsible for managing their own drawing operations to the display (in EyeDrawer.cpp)
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 550 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 51 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 85 KiB |
@@ -1,380 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
width="210mm"
|
||||
height="297mm"
|
||||
viewBox="0 0 210 297"
|
||||
version="1.1"
|
||||
id="svg1"
|
||||
inkscape:version="1.3 (0e150ed6c4, 2023-07-21)"
|
||||
sodipodi:docname="eyes.svg"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:svg="http://www.w3.org/2000/svg">
|
||||
<sodipodi:namedview
|
||||
id="namedview1"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#000000"
|
||||
borderopacity="0.25"
|
||||
inkscape:showpageshadow="2"
|
||||
inkscape:pageopacity="0.0"
|
||||
inkscape:pagecheckerboard="0"
|
||||
inkscape:deskcolor="#d1d1d1"
|
||||
inkscape:document-units="mm"
|
||||
showgrid="true"
|
||||
inkscape:zoom="1.8088339"
|
||||
inkscape:cx="247.12054"
|
||||
inkscape:cy="273.38055"
|
||||
inkscape:window-width="1920"
|
||||
inkscape:window-height="1057"
|
||||
inkscape:window-x="-8"
|
||||
inkscape:window-y="-8"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="layer1">
|
||||
<inkscape:grid
|
||||
id="grid2"
|
||||
units="px"
|
||||
originx="0"
|
||||
originy="0"
|
||||
spacingx="0.26458333"
|
||||
spacingy="0.26458334"
|
||||
empcolor="#0099e5"
|
||||
empopacity="0.30196078"
|
||||
color="#0099e5"
|
||||
opacity="0.14901961"
|
||||
empspacing="5"
|
||||
dotted="false"
|
||||
gridanglex="30"
|
||||
gridanglez="30"
|
||||
visible="true" />
|
||||
</sodipodi:namedview>
|
||||
<defs
|
||||
id="defs1">
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="Triangle"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path135" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="marker7"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path7" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="Triangle-6"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path135-1" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="marker7-5"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path7-6" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="Triangle-6-4"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path135-1-3" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="marker7-5-9"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path7-6-9" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="Triangle-6-4-1"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path135-1-3-4" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="marker7-5-9-3"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path7-6-9-4" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="Triangle-6-4-1-0"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path135-1-3-4-3" />
|
||||
</marker>
|
||||
<marker
|
||||
style="overflow:visible"
|
||||
id="marker7-5-9-3-5"
|
||||
refX="0"
|
||||
refY="0"
|
||||
orient="auto-start-reverse"
|
||||
inkscape:stockid="Triangle arrow"
|
||||
markerWidth="0.5"
|
||||
markerHeight="0.5"
|
||||
viewBox="0 0 1 1"
|
||||
inkscape:isstock="true"
|
||||
inkscape:collect="always"
|
||||
preserveAspectRatio="xMidYMid"
|
||||
markerUnits="userSpaceOnUse">
|
||||
<path
|
||||
transform="scale(0.5)"
|
||||
style="fill:context-stroke;fill-rule:evenodd;stroke:context-stroke;stroke-width:1pt"
|
||||
d="M 5.77,0 -2.88,5 V -5 Z"
|
||||
id="path7-6-9-4-7" />
|
||||
</marker>
|
||||
</defs>
|
||||
<g
|
||||
inkscape:label="Layer 1"
|
||||
inkscape:groupmode="layer"
|
||||
id="layer1">
|
||||
<path
|
||||
id="rect1"
|
||||
style="fill:#5c5cd6;stroke:#5c5cd6;fill-opacity:1;stroke-opacity:1"
|
||||
d="m 52.777002,65.007195 32.770035,8.466667 c 4.810658,1.242911 8.968641,4.000014 8.968641,8.968641 v 16.557491 c 0,4.968626 -1.354181,6.322816 -6.322808,6.322816 H 50.131169 c -4.968627,0 -6.322808,-1.35419 -6.322808,-6.322816 V 73.975836 c 0,-4.968627 4.157983,-10.211552 8.968641,-8.968641 z"
|
||||
sodipodi:nodetypes="sssssssss" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.851072;stroke-dasharray:0.851072, 0.851072;stroke-dashoffset:0"
|
||||
d="M 100.54166,80.697919 H 38.364582"
|
||||
id="path2"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.912251;stroke-dasharray:1.8245, 0.912251;stroke-dashoffset:0"
|
||||
d="M 107.15625,72.760419 H 35.718747"
|
||||
id="path2-6"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.855516;stroke-dasharray:0.855516, 0.855516;stroke-dashoffset:0"
|
||||
d="M 99.880204,99.218753 H 37.703126"
|
||||
id="path3"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.962267;stroke-dasharray:0.962267, 0.962267;stroke-dashoffset:0"
|
||||
d="m 48.947915,111.125 0,-50.270831"
|
||||
id="path4"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.963503;stroke-dasharray:0.963503, 0.963503;stroke-dashoffset:0"
|
||||
d="M 88.635414,60.854171 V 111.125"
|
||||
id="path5"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#Triangle);marker-end:url(#marker7)"
|
||||
d="m 34.395832,83.343753 c 0,14.552084 0,14.552084 0,14.552084"
|
||||
id="path6" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-size:3.52778px;font-family:'Gill Sans MT';-inkscape-font-specification:'Gill Sans MT';fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.499999;stroke-dasharray:none;stroke-dashoffset:0"
|
||||
x="22.274263"
|
||||
y="92.080513"
|
||||
id="text7"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan7"
|
||||
style="font-size:3.52778px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.5"
|
||||
x="22.274263"
|
||||
y="92.080513">Height</tspan></text>
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#Triangle-6);marker-end:url(#marker7-5)"
|
||||
d="m 51.593751,113.77084 35.718746,0"
|
||||
id="path6-9"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#Triangle-6-4);marker-end:url(#marker7-5-9)"
|
||||
d="m 91.281247,113.77084 2.645834,0"
|
||||
id="path6-9-4"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-size:3.52778px;font-family:'Gill Sans MT';-inkscape-font-specification:'Gill Sans MT';fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.499999;stroke-dasharray:none;stroke-dashoffset:0"
|
||||
x="64.306145"
|
||||
y="117.60609"
|
||||
id="text7-6"><tspan
|
||||
sodipodi:role="line"
|
||||
style="font-size:3.52778px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.5"
|
||||
x="64.306145"
|
||||
y="117.60609"
|
||||
id="tspan8">Width</tspan></text>
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-size:3.52777px;font-family:'Gill Sans MT';-inkscape-font-specification:'Gill Sans MT';fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.499999;stroke-dasharray:none;stroke-dashoffset:0"
|
||||
x="89.74733"
|
||||
y="118.82307"
|
||||
id="text9"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan9"
|
||||
style="stroke-width:0.5"
|
||||
x="89.74733"
|
||||
y="118.82307">Radius</tspan><tspan
|
||||
sodipodi:role="line"
|
||||
style="stroke-width:0.5"
|
||||
x="89.74733"
|
||||
y="123.23278"
|
||||
id="tspan10">Bottom</tspan></text>
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#Triangle-6-4-1);marker-end:url(#marker7-5-9-3)"
|
||||
d="m 99.218747,78.052086 0,-2.645834"
|
||||
id="path6-9-4-4"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-size:3.52777px;font-family:'Gill Sans MT';-inkscape-font-specification:'Gill Sans MT';fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.499999;stroke-dasharray:none;stroke-dashoffset:0"
|
||||
x="102.53122"
|
||||
y="76.646492"
|
||||
id="text9-2"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan9-6"
|
||||
style="stroke-width:0.5"
|
||||
x="102.53122"
|
||||
y="76.646492">Radius</tspan><tspan
|
||||
sodipodi:role="line"
|
||||
style="stroke-width:0.5"
|
||||
x="102.53122"
|
||||
y="81.056206"
|
||||
id="tspan10-3">Top</tspan></text>
|
||||
<path
|
||||
style="fill:none;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;stroke-dashoffset:0;marker-start:url(#Triangle-6-4-1-0);marker-end:url(#marker7-5-9-3-5)"
|
||||
d="m 92.604164,70.114586 0,-5.291667"
|
||||
id="path6-9-4-4-8"
|
||||
sodipodi:nodetypes="cc" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-size:3.52777px;font-family:'Gill Sans MT';-inkscape-font-specification:'Gill Sans MT';fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.499999;stroke-dasharray:none;stroke-dashoffset:0"
|
||||
x="95.266388"
|
||||
y="69.306709"
|
||||
id="text9-2-7"><tspan
|
||||
sodipodi:role="line"
|
||||
style="stroke-width:0.5"
|
||||
x="95.266388"
|
||||
y="69.306709"
|
||||
id="tspan10-3-5">Slope x Height</tspan></text>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 13 KiB |
@@ -1,90 +0,0 @@
|
||||
/***************************************************
|
||||
* ESP32-Eyes, Copyright (c) 2023 Alastair Aitchison, Playful Technology
|
||||
* Based on previous work by Luis Llamas (www.luisllamas.es)
|
||||
*
|
||||
****************************************************/
|
||||
|
||||
// INCLUDES
|
||||
// Built-in Arduino I2C library
|
||||
#include <Wire.h>
|
||||
// Defines all face functionality
|
||||
#include "Face.h"
|
||||
|
||||
// CONSTANTS
|
||||
const byte joystickPins[] = {25, 26};
|
||||
const byte blinkPin = 16;
|
||||
const byte moodPins[] = {12, 13, 15};
|
||||
const eEmotions moods[] = {eEmotions::Angry, eEmotions::Sad, eEmotions::Surprised};
|
||||
|
||||
// GLOBALS
|
||||
Face *face;
|
||||
|
||||
void setup(void) {
|
||||
// Create a serial connection
|
||||
Serial.begin(115200);
|
||||
Serial.println(__FILE__ __DATE__);
|
||||
|
||||
// Configure input pins
|
||||
pinMode(blinkPin, INPUT_PULLUP);
|
||||
|
||||
// Create a new face
|
||||
face = new Face(/* screenWidth = */ 128, /* screenHeight = */ 64, /* eyeSize = */ 40);
|
||||
// Assign the current expression
|
||||
face->Expression.GoTo_Normal();
|
||||
|
||||
// Assign a weight to each emotion
|
||||
//face->Behavior.SetEmotion(eEmotions::Normal, 1.0);
|
||||
//face->Behavior.SetEmotion(eEmotions::Angry, 1.0);
|
||||
//face->Behavior.SetEmotion(eEmotions::Sad, 1.0);
|
||||
// Automatically switch between behaviours (selecting new behaviour randomly based on the weight assigned to each emotion)
|
||||
face->RandomBehavior = true;
|
||||
|
||||
// Automatically blink
|
||||
face->RandomBlink = true;
|
||||
// Set blink rate
|
||||
face->Blink.Timer.SetIntervalMillis(4000);
|
||||
|
||||
// Automatically choose a new random direction to look
|
||||
face->RandomLook = false;
|
||||
}
|
||||
|
||||
float mapFloat(float x, float in_min, float in_max, float out_min, float out_max) {
|
||||
// Check if x is outside the input range
|
||||
if (x <= in_min) return out_min;
|
||||
if (x >= in_max) return out_max;
|
||||
|
||||
// Calculate the proportion of x relative to the input range
|
||||
float proportion = (x - in_min) / (in_max - in_min);
|
||||
|
||||
// Map the proportion to the output range and return the result
|
||||
return (proportion * (out_max - out_min)) + out_min;
|
||||
}
|
||||
|
||||
void loop(){
|
||||
static int lastMoveTime;
|
||||
|
||||
// To avoid making eyes too twitchy (and to allow time for previous move animation to end),
|
||||
// only recalculate new position every 500ms
|
||||
if(millis() - lastMoveTime > 500) {
|
||||
int yRaw = analogRead(25);
|
||||
int xRaw = analogRead(26);
|
||||
float y = mapFloat(yRaw, 0, 4095, 1.0, -1.0);
|
||||
float x = mapFloat(xRaw, 0, 4095, -1.0, 1.0);
|
||||
face->Look.LookAt(x, y);
|
||||
lastMoveTime = millis();
|
||||
}
|
||||
// Blink when joystick pressed in
|
||||
if(!digitalRead(blinkPin)){
|
||||
face->DoBlink();
|
||||
}
|
||||
|
||||
// Use this code to set a particular emotion from a button
|
||||
for(int i=0; i<3; i++){
|
||||
int32_t potValue = analogRead(moodPins[i]);
|
||||
float moodLevel = map(potValue, 0, 4095, 0.0, 2.0);
|
||||
face->Behavior.SetEmotion(moods[i], moodLevel);
|
||||
}
|
||||
|
||||
// Update the face!
|
||||
face->Update();
|
||||
}
|
||||
@@ -1,9 +1,24 @@
|
||||
idf_component_register(
|
||||
SRCS "blink_animation.c" "lottie_player.c" "example_qspi_with_ram.c" "splash_screen.c" "animated_eyes.c" "animated_eyes_demo.c" "shake_detector.cpp"
|
||||
INCLUDE_DIRS "."
|
||||
REQUIRES SensorLib json)
|
||||
SRCS
|
||||
"main.c"
|
||||
"drivers/display_driver.c"
|
||||
"drivers/touch_driver.c"
|
||||
"ui/splash_screen.c"
|
||||
"ui/assets/splash_screen/logo_iro.c"
|
||||
"ui/lottie_player.c"
|
||||
"sensors/shake_detector.cpp"
|
||||
"emotion-engine/emotion_manager.c"
|
||||
"emotion-engine/blink/blink_emotion.c"
|
||||
INCLUDE_DIRS
|
||||
"."
|
||||
"config"
|
||||
REQUIRES
|
||||
SensorLib
|
||||
json
|
||||
)
|
||||
|
||||
set_source_files_properties(
|
||||
${LV_DEMOS_SOURCES}
|
||||
PROPERTIES COMPILE_OPTIONS
|
||||
-DLV_LVGL_H_INCLUDE_SIMPLE)
|
||||
-DLV_LVGL_H_INCLUDE_SIMPLE
|
||||
)
|
||||
|
||||
@@ -1,845 +0,0 @@
|
||||
/**
|
||||
* @file animated_eyes.c
|
||||
* @brief Animated expressive eyes for LVGL - Implementation
|
||||
* Ported from esp32-eyes for LVGL/ESP-IDF
|
||||
*/
|
||||
|
||||
#include "animated_eyes.h"
|
||||
#include "esp_heap_caps.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static const char *TAG = "animated_eyes";
|
||||
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
||||
|
||||
// Get current time in milliseconds
|
||||
static inline uint32_t get_millis(void) {
|
||||
return (uint32_t)(esp_timer_get_time() / 1000);
|
||||
}
|
||||
|
||||
// Eye configuration structure
|
||||
typedef struct {
|
||||
int16_t offset_x, offset_y;
|
||||
int16_t height, width;
|
||||
float slope_top, slope_bottom;
|
||||
int16_t radius_top, radius_bottom;
|
||||
} eye_config_t;
|
||||
|
||||
// Transformation structure
|
||||
typedef struct {
|
||||
int16_t move_x, move_y;
|
||||
float scale_x, scale_y;
|
||||
} transformation_t;
|
||||
|
||||
// Animation state
|
||||
typedef struct {
|
||||
uint32_t start_time;
|
||||
uint32_t interval;
|
||||
uint32_t t0, t1, t2, t3, t4;
|
||||
} animation_t;
|
||||
|
||||
// Timer structure
|
||||
typedef struct {
|
||||
uint32_t start_time;
|
||||
uint32_t interval;
|
||||
bool is_active;
|
||||
bool is_expired;
|
||||
} async_timer_t;
|
||||
|
||||
// Eye state
|
||||
typedef struct {
|
||||
eye_config_t config;
|
||||
eye_config_t final_config;
|
||||
eye_config_t transition_dest;
|
||||
transformation_t transform_origin, transform_current, transform_dest;
|
||||
eye_config_t variation_values1, variation_values2;
|
||||
animation_t transition_anim, transform_anim, variation_anim1, variation_anim2,
|
||||
blink_anim;
|
||||
int16_t center_x, center_y;
|
||||
bool is_mirrored;
|
||||
} eye_state_t;
|
||||
|
||||
// Main animated eyes structure
|
||||
struct animated_eyes_t {
|
||||
lv_obj_t *canvas;
|
||||
lv_color_t *canvas_buf;
|
||||
animated_eyes_config_t config;
|
||||
|
||||
eye_state_t left_eye, right_eye;
|
||||
|
||||
animated_eyes_emotion_t current_emotion;
|
||||
float emotion_weights[EMOTION_COUNT];
|
||||
|
||||
async_timer_t behavior_timer, look_timer, blink_timer;
|
||||
|
||||
// Temporary emotion state
|
||||
bool is_temporary_emotion;
|
||||
animated_eyes_emotion_t saved_emotion;
|
||||
async_timer_t temporary_timer;
|
||||
|
||||
// Inertia state
|
||||
float inertia_x;
|
||||
float inertia_y;
|
||||
|
||||
uint16_t center_x, center_y;
|
||||
};
|
||||
|
||||
// Eye presets for different emotions
|
||||
static const eye_config_t PRESET_NORMAL = {0, 0, 40, 40, 0, 0, 8, 8};
|
||||
static const eye_config_t PRESET_HAPPY = {0, 0, 10, 40, 0, 0, 10, 0};
|
||||
static const eye_config_t PRESET_GLEE = {0, 0, 8, 40, 0, 0, 8, 0};
|
||||
static const eye_config_t PRESET_SAD = {0, 0, 15, 40, -0.5f, 0, 1, 10};
|
||||
static const eye_config_t PRESET_WORRIED = {0, 0, 25, 40, -0.1f, 0, 6, 10};
|
||||
static const eye_config_t PRESET_FOCUSED = {0, 0, 14, 40, 0.2f, 0, 3, 1};
|
||||
static const eye_config_t PRESET_ANNOYED = {0, 0, 12, 40, 0, 0, 0, 10};
|
||||
static const eye_config_t PRESET_SURPRISED = {-2, 0, 45, 45, 0, 0, 16, 16};
|
||||
static const eye_config_t PRESET_ANGRY = {-3, 0, 20, 40, 0.3f, 0, 2, 12};
|
||||
static const eye_config_t PRESET_FURIOUS = {-2, 0, 30, 40, 0.4f, 0, 2, 8};
|
||||
static const eye_config_t PRESET_SCARED = {-3, 0, 40, 40, -0.1f, 0, 12, 8};
|
||||
static const eye_config_t PRESET_AWE = {2, 0, 35, 45, -0.1f, 0.1f, 12, 12};
|
||||
static const eye_config_t PRESET_SLEEPY = {0, -2, 14, 40, -0.5f, -0.5f, 3, 3};
|
||||
static const eye_config_t PRESET_SUSPICIOUS = {0, 0, 22, 40, 0, 0, 8, 3};
|
||||
static const eye_config_t PRESET_SKEPTIC = {0, 0, 40, 40, 0, 0, 10, 10};
|
||||
static const eye_config_t PRESET_FRUSTRATED = {3, -5, 12, 40, 0, 0, 0, 10};
|
||||
static const eye_config_t PRESET_UNIMPRESSED = {3, 0, 12, 40, 0, 0, 1, 10};
|
||||
static const eye_config_t PRESET_SQUINT = {-10, -3, 35, 35, 0, 0, 8, 8};
|
||||
|
||||
// Timer functions
|
||||
static void timer_start(async_timer_t *timer, uint32_t interval) {
|
||||
timer->start_time = get_millis();
|
||||
timer->interval = interval;
|
||||
timer->is_active = true;
|
||||
timer->is_expired = false;
|
||||
}
|
||||
|
||||
static void timer_reset(async_timer_t *timer) {
|
||||
timer->start_time = get_millis();
|
||||
timer->is_expired = false;
|
||||
}
|
||||
|
||||
static void timer_update(async_timer_t *timer) {
|
||||
if (!timer->is_active)
|
||||
return;
|
||||
uint32_t now = get_millis();
|
||||
if (now - timer->start_time >= timer->interval) {
|
||||
timer->is_expired = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Animation functions
|
||||
static void anim_restart(animation_t *anim) { anim->start_time = get_millis(); }
|
||||
|
||||
static float anim_get_value(animation_t *anim) {
|
||||
uint32_t elapsed = get_millis() - anim->start_time;
|
||||
if (anim->interval == 0)
|
||||
return 0.0f;
|
||||
uint32_t pos = elapsed % anim->interval;
|
||||
|
||||
if (pos < anim->t0)
|
||||
return 0.0f;
|
||||
pos -= anim->t0;
|
||||
if (pos < anim->t1 && anim->t1 > 0)
|
||||
return (float)pos / anim->t1;
|
||||
pos -= anim->t1;
|
||||
if (pos < anim->t2)
|
||||
return 1.0f;
|
||||
pos -= anim->t2;
|
||||
if (pos < anim->t3 && anim->t3 > 0)
|
||||
return 1.0f - (float)pos / anim->t3;
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
static uint32_t anim_get_elapsed(animation_t *anim) {
|
||||
return get_millis() - anim->start_time;
|
||||
}
|
||||
|
||||
static void anim_set_trapezium(animation_t *anim, uint32_t t0, uint32_t t1,
|
||||
uint32_t t2, uint32_t t3, uint32_t t4) {
|
||||
anim->t0 = t0;
|
||||
anim->t1 = t1;
|
||||
anim->t2 = t2;
|
||||
anim->t3 = t3;
|
||||
anim->t4 = t4;
|
||||
anim->interval = t0 + t1 + t2 + t3 + t4;
|
||||
}
|
||||
|
||||
// Scale preset for larger screen
|
||||
static eye_config_t scale_preset(const eye_config_t *preset, float scale) {
|
||||
eye_config_t scaled = *preset;
|
||||
scaled.offset_x = (int16_t)(preset->offset_x * scale);
|
||||
scaled.offset_y = (int16_t)(preset->offset_y * scale);
|
||||
scaled.height = (int16_t)(preset->height * scale);
|
||||
scaled.width = (int16_t)(preset->width * scale);
|
||||
scaled.radius_top = (int16_t)(preset->radius_top * scale);
|
||||
scaled.radius_bottom = (int16_t)(preset->radius_bottom * scale);
|
||||
return scaled;
|
||||
}
|
||||
|
||||
// Initialize eye state
|
||||
static void eye_init(eye_state_t *eye, bool is_mirrored) {
|
||||
memset(eye, 0, sizeof(eye_state_t));
|
||||
eye->is_mirrored = is_mirrored;
|
||||
|
||||
eye->transform_current.scale_x = 1.0f;
|
||||
eye->transform_current.scale_y = 1.0f;
|
||||
eye->transform_dest.scale_x = 1.0f;
|
||||
eye->transform_dest.scale_y = 1.0f;
|
||||
eye->transform_origin.scale_x = 1.0f;
|
||||
eye->transform_origin.scale_y = 1.0f;
|
||||
|
||||
anim_set_trapezium(&eye->transition_anim, 0, 250, 0, 250, 0);
|
||||
anim_set_trapezium(&eye->transform_anim, 0, 100, 0, 100, 0);
|
||||
// Smoother blink: 150ms close, 50ms closed, 150ms open
|
||||
anim_set_trapezium(&eye->blink_anim, 0, 150, 50, 150, 0);
|
||||
anim_set_trapezium(&eye->variation_anim1, 200, 200, 200, 200, 0);
|
||||
anim_set_trapezium(&eye->variation_anim2, 0, 200, 200, 200, 200);
|
||||
}
|
||||
|
||||
// Apply preset to eye
|
||||
static void eye_apply_preset(eye_state_t *eye, const eye_config_t *preset,
|
||||
float scale) {
|
||||
eye_config_t scaled = scale_preset(preset, scale);
|
||||
eye->config = scaled;
|
||||
if (eye->is_mirrored) {
|
||||
eye->config.offset_x = -scaled.offset_x;
|
||||
eye->config.slope_top = scaled.slope_top;
|
||||
eye->config.slope_bottom = scaled.slope_bottom;
|
||||
} else {
|
||||
eye->config.slope_top = -scaled.slope_top;
|
||||
eye->config.slope_bottom = -scaled.slope_bottom;
|
||||
}
|
||||
eye->transition_dest = eye->config;
|
||||
}
|
||||
|
||||
// Transition eye to preset
|
||||
static void eye_transition_to(eye_state_t *eye, const eye_config_t *preset,
|
||||
float scale) {
|
||||
eye_config_t scaled = scale_preset(preset, scale);
|
||||
eye->transition_dest = scaled;
|
||||
if (eye->is_mirrored) {
|
||||
eye->transition_dest.offset_x = -scaled.offset_x;
|
||||
eye->transition_dest.slope_top = scaled.slope_top;
|
||||
eye->transition_dest.slope_bottom = scaled.slope_bottom;
|
||||
} else {
|
||||
eye->transition_dest.slope_top = -scaled.slope_top;
|
||||
eye->transition_dest.slope_bottom = -scaled.slope_bottom;
|
||||
}
|
||||
anim_restart(&eye->transition_anim);
|
||||
}
|
||||
|
||||
// Update eye animations
|
||||
static void eye_update(eye_state_t *eye) {
|
||||
// Transition update
|
||||
float t = anim_get_value(&eye->transition_anim);
|
||||
eye->config.offset_x =
|
||||
eye->config.offset_x * (1.0f - t) + eye->transition_dest.offset_x * t;
|
||||
eye->config.offset_y =
|
||||
eye->config.offset_y * (1.0f - t) + eye->transition_dest.offset_y * t;
|
||||
eye->config.height =
|
||||
eye->config.height * (1.0f - t) + eye->transition_dest.height * t;
|
||||
eye->config.width =
|
||||
eye->config.width * (1.0f - t) + eye->transition_dest.width * t;
|
||||
eye->config.slope_top =
|
||||
eye->config.slope_top * (1.0f - t) + eye->transition_dest.slope_top * t;
|
||||
eye->config.slope_bottom = eye->config.slope_bottom * (1.0f - t) +
|
||||
eye->transition_dest.slope_bottom * t;
|
||||
eye->config.radius_top =
|
||||
eye->config.radius_top * (1.0f - t) + eye->transition_dest.radius_top * t;
|
||||
eye->config.radius_bottom = eye->config.radius_bottom * (1.0f - t) +
|
||||
eye->transition_dest.radius_bottom * t;
|
||||
|
||||
// Transform update
|
||||
t = anim_get_value(&eye->transform_anim);
|
||||
eye->transform_current.move_x =
|
||||
(eye->transform_dest.move_x - eye->transform_origin.move_x) * t +
|
||||
eye->transform_origin.move_x;
|
||||
eye->transform_current.move_y =
|
||||
(eye->transform_dest.move_y - eye->transform_origin.move_y) * t +
|
||||
eye->transform_origin.move_y;
|
||||
eye->transform_current.scale_x =
|
||||
(eye->transform_dest.scale_x - eye->transform_origin.scale_x) * t +
|
||||
eye->transform_origin.scale_x;
|
||||
eye->transform_current.scale_y =
|
||||
(eye->transform_dest.scale_y - eye->transform_origin.scale_y) * t +
|
||||
eye->transform_origin.scale_y;
|
||||
|
||||
// Apply transformation
|
||||
eye->final_config.offset_x =
|
||||
eye->config.offset_x + eye->transform_current.move_x;
|
||||
eye->final_config.offset_y =
|
||||
eye->config.offset_y - eye->transform_current.move_y;
|
||||
eye->final_config.width = eye->config.width * eye->transform_current.scale_x;
|
||||
eye->final_config.height =
|
||||
eye->config.height * eye->transform_current.scale_y;
|
||||
eye->final_config.slope_top = eye->config.slope_top;
|
||||
eye->final_config.slope_bottom = eye->config.slope_bottom;
|
||||
eye->final_config.radius_top = eye->config.radius_top;
|
||||
eye->final_config.radius_bottom = eye->config.radius_bottom;
|
||||
|
||||
// Blink update
|
||||
t = anim_get_value(&eye->blink_anim);
|
||||
if (anim_get_elapsed(&eye->blink_anim) > eye->blink_anim.interval)
|
||||
t = 0.0f;
|
||||
t = t * t;
|
||||
int16_t blink_height = 4;
|
||||
eye->final_config.height =
|
||||
(blink_height - eye->final_config.height) * t + eye->final_config.height;
|
||||
eye->final_config.slope_top *= (1.0f - t);
|
||||
eye->final_config.slope_bottom *= (1.0f - t);
|
||||
eye->final_config.radius_top *= (1.0f - t);
|
||||
eye->final_config.radius_bottom *= (1.0f - t);
|
||||
}
|
||||
|
||||
// Draw filled rectangle on canvas
|
||||
|
||||
// Draw filled quadrilateral (polygon)
|
||||
static void draw_quad(lv_obj_t *canvas, int32_t x0, int32_t y0, int32_t x1,
|
||||
int32_t y1, int32_t x2, int32_t y2, int32_t x3,
|
||||
int32_t y3, lv_color_t color) {
|
||||
lv_point_t points[4];
|
||||
points[0].x = x0;
|
||||
points[0].y = y0;
|
||||
points[1].x = x1;
|
||||
points[1].y = y1;
|
||||
points[2].x = x2;
|
||||
points[2].y = y2;
|
||||
points[3].x = x3;
|
||||
points[3].y = y3;
|
||||
|
||||
lv_draw_rect_dsc_t rect_dsc;
|
||||
lv_draw_rect_dsc_init(&rect_dsc);
|
||||
rect_dsc.bg_color = color;
|
||||
rect_dsc.bg_opa = LV_OPA_COVER;
|
||||
rect_dsc.border_width = 0;
|
||||
|
||||
lv_canvas_draw_polygon(canvas, points, 4, &rect_dsc);
|
||||
}
|
||||
|
||||
// Draw filled ellipse corner
|
||||
static void draw_ellipse_corner(lv_obj_t *canvas, int corner, int16_t x0,
|
||||
int16_t y0, int32_t rx, int32_t ry,
|
||||
lv_color_t color) {
|
||||
if (rx < 2 || ry < 2)
|
||||
return;
|
||||
|
||||
lv_draw_rect_dsc_t rect_dsc;
|
||||
lv_draw_rect_dsc_init(&rect_dsc);
|
||||
rect_dsc.bg_color = color;
|
||||
rect_dsc.bg_opa = LV_OPA_COVER;
|
||||
rect_dsc.border_width = 0;
|
||||
rect_dsc.radius = 0;
|
||||
|
||||
int32_t x, y;
|
||||
int32_t rx2 = rx * rx, ry2 = ry * ry;
|
||||
int32_t fx2 = 4 * rx2, fy2 = 4 * ry2;
|
||||
int32_t s;
|
||||
|
||||
// Draw using horizontal lines for each scanline of the ellipse
|
||||
for (x = 0, y = ry, s = 2 * ry2 + rx2 * (1 - 2 * ry); ry2 * x <= rx2 * y;
|
||||
x++) {
|
||||
int16_t draw_x, draw_y, draw_w;
|
||||
switch (corner) {
|
||||
case 0:
|
||||
draw_x = x0;
|
||||
draw_y = y0 - y;
|
||||
draw_w = x;
|
||||
break; // TR
|
||||
case 1:
|
||||
draw_x = x0 - x;
|
||||
draw_y = y0 - y;
|
||||
draw_w = x;
|
||||
break; // TL
|
||||
case 2:
|
||||
draw_x = x0 - x;
|
||||
draw_y = y0 + y - 1;
|
||||
draw_w = x;
|
||||
break; // BL
|
||||
case 3:
|
||||
draw_x = x0;
|
||||
draw_y = y0 + y - 1;
|
||||
draw_w = x;
|
||||
break; // BR
|
||||
}
|
||||
if (draw_w > 0)
|
||||
lv_canvas_draw_rect(canvas, draw_x, draw_y, draw_w, 1, &rect_dsc);
|
||||
if (s >= 0) {
|
||||
s += fx2 * (1 - y);
|
||||
y--;
|
||||
}
|
||||
s += ry2 * ((4 * x) + 6);
|
||||
}
|
||||
for (x = rx, y = 0, s = 2 * rx2 + ry2 * (1 - 2 * rx); rx2 * y <= ry2 * x;
|
||||
y++) {
|
||||
int16_t draw_x, draw_y, draw_w;
|
||||
switch (corner) {
|
||||
case 0:
|
||||
draw_x = x0;
|
||||
draw_y = y0 - y;
|
||||
draw_w = x;
|
||||
break;
|
||||
case 1:
|
||||
draw_x = x0 - x;
|
||||
draw_y = y0 - y;
|
||||
draw_w = x;
|
||||
break;
|
||||
case 2:
|
||||
draw_x = x0 - x;
|
||||
draw_y = y0 + y;
|
||||
draw_w = x;
|
||||
break;
|
||||
case 3:
|
||||
draw_x = x0;
|
||||
draw_y = y0 + y;
|
||||
draw_w = x;
|
||||
break;
|
||||
}
|
||||
if (draw_w > 0)
|
||||
lv_canvas_draw_rect(canvas, draw_x, draw_y, draw_w, 1, &rect_dsc);
|
||||
if (s >= 0) {
|
||||
s += fy2 * (1 - x);
|
||||
x--;
|
||||
}
|
||||
s += rx2 * ((4 * y) + 6);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw single eye
|
||||
static void eye_draw(lv_obj_t *canvas, eye_state_t *eye, lv_color_t color) {
|
||||
eye_config_t *cfg = &eye->final_config;
|
||||
int16_t cx = eye->center_x;
|
||||
int16_t cy = eye->center_y;
|
||||
|
||||
int32_t delta_y_top = cfg->height * cfg->slope_top / 2.0f;
|
||||
int32_t delta_y_bottom = cfg->height * cfg->slope_bottom / 2.0f;
|
||||
int32_t total_height = cfg->height + delta_y_top - delta_y_bottom;
|
||||
|
||||
int16_t rt = cfg->radius_top, rb = cfg->radius_bottom;
|
||||
if (rt > 0 && rb > 0 && total_height - 1 < rb + rt) {
|
||||
float ratio = (float)(total_height - 1) / (rb + rt);
|
||||
rt = (int16_t)(rt * ratio);
|
||||
rb = (int16_t)(rb * ratio);
|
||||
}
|
||||
|
||||
int32_t TLc_x = cx + cfg->offset_x - cfg->width / 2 + rt;
|
||||
int32_t TLc_y = cy + cfg->offset_y - cfg->height / 2 + rt - delta_y_top;
|
||||
int32_t TRc_x = cx + cfg->offset_x + cfg->width / 2 - rt;
|
||||
int32_t TRc_y = cy + cfg->offset_y - cfg->height / 2 + rt + delta_y_top;
|
||||
int32_t BLc_x = cx + cfg->offset_x - cfg->width / 2 + rb;
|
||||
int32_t BLc_y = cy + cfg->offset_y + cfg->height / 2 - rb - delta_y_bottom;
|
||||
int32_t BRc_x = cx + cfg->offset_x + cfg->width / 2 - rb;
|
||||
int32_t BRc_y = cy + cfg->offset_y + cfg->height / 2 - rb + delta_y_bottom;
|
||||
|
||||
// Fill center (Connecting the 4 corner centers)
|
||||
// Expand by 2px to ensure overlap and avoid gaps
|
||||
draw_quad(canvas, TLc_x - 2, TLc_y - 2, TRc_x + 2, TRc_y - 2, BRc_x + 2,
|
||||
BRc_y + 2, BLc_x - 2, BLc_y + 2, color);
|
||||
|
||||
// Fill edges (Connecting corner centers to outer edges)
|
||||
// Right Edge
|
||||
draw_quad(canvas, TRc_x, TRc_y, TRc_x + rt, TRc_y, BRc_x + rb, BRc_y, BRc_x,
|
||||
BRc_y, color);
|
||||
|
||||
// Top Edge
|
||||
draw_quad(canvas, TLc_x, TLc_y - rt, TRc_x, TRc_y - rt, TRc_x, TRc_y, TLc_x,
|
||||
TLc_y, color);
|
||||
|
||||
// Left Edge
|
||||
draw_quad(canvas, TLc_x - rt, TLc_y, TLc_x, TLc_y, BLc_x, BLc_y, BLc_x - rb,
|
||||
BLc_y, color);
|
||||
|
||||
// Bottom Edge
|
||||
draw_quad(canvas, BLc_x, BLc_y, BRc_x, BRc_y, BRc_x, BRc_y + rb, BLc_x,
|
||||
BLc_y + rb, color);
|
||||
|
||||
// Draw corners
|
||||
if (rt > 0) {
|
||||
draw_ellipse_corner(canvas, 1, TLc_x, TLc_y, rt, rt, color);
|
||||
draw_ellipse_corner(canvas, 0, TRc_x, TRc_y, rt, rt, color);
|
||||
}
|
||||
if (rb > 0) {
|
||||
draw_ellipse_corner(canvas, 2, BLc_x, BLc_y, rb, rb, color);
|
||||
draw_ellipse_corner(canvas, 3, BRc_x, BRc_y, rb, rb, color);
|
||||
}
|
||||
}
|
||||
|
||||
// Go to emotion
|
||||
static void go_to_emotion(animated_eyes_handle_t h,
|
||||
animated_eyes_emotion_t emotion) {
|
||||
float scale = (float)h->config.eye_size / 40.0f;
|
||||
const eye_config_t *preset = &PRESET_NORMAL;
|
||||
|
||||
switch (emotion) {
|
||||
case EMOTION_NORMAL:
|
||||
preset = &PRESET_NORMAL;
|
||||
break;
|
||||
case EMOTION_ANGRY:
|
||||
preset = &PRESET_ANGRY;
|
||||
break;
|
||||
case EMOTION_GLEE:
|
||||
preset = &PRESET_GLEE;
|
||||
break;
|
||||
case EMOTION_HAPPY:
|
||||
preset = &PRESET_HAPPY;
|
||||
break;
|
||||
case EMOTION_SAD:
|
||||
preset = &PRESET_SAD;
|
||||
break;
|
||||
case EMOTION_WORRIED:
|
||||
preset = &PRESET_WORRIED;
|
||||
break;
|
||||
case EMOTION_FOCUSED:
|
||||
preset = &PRESET_FOCUSED;
|
||||
break;
|
||||
case EMOTION_ANNOYED:
|
||||
preset = &PRESET_ANNOYED;
|
||||
break;
|
||||
case EMOTION_SURPRISED:
|
||||
preset = &PRESET_SURPRISED;
|
||||
break;
|
||||
case EMOTION_SKEPTIC:
|
||||
preset = &PRESET_SKEPTIC;
|
||||
break;
|
||||
case EMOTION_FRUSTRATED:
|
||||
preset = &PRESET_FRUSTRATED;
|
||||
break;
|
||||
case EMOTION_UNIMPRESSED:
|
||||
preset = &PRESET_UNIMPRESSED;
|
||||
break;
|
||||
case EMOTION_SLEEPY:
|
||||
preset = &PRESET_SLEEPY;
|
||||
break;
|
||||
case EMOTION_SUSPICIOUS:
|
||||
preset = &PRESET_SUSPICIOUS;
|
||||
break;
|
||||
case EMOTION_SQUINT:
|
||||
preset = &PRESET_SQUINT;
|
||||
break;
|
||||
case EMOTION_FURIOUS:
|
||||
preset = &PRESET_FURIOUS;
|
||||
break;
|
||||
case EMOTION_SCARED:
|
||||
preset = &PRESET_SCARED;
|
||||
break;
|
||||
case EMOTION_AWE:
|
||||
preset = &PRESET_AWE;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
eye_transition_to(&h->left_eye, preset, scale);
|
||||
eye_transition_to(&h->right_eye, preset, scale);
|
||||
h->current_emotion = emotion;
|
||||
}
|
||||
|
||||
// Get random emotion based on weights
|
||||
static animated_eyes_emotion_t get_random_emotion(animated_eyes_handle_t h) {
|
||||
float sum = 0;
|
||||
for (int i = 0; i < EMOTION_COUNT; i++)
|
||||
sum += h->emotion_weights[i];
|
||||
if (sum == 0)
|
||||
return EMOTION_NORMAL;
|
||||
|
||||
float r = (float)(rand() % 1000) / 1000.0f * sum;
|
||||
float acc = 0;
|
||||
for (int i = 0; i < EMOTION_COUNT; i++) {
|
||||
if (h->emotion_weights[i] == 0)
|
||||
continue;
|
||||
acc += h->emotion_weights[i];
|
||||
if (r <= acc)
|
||||
return (animated_eyes_emotion_t)i;
|
||||
}
|
||||
return EMOTION_NORMAL;
|
||||
}
|
||||
|
||||
// Public API Implementation
|
||||
animated_eyes_handle_t
|
||||
animated_eyes_create(lv_obj_t *parent, const animated_eyes_config_t *config) {
|
||||
animated_eyes_handle_t h = calloc(1, sizeof(struct animated_eyes_t));
|
||||
if (!h)
|
||||
return NULL;
|
||||
|
||||
h->config = *config;
|
||||
h->center_x = config->screen_width / 2;
|
||||
h->center_y = config->screen_height / 2;
|
||||
|
||||
// Create canvas
|
||||
// Use SPIRAM for large canvas buffer (internal RAM is likely too small for
|
||||
// full screen buffer)
|
||||
h->canvas_buf = heap_caps_malloc(
|
||||
config->screen_width * config->screen_height * sizeof(lv_color_t),
|
||||
MALLOC_CAP_SPIRAM);
|
||||
if (!h->canvas_buf) {
|
||||
ESP_LOGE(TAG, "Failed to allocate canvas buffer");
|
||||
free(h);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
h->canvas = lv_canvas_create(parent);
|
||||
lv_canvas_set_buffer(h->canvas, h->canvas_buf, config->screen_width,
|
||||
config->screen_height, LV_IMG_CF_TRUE_COLOR);
|
||||
lv_obj_center(h->canvas);
|
||||
lv_canvas_fill_bg(h->canvas, config->bg_color, LV_OPA_COVER);
|
||||
|
||||
// Initialize eyes
|
||||
eye_init(&h->left_eye, true);
|
||||
eye_init(&h->right_eye, false);
|
||||
|
||||
float scale = (float)config->eye_size / 40.0f;
|
||||
h->left_eye.center_x =
|
||||
h->center_x - config->eye_size / 2 - config->eye_spacing;
|
||||
h->left_eye.center_y = h->center_y;
|
||||
h->right_eye.center_x =
|
||||
h->center_x + config->eye_size / 2 + config->eye_spacing;
|
||||
h->right_eye.center_y = h->center_y;
|
||||
|
||||
eye_apply_preset(&h->left_eye, &PRESET_NORMAL, scale);
|
||||
eye_apply_preset(&h->right_eye, &PRESET_NORMAL, scale);
|
||||
|
||||
// Initialize emotion weights
|
||||
for (int i = 0; i < EMOTION_COUNT; i++)
|
||||
h->emotion_weights[i] = 0;
|
||||
h->emotion_weights[EMOTION_NORMAL] = 1.0f;
|
||||
|
||||
// Initialize timers
|
||||
timer_start(&h->behavior_timer, config->behavior_interval);
|
||||
timer_start(&h->look_timer, config->look_interval);
|
||||
timer_start(&h->blink_timer, config->blink_interval);
|
||||
|
||||
ESP_LOGI(TAG, "Animated eyes created (%dx%d, eye_size=%d)",
|
||||
config->screen_width, config->screen_height, config->eye_size);
|
||||
return h;
|
||||
}
|
||||
|
||||
void animated_eyes_delete(animated_eyes_handle_t h) {
|
||||
if (!h)
|
||||
return;
|
||||
if (h->canvas)
|
||||
lv_obj_del(h->canvas);
|
||||
if (h->canvas_buf)
|
||||
free(h->canvas_buf);
|
||||
free(h);
|
||||
}
|
||||
|
||||
void animated_eyes_update(animated_eyes_handle_t h) {
|
||||
if (!h)
|
||||
return;
|
||||
|
||||
if (!h)
|
||||
return;
|
||||
|
||||
// Update temporary emotion
|
||||
if (h->is_temporary_emotion) {
|
||||
timer_update(&h->temporary_timer);
|
||||
if (h->temporary_timer.is_expired) {
|
||||
h->is_temporary_emotion = false;
|
||||
go_to_emotion(h, h->saved_emotion);
|
||||
}
|
||||
}
|
||||
|
||||
// Decay inertia
|
||||
h->inertia_x *= 0.9f; // Slower decay for visibility
|
||||
h->inertia_y *= 0.9f;
|
||||
if (fabsf(h->inertia_x) < 1.0f)
|
||||
h->inertia_x = 0;
|
||||
if (fabsf(h->inertia_y) < 1.0f)
|
||||
h->inertia_y = 0;
|
||||
|
||||
// Update behavior (only if not in temporary emotion)
|
||||
if (h->config.random_behavior && !h->is_temporary_emotion) {
|
||||
timer_update(&h->behavior_timer);
|
||||
if (h->behavior_timer.is_expired) {
|
||||
timer_reset(&h->behavior_timer);
|
||||
animated_eyes_emotion_t new_emotion = get_random_emotion(h);
|
||||
if (new_emotion != h->current_emotion)
|
||||
go_to_emotion(h, new_emotion);
|
||||
}
|
||||
}
|
||||
|
||||
// Update look
|
||||
if (h->config.random_look) {
|
||||
timer_update(&h->look_timer);
|
||||
if (h->look_timer.is_expired) {
|
||||
timer_reset(&h->look_timer);
|
||||
float x = (float)(rand() % 100 - 50) / 100.0f;
|
||||
float y = (float)(rand() % 100 - 50) / 100.0f;
|
||||
animated_eyes_look_at(h, x, y);
|
||||
}
|
||||
}
|
||||
|
||||
// Update blink
|
||||
if (h->config.random_blink) {
|
||||
timer_update(&h->blink_timer);
|
||||
if (h->blink_timer.is_expired) {
|
||||
animated_eyes_blink(h);
|
||||
|
||||
// Randomize NEXT blink interval (3s to 8s for a more relaxed feel)
|
||||
uint32_t next_interval = 3000 + (rand() % 5000);
|
||||
|
||||
h->blink_timer.interval = next_interval;
|
||||
timer_reset(&h->blink_timer);
|
||||
}
|
||||
}
|
||||
|
||||
// Update eye animations
|
||||
eye_update(&h->left_eye);
|
||||
eye_update(&h->right_eye);
|
||||
|
||||
// Redraw
|
||||
lv_canvas_fill_bg(h->canvas, h->config.bg_color, LV_OPA_COVER);
|
||||
|
||||
// Apply inertia offset temporarily for drawing
|
||||
int16_t original_cx_l = h->left_eye.center_x;
|
||||
int16_t original_cy_l = h->left_eye.center_y;
|
||||
int16_t original_cx_r = h->right_eye.center_x;
|
||||
int16_t original_cy_r = h->right_eye.center_y;
|
||||
|
||||
h->left_eye.center_x += (int16_t)h->inertia_x;
|
||||
h->left_eye.center_y += (int16_t)h->inertia_y;
|
||||
h->right_eye.center_x += (int16_t)h->inertia_x;
|
||||
h->right_eye.center_y += (int16_t)h->inertia_y;
|
||||
|
||||
eye_draw(h->canvas, &h->left_eye, h->config.eye_color);
|
||||
eye_draw(h->canvas, &h->right_eye, h->config.eye_color);
|
||||
|
||||
// Restore centers
|
||||
h->left_eye.center_x = original_cx_l;
|
||||
h->left_eye.center_y = original_cy_l;
|
||||
h->right_eye.center_x = original_cx_r;
|
||||
h->right_eye.center_y = original_cy_r;
|
||||
|
||||
lv_obj_invalidate(h->canvas);
|
||||
}
|
||||
|
||||
void animated_eyes_blink(animated_eyes_handle_t h) {
|
||||
if (!h)
|
||||
return;
|
||||
anim_restart(&h->left_eye.blink_anim);
|
||||
anim_restart(&h->right_eye.blink_anim);
|
||||
// Note: Timer reset and interval randomization is handled in update loop for
|
||||
// automatic blinks
|
||||
}
|
||||
|
||||
void animated_eyes_set_emotion(animated_eyes_handle_t h,
|
||||
animated_eyes_emotion_t emotion) {
|
||||
if (!h || emotion >= EMOTION_COUNT)
|
||||
return;
|
||||
if (!h || emotion >= EMOTION_COUNT)
|
||||
return;
|
||||
// If we were in a temporary emotion, setting a new one manually cancels it
|
||||
h->is_temporary_emotion = false;
|
||||
go_to_emotion(h, emotion);
|
||||
}
|
||||
|
||||
void animated_eyes_set_temporary_emotion(animated_eyes_handle_t h,
|
||||
animated_eyes_emotion_t emotion,
|
||||
uint32_t duration_ms) {
|
||||
if (!h || emotion >= EMOTION_COUNT)
|
||||
return;
|
||||
|
||||
if (!h->is_temporary_emotion) {
|
||||
h->saved_emotion = h->current_emotion;
|
||||
h->is_temporary_emotion = true;
|
||||
}
|
||||
|
||||
go_to_emotion(h, emotion);
|
||||
timer_start(&h->temporary_timer, duration_ms);
|
||||
ESP_LOGI(TAG, "Set temp emotion: %d for %d ms", emotion, duration_ms);
|
||||
}
|
||||
|
||||
void animated_eyes_shake_inertia(animated_eyes_handle_t h, float intensity_x,
|
||||
float intensity_y) {
|
||||
if (!h)
|
||||
return;
|
||||
// Map intensity (G-force) to pixel offset
|
||||
// aggressive: 1G = 50 pixels displacement (X needs negative for inertia feel)
|
||||
h->inertia_x = intensity_x * -50.0f;
|
||||
h->inertia_y = intensity_y * 50.0f;
|
||||
}
|
||||
|
||||
animated_eyes_emotion_t animated_eyes_get_emotion(animated_eyes_handle_t h) {
|
||||
return h ? h->current_emotion : EMOTION_NORMAL;
|
||||
}
|
||||
|
||||
void animated_eyes_set_emotion_weight(animated_eyes_handle_t h,
|
||||
animated_eyes_emotion_t emotion,
|
||||
float weight) {
|
||||
if (!h || emotion >= EMOTION_COUNT)
|
||||
return;
|
||||
h->emotion_weights[emotion] = weight;
|
||||
}
|
||||
|
||||
void animated_eyes_look_at(animated_eyes_handle_t h, float x, float y) {
|
||||
if (!h)
|
||||
return;
|
||||
|
||||
float scale = (float)h->config.eye_size / 40.0f;
|
||||
int16_t move_x = (int16_t)(-25 * x * scale);
|
||||
int16_t move_y = (int16_t)(20 * y * scale);
|
||||
float scale_y = 1.0f - fabsf(y) * 0.4f;
|
||||
|
||||
h->right_eye.transform_origin = h->right_eye.transform_current;
|
||||
h->right_eye.transform_dest.move_x = move_x;
|
||||
h->right_eye.transform_dest.move_y = move_y;
|
||||
h->right_eye.transform_dest.scale_x = 1.0f;
|
||||
h->right_eye.transform_dest.scale_y = scale_y * (1.0f - x * 0.2f);
|
||||
anim_restart(&h->right_eye.transform_anim);
|
||||
|
||||
h->left_eye.transform_origin = h->left_eye.transform_current;
|
||||
h->left_eye.transform_dest.move_x = move_x;
|
||||
h->left_eye.transform_dest.move_y = move_y;
|
||||
h->left_eye.transform_dest.scale_x = 1.0f;
|
||||
h->left_eye.transform_dest.scale_y = scale_y * (1.0f + x * 0.2f);
|
||||
anim_restart(&h->left_eye.transform_anim);
|
||||
}
|
||||
|
||||
void animated_eyes_look_at_point(animated_eyes_handle_t h, int16_t sx,
|
||||
int16_t sy) {
|
||||
if (!h)
|
||||
return;
|
||||
float x = (float)(sx - h->center_x) / (h->config.screen_width / 2);
|
||||
float y = (float)(h->center_y - sy) / (h->config.screen_height / 2);
|
||||
x = x < -1.0f ? -1.0f : (x > 1.0f ? 1.0f : x);
|
||||
y = y < -1.0f ? -1.0f : (y > 1.0f ? 1.0f : y);
|
||||
animated_eyes_look_at(h, x, y);
|
||||
}
|
||||
|
||||
void animated_eyes_look_left(animated_eyes_handle_t h) {
|
||||
animated_eyes_look_at(h, 1.0f, 0);
|
||||
}
|
||||
void animated_eyes_look_right(animated_eyes_handle_t h) {
|
||||
animated_eyes_look_at(h, -1.0f, 0);
|
||||
}
|
||||
void animated_eyes_look_up(animated_eyes_handle_t h) {
|
||||
animated_eyes_look_at(h, 0, 1.0f);
|
||||
}
|
||||
void animated_eyes_look_down(animated_eyes_handle_t h) {
|
||||
animated_eyes_look_at(h, 0, -1.0f);
|
||||
}
|
||||
void animated_eyes_look_center(animated_eyes_handle_t h) {
|
||||
animated_eyes_look_at(h, 0, 0);
|
||||
}
|
||||
|
||||
void animated_eyes_set_random(animated_eyes_handle_t h, bool behavior,
|
||||
bool look, bool blink) {
|
||||
if (!h)
|
||||
return;
|
||||
h->config.random_behavior = behavior;
|
||||
h->config.random_look = look;
|
||||
h->config.random_blink = blink;
|
||||
}
|
||||
|
||||
void animated_eyes_set_color(animated_eyes_handle_t h, lv_color_t color) {
|
||||
if (h)
|
||||
h->config.eye_color = color;
|
||||
}
|
||||
|
||||
void animated_eyes_set_bg_color(animated_eyes_handle_t h, lv_color_t color) {
|
||||
if (h)
|
||||
h->config.bg_color = color;
|
||||
}
|
||||
@@ -1,264 +0,0 @@
|
||||
/**
|
||||
* @file animated_eyes.h
|
||||
* @brief Animated expressive eyes for LVGL displays
|
||||
*
|
||||
* Ported from esp32-eyes (https://github.com/playfultechnology/esp32-eyes)
|
||||
* Original Copyright (c) 2020 Luis Llamas, 2023 Alastair Aitchison
|
||||
* LVGL port for ESP-IDF
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Affero General Public License.
|
||||
*/
|
||||
|
||||
#ifndef ANIMATED_EYES_H
|
||||
#define ANIMATED_EYES_H
|
||||
|
||||
#include "lvgl.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Available emotions for the animated face
|
||||
*/
|
||||
typedef enum {
|
||||
EMOTION_NORMAL = 0,
|
||||
EMOTION_ANGRY,
|
||||
EMOTION_GLEE,
|
||||
EMOTION_HAPPY,
|
||||
EMOTION_SAD,
|
||||
EMOTION_WORRIED,
|
||||
EMOTION_FOCUSED,
|
||||
EMOTION_ANNOYED,
|
||||
EMOTION_SURPRISED,
|
||||
EMOTION_SKEPTIC,
|
||||
EMOTION_FRUSTRATED,
|
||||
EMOTION_UNIMPRESSED,
|
||||
EMOTION_SLEEPY,
|
||||
EMOTION_SUSPICIOUS,
|
||||
EMOTION_SQUINT,
|
||||
EMOTION_FURIOUS,
|
||||
EMOTION_SCARED,
|
||||
EMOTION_AWE,
|
||||
EMOTION_COUNT
|
||||
} animated_eyes_emotion_t;
|
||||
|
||||
/**
|
||||
* @brief Configuration for animated eyes
|
||||
*/
|
||||
typedef struct {
|
||||
uint16_t screen_width; /**< Screen width in pixels */
|
||||
uint16_t screen_height; /**< Screen height in pixels */
|
||||
uint16_t eye_size; /**< Base eye size (will be scaled) */
|
||||
uint16_t eye_spacing; /**< Distance between eyes */
|
||||
lv_color_t eye_color; /**< Color of the eyes */
|
||||
lv_color_t bg_color; /**< Background color */
|
||||
bool random_behavior; /**< Enable random emotion changes */
|
||||
bool random_look; /**< Enable random look-around */
|
||||
bool random_blink; /**< Enable random blinking */
|
||||
uint32_t behavior_interval; /**< Interval for behavior changes (ms) */
|
||||
uint32_t look_interval; /**< Interval for look changes (ms) */
|
||||
uint32_t blink_interval; /**< Interval for blinking (ms) */
|
||||
} animated_eyes_config_t;
|
||||
|
||||
/**
|
||||
* @brief Handle for animated eyes instance
|
||||
*/
|
||||
typedef struct animated_eyes_t *animated_eyes_handle_t;
|
||||
|
||||
/**
|
||||
* @brief Default configuration macro
|
||||
*/
|
||||
#define ANIMATED_EYES_DEFAULT_CONFIG() \
|
||||
{.screen_width = 368, \
|
||||
.screen_height = 448, \
|
||||
.eye_size = 120, \
|
||||
.eye_spacing = 20, \
|
||||
.eye_color = lv_color_white(), \
|
||||
.bg_color = lv_color_black(), \
|
||||
.random_behavior = true, \
|
||||
.random_look = true, \
|
||||
.random_blink = true, \
|
||||
.behavior_interval = 5000, \
|
||||
.look_interval = 4000, \
|
||||
.blink_interval = 3500}
|
||||
|
||||
/**
|
||||
* @brief Create animated eyes on a parent LVGL object
|
||||
*
|
||||
* @param parent Parent LVGL object to attach eyes to
|
||||
* @param config Configuration for the eyes
|
||||
* @return Handle to the animated eyes instance, or NULL on failure
|
||||
*/
|
||||
animated_eyes_handle_t
|
||||
animated_eyes_create(lv_obj_t *parent, const animated_eyes_config_t *config);
|
||||
|
||||
/**
|
||||
* @brief Delete animated eyes and free resources
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
*/
|
||||
void animated_eyes_delete(animated_eyes_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Update the animated eyes (call this regularly, e.g., every frame)
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
*/
|
||||
void animated_eyes_update(animated_eyes_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Trigger a blink animation
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
*/
|
||||
void animated_eyes_blink(animated_eyes_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Set the current emotion
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
* @param emotion The emotion to set
|
||||
*/
|
||||
void animated_eyes_set_emotion(animated_eyes_handle_t handle,
|
||||
animated_eyes_emotion_t emotion);
|
||||
|
||||
/**
|
||||
* @brief Set a temporary emotion that reverts after a duration
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
* @param emotion The temporary emotion to set
|
||||
* @param duration_ms Duration in milliseconds before reverting
|
||||
*/
|
||||
void animated_eyes_set_temporary_emotion(animated_eyes_handle_t handle,
|
||||
animated_eyes_emotion_t emotion,
|
||||
uint32_t duration_ms);
|
||||
|
||||
/**
|
||||
* @brief Get the current emotion
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
* @return Current emotion
|
||||
*/
|
||||
animated_eyes_emotion_t
|
||||
animated_eyes_get_emotion(animated_eyes_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Set a temporary emotion that reverts after a duration
|
||||
*
|
||||
* @param handle Handle to the animated eyes instance
|
||||
* @param emotion The temporary emotion to set
|
||||
* @param duration_ms Duration in milliseconds before reverting
|
||||
*/
|
||||
void animated_eyes_set_temporary_emotion(animated_eyes_handle_t handle,
|
||||
animated_eyes_emotion_t emotion,
|
||||
uint32_t duration_ms);
|
||||
|
||||
/**
|
||||
* @brief Apply an inertia-based offset
|
||||
* to the eyes
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param intensity_x Intensity of the
|
||||
* shake X component (G-force)
|
||||
* @param intensity_y Intensity of the
|
||||
* shake Y component (G-force)
|
||||
*/
|
||||
void animated_eyes_shake_inertia(animated_eyes_handle_t handle,
|
||||
float intensity_x, float intensity_y);
|
||||
|
||||
/**
|
||||
* @brief Set the emotion probability
|
||||
* weight
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param emotion The emotion to set
|
||||
* weight for
|
||||
* @param weight Weight value (0.0 to
|
||||
* disable, higher = more likely)
|
||||
*/
|
||||
void animated_eyes_set_emotion_weight(animated_eyes_handle_t handle,
|
||||
animated_eyes_emotion_t emotion,
|
||||
float weight);
|
||||
|
||||
/**
|
||||
* @brief Make the eyes look in a
|
||||
* specific direction
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param x Horizontal direction (-1.0
|
||||
* = left, 0.0 = center, 1.0 = right)
|
||||
* @param y Vertical direction (-1.0 =
|
||||
* down, 0.0 = center, 1.0 = up)
|
||||
*/
|
||||
void animated_eyes_look_at(animated_eyes_handle_t handle, float x, float y);
|
||||
|
||||
/**
|
||||
* @brief Make the eyes look at a
|
||||
* screen position
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param screen_x X coordinate on
|
||||
* screen
|
||||
* @param screen_y Y coordinate on
|
||||
* screen
|
||||
*/
|
||||
void animated_eyes_look_at_point(animated_eyes_handle_t handle,
|
||||
int16_t screen_x, int16_t screen_y);
|
||||
|
||||
/**
|
||||
* @brief Convenience methods for
|
||||
* common look directions
|
||||
*/
|
||||
void animated_eyes_look_left(animated_eyes_handle_t handle);
|
||||
void animated_eyes_look_right(animated_eyes_handle_t handle);
|
||||
void animated_eyes_look_up(animated_eyes_handle_t handle);
|
||||
void animated_eyes_look_down(animated_eyes_handle_t handle);
|
||||
void animated_eyes_look_center(animated_eyes_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Enable or disable random
|
||||
* behaviors
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param behavior Enable random
|
||||
* emotion changes
|
||||
* @param look Enable random looking
|
||||
* around
|
||||
* @param blink Enable random blinking
|
||||
*/
|
||||
void animated_eyes_set_random(animated_eyes_handle_t handle, bool behavior,
|
||||
bool look, bool blink);
|
||||
|
||||
/**
|
||||
* @brief Set the eye color
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param color New eye color
|
||||
*/
|
||||
void animated_eyes_set_color(animated_eyes_handle_t handle, lv_color_t color);
|
||||
|
||||
/**
|
||||
* @brief Set the background color
|
||||
*
|
||||
* @param handle Handle to the animated
|
||||
* eyes instance
|
||||
* @param color New background color
|
||||
*/
|
||||
void animated_eyes_set_bg_color(animated_eyes_handle_t handle,
|
||||
lv_color_t color);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ANIMATED_EYES_H */
|
||||
@@ -1,84 +0,0 @@
|
||||
/**
|
||||
* @file animated_eyes_demo.c
|
||||
* @brief Demo implementation for animated eyes
|
||||
*/
|
||||
|
||||
#include "animated_eyes_demo.h"
|
||||
#include "esp_log.h"
|
||||
// FreeRTOS includes not needed for lv_timer
|
||||
|
||||
static const char *TAG = "eyes_demo";
|
||||
|
||||
static lv_timer_t *update_timer = NULL;
|
||||
static animated_eyes_handle_t eyes_handle = NULL;
|
||||
|
||||
// Timer callback for updating eyes
|
||||
static void update_timer_callback(lv_timer_t *timer) {
|
||||
if (eyes_handle) {
|
||||
animated_eyes_update(eyes_handle);
|
||||
}
|
||||
}
|
||||
|
||||
animated_eyes_handle_t animated_eyes_demo_start(void) {
|
||||
ESP_LOGI(TAG, "Starting animated eyes demo");
|
||||
|
||||
// Get the active screen
|
||||
lv_obj_t *scr = lv_scr_act();
|
||||
|
||||
// Set black background
|
||||
lv_obj_set_style_bg_color(scr, lv_color_black(), 0);
|
||||
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, 0);
|
||||
|
||||
// Configure and create animated eyes
|
||||
animated_eyes_config_t config = ANIMATED_EYES_DEFAULT_CONFIG();
|
||||
|
||||
// Customize for your screen (368x448)
|
||||
config.screen_width = 368;
|
||||
config.screen_height = 448;
|
||||
config.eye_size = 120; // Larger eyes to fill the screen better
|
||||
config.eye_spacing = 20; // Closer together
|
||||
config.eye_color = lv_color_white();
|
||||
config.bg_color = lv_color_black();
|
||||
|
||||
// Disable random movements for stability
|
||||
config.random_behavior = false;
|
||||
config.random_look = false;
|
||||
config.random_blink = true; // Keep blinking for life
|
||||
|
||||
// Timing settings (unused when random features disabled, but kept for
|
||||
// reference)
|
||||
config.behavior_interval = 6000;
|
||||
config.look_interval = 3000;
|
||||
config.blink_interval = 4000;
|
||||
|
||||
eyes_handle = animated_eyes_create(scr, &config);
|
||||
if (!eyes_handle) {
|
||||
ESP_LOGE(TAG, "Failed to create animated eyes");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Create timers
|
||||
// 1. Update timer: 33ms (approx 30 FPS) for smooth animation
|
||||
update_timer = lv_timer_create(update_timer_callback, 33, NULL);
|
||||
|
||||
ESP_LOGI(TAG, "Animated eyes started successfully");
|
||||
return eyes_handle;
|
||||
}
|
||||
|
||||
animated_eyes_handle_t animated_eyes_demo_get_handle(void) {
|
||||
return eyes_handle;
|
||||
}
|
||||
|
||||
void animated_eyes_demo_stop(animated_eyes_handle_t handle) {
|
||||
if (update_timer) {
|
||||
lv_timer_del(update_timer);
|
||||
update_timer = NULL;
|
||||
}
|
||||
|
||||
if (handle) {
|
||||
animated_eyes_delete(handle);
|
||||
eyes_handle = NULL;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Animated eyes demo stopped");
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
/**
|
||||
* @file animated_eyes_demo.h
|
||||
* @brief Demo functions for animated eyes
|
||||
*/
|
||||
|
||||
#ifndef ANIMATED_EYES_DEMO_H
|
||||
#define ANIMATED_EYES_DEMO_H
|
||||
|
||||
#include "animated_eyes.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Start the animated eyes demo
|
||||
*
|
||||
* Creates animated eyes on the current screen and starts
|
||||
* the animation. Call animated_eyes_demo_stop() to clean up.
|
||||
*
|
||||
* @return Handle to the animated eyes, or NULL on failure
|
||||
*/
|
||||
animated_eyes_handle_t animated_eyes_demo_start(void);
|
||||
|
||||
/**
|
||||
* @brief Get the current animated eyes handle
|
||||
*
|
||||
* @return animated_eyes_handle_t Handle or NULL if not started
|
||||
*/
|
||||
animated_eyes_handle_t animated_eyes_demo_get_handle(void);
|
||||
|
||||
/**
|
||||
* @brief Stop the animated eyes demo and clean up
|
||||
*
|
||||
* @param handle Handle returned by animated_eyes_demo_start()
|
||||
*/
|
||||
void animated_eyes_demo_stop(animated_eyes_handle_t handle);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ANIMATED_EYES_DEMO_H */
|
||||
83
main/config/display_config.h
Normal file
83
main/config/display_config.h
Normal file
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* @file display_config.h
|
||||
* @brief Display configuration constants for the iroBot display system
|
||||
*
|
||||
* This header centralizes all LCD and LVGL configuration parameters.
|
||||
* Modify these values to adapt to different display hardware.
|
||||
*/
|
||||
|
||||
#ifndef DISPLAY_CONFIG_H
|
||||
#define DISPLAY_CONFIG_H
|
||||
|
||||
#include "driver/gpio.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LCD Resolution
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define DISPLAY_WIDTH 368
|
||||
#define DISPLAY_HEIGHT 448
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LCD SPI Pin Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define LCD_PIN_CS (GPIO_NUM_12)
|
||||
#define LCD_PIN_PCLK (GPIO_NUM_11)
|
||||
#define LCD_PIN_DATA0 (GPIO_NUM_4)
|
||||
#define LCD_PIN_DATA1 (GPIO_NUM_5)
|
||||
#define LCD_PIN_DATA2 (GPIO_NUM_6)
|
||||
#define LCD_PIN_DATA3 (GPIO_NUM_7)
|
||||
#define LCD_PIN_RST (-1)
|
||||
#define LCD_PIN_BACKLIGHT (-1)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LCD Backlight Control
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define LCD_BACKLIGHT_ON_LEVEL 1
|
||||
#define LCD_BACKLIGHT_OFF_LEVEL (!LCD_BACKLIGHT_ON_LEVEL)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// SPI Host Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define LCD_SPI_HOST SPI2_HOST
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Color Depth Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if CONFIG_LV_COLOR_DEPTH == 32
|
||||
#define LCD_BIT_PER_PIXEL 24
|
||||
#elif CONFIG_LV_COLOR_DEPTH == 16
|
||||
#define LCD_BIT_PER_PIXEL 16
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LVGL Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Draw buffer height as a fraction of display height (1/4 of screen)
|
||||
#define LVGL_BUFFER_HEIGHT (DISPLAY_HEIGHT / 4)
|
||||
|
||||
// LVGL tick period in milliseconds
|
||||
#define LVGL_TICK_PERIOD_MS 2
|
||||
|
||||
// LVGL task timing constraints
|
||||
#define LVGL_TASK_MAX_DELAY_MS 500
|
||||
#define LVGL_TASK_MIN_DELAY_MS 1
|
||||
|
||||
// LVGL task configuration
|
||||
#define LVGL_TASK_STACK_SIZE (4 * 1024)
|
||||
#define LVGL_TASK_PRIORITY 2
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // DISPLAY_CONFIG_H
|
||||
61
main/config/hardware_config.h
Normal file
61
main/config/hardware_config.h
Normal file
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* @file hardware_config.h
|
||||
* @brief Hardware pin and peripheral configuration for the iroBot system
|
||||
*
|
||||
* This header centralizes all hardware-related configuration including
|
||||
* I2C buses, touch controller, IO expander, and sensor addresses.
|
||||
* Modify these values to adapt to different hardware configurations.
|
||||
*/
|
||||
|
||||
#ifndef HARDWARE_CONFIG_H
|
||||
#define HARDWARE_CONFIG_H
|
||||
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/i2c.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// I2C Bus Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define I2C_MASTER_PORT I2C_NUM_0
|
||||
#define I2C_MASTER_SDA (GPIO_NUM_15)
|
||||
#define I2C_MASTER_SCL (GPIO_NUM_14)
|
||||
#define I2C_MASTER_FREQ_HZ (200 * 1000)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Touch Controller Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define TOUCH_PIN_SDA I2C_MASTER_SDA
|
||||
#define TOUCH_PIN_SCL I2C_MASTER_SCL
|
||||
#define TOUCH_PIN_RST (-1)
|
||||
#define TOUCH_PIN_INT (GPIO_NUM_21)
|
||||
|
||||
// Enable/disable touch functionality
|
||||
#define TOUCH_ENABLED 1
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// QMI8658 IMU Sensor Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define QMI8658_I2C_PORT I2C_MASTER_PORT
|
||||
#define QMI8658_I2C_ADDR 0x6B
|
||||
#define QMI8658_PIN_SDA I2C_MASTER_SDA
|
||||
#define QMI8658_PIN_SCL I2C_MASTER_SCL
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// IO Expander Configuration (TCA9554)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define IO_EXPANDER_I2C_PORT I2C_MASTER_PORT
|
||||
// Address is defined by ESP chip support library
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // HARDWARE_CONFIG_H
|
||||
421
main/drivers/display_driver.c
Normal file
421
main/drivers/display_driver.c
Normal file
@@ -0,0 +1,421 @@
|
||||
/**
|
||||
* @file display_driver.c
|
||||
* @brief Display driver implementation for SH8601 LCD with LVGL
|
||||
*
|
||||
* This module encapsulates all display initialization including:
|
||||
* - I2C bus setup for IO expander
|
||||
* - SPI bus configuration for LCD
|
||||
* - SH8601 panel driver initialization
|
||||
* - LVGL display driver registration
|
||||
* - Thread-safe LVGL task management
|
||||
*/
|
||||
|
||||
#include "display_driver.h"
|
||||
#include "config/display_config.h"
|
||||
#include "config/hardware_config.h"
|
||||
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/i2c.h"
|
||||
#include "driver/spi_master.h"
|
||||
#include "esp_err.h"
|
||||
#include "esp_io_expander_tca9554.h"
|
||||
#include "esp_lcd_panel_io.h"
|
||||
#include "esp_lcd_panel_ops.h"
|
||||
#include "esp_lcd_panel_vendor.h"
|
||||
#include "esp_lcd_sh8601.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "freertos/task.h"
|
||||
#include "lvgl.h"
|
||||
|
||||
|
||||
static const char *TAG = "display_driver";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private State
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static SemaphoreHandle_t lvglMutex = NULL;
|
||||
static lv_disp_drv_t dispDriver;
|
||||
static lv_disp_draw_buf_t dispBuffer;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LCD Initialization Commands
|
||||
// The SH8601 requires specific initialization sequences.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static const sh8601_lcd_init_cmd_t lcdInitCmds[] = {
|
||||
{0x11, (uint8_t[]){0x00}, 0, 120},
|
||||
{0x44, (uint8_t[]){0x01, 0xD1}, 2, 0},
|
||||
{0x35, (uint8_t[]){0x00}, 1, 0},
|
||||
{0x53, (uint8_t[]){0x20}, 1, 10},
|
||||
{0x2A, (uint8_t[]){0x00, 0x00, 0x01, 0x6F}, 4, 0},
|
||||
{0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0},
|
||||
{0x51, (uint8_t[]){0x00}, 1, 10},
|
||||
{0x29, (uint8_t[]){0x00}, 0, 10},
|
||||
{0x51, (uint8_t[]){0xFF}, 1, 0},
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private Function Prototypes
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static bool initI2cBus(void);
|
||||
static bool initIoExpander(void);
|
||||
static bool initSpi(void);
|
||||
static bool initLcdPanel(esp_lcd_panel_io_handle_t *ioHandle,
|
||||
esp_lcd_panel_handle_t *panelHandle);
|
||||
static bool initLvgl(esp_lcd_panel_handle_t panelHandle);
|
||||
static void lvglPortTask(void *arg);
|
||||
static void lvglTickCallback(void *arg);
|
||||
static bool lvglFlushReady(esp_lcd_panel_io_handle_t panelIo,
|
||||
esp_lcd_panel_io_event_data_t *eventData,
|
||||
void *userCtx);
|
||||
static void lvglFlushCallback(lv_disp_drv_t *drv, const lv_area_t *area,
|
||||
lv_color_t *colorMap);
|
||||
static void lvglUpdateCallback(lv_disp_drv_t *drv);
|
||||
static void lvglRounderCallback(lv_disp_drv_t *drv, lv_area_t *area);
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
bool displayDriverInit(void) {
|
||||
ESP_LOGI(TAG, "Initializing display subsystem");
|
||||
|
||||
// Suppress noisy log messages from sub-components
|
||||
esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
|
||||
esp_log_level_set("FT5x06", ESP_LOG_NONE);
|
||||
|
||||
// Initialize I2C bus (shared with touch and sensors)
|
||||
if (!initI2cBus()) {
|
||||
ESP_LOGE(TAG, "Failed to initialize I2C bus");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize IO expander for power control
|
||||
if (!initIoExpander()) {
|
||||
ESP_LOGE(TAG, "Failed to initialize IO expander");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize SPI bus for LCD
|
||||
if (!initSpi()) {
|
||||
ESP_LOGE(TAG, "Failed to initialize SPI bus");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize LCD panel driver
|
||||
esp_lcd_panel_io_handle_t ioHandle = NULL;
|
||||
esp_lcd_panel_handle_t panelHandle = NULL;
|
||||
if (!initLcdPanel(&ioHandle, &panelHandle)) {
|
||||
ESP_LOGE(TAG, "Failed to initialize LCD panel");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize LVGL graphics library
|
||||
if (!initLvgl(panelHandle)) {
|
||||
ESP_LOGE(TAG, "Failed to initialize LVGL");
|
||||
return false;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Display subsystem initialized successfully");
|
||||
return true;
|
||||
}
|
||||
|
||||
bool displayDriverLock(int timeoutMs) {
|
||||
if (lvglMutex == NULL) {
|
||||
ESP_LOGE(TAG, "Display not initialized");
|
||||
return false;
|
||||
}
|
||||
TickType_t ticks =
|
||||
(timeoutMs == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeoutMs);
|
||||
return xSemaphoreTake(lvglMutex, ticks) == pdTRUE;
|
||||
}
|
||||
|
||||
void displayDriverUnlock(void) {
|
||||
if (lvglMutex == NULL) {
|
||||
ESP_LOGE(TAG, "Display not initialized");
|
||||
return;
|
||||
}
|
||||
xSemaphoreGive(lvglMutex);
|
||||
}
|
||||
|
||||
lv_obj_t *displayDriverGetActiveScreen(void) { return lv_scr_act(); }
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static bool initI2cBus(void) {
|
||||
ESP_LOGI(TAG, "Initializing I2C bus");
|
||||
|
||||
const i2c_config_t i2cConfig = {
|
||||
.mode = I2C_MODE_MASTER,
|
||||
.sda_io_num = I2C_MASTER_SDA,
|
||||
.sda_pullup_en = GPIO_PULLUP_ENABLE,
|
||||
.scl_io_num = I2C_MASTER_SCL,
|
||||
.scl_pullup_en = GPIO_PULLUP_ENABLE,
|
||||
.master.clk_speed = I2C_MASTER_FREQ_HZ,
|
||||
};
|
||||
|
||||
esp_err_t err = i2c_param_config(I2C_MASTER_PORT, &i2cConfig);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "I2C param config failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
err = i2c_driver_install(I2C_MASTER_PORT, i2cConfig.mode, 0, 0, 0);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "I2C driver install failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool initIoExpander(void) {
|
||||
ESP_LOGI(TAG, "Initializing IO expander");
|
||||
|
||||
esp_io_expander_handle_t ioExpander = NULL;
|
||||
esp_err_t err = esp_io_expander_new_i2c_tca9554(
|
||||
I2C_MASTER_PORT, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &ioExpander);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "IO expander init failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Configure pins 0-2 as outputs for power control
|
||||
esp_io_expander_set_dir(ioExpander,
|
||||
IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_1 |
|
||||
IO_EXPANDER_PIN_NUM_2,
|
||||
IO_EXPANDER_OUTPUT);
|
||||
|
||||
// Power cycle sequence
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_0, 0);
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_1, 0);
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_2, 0);
|
||||
vTaskDelay(pdMS_TO_TICKS(200));
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_0, 1);
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_1, 1);
|
||||
esp_io_expander_set_level(ioExpander, IO_EXPANDER_PIN_NUM_2, 1);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool initSpi(void) {
|
||||
ESP_LOGI(TAG, "Initializing SPI bus");
|
||||
|
||||
const spi_bus_config_t spiConfig = SH8601_PANEL_BUS_QSPI_CONFIG(
|
||||
LCD_PIN_PCLK, LCD_PIN_DATA0, LCD_PIN_DATA1, LCD_PIN_DATA2, LCD_PIN_DATA3,
|
||||
DISPLAY_WIDTH * DISPLAY_HEIGHT * LCD_BIT_PER_PIXEL / 8);
|
||||
|
||||
esp_err_t err = spi_bus_initialize(LCD_SPI_HOST, &spiConfig, SPI_DMA_CH_AUTO);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "SPI bus init failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool initLcdPanel(esp_lcd_panel_io_handle_t *ioHandle,
|
||||
esp_lcd_panel_handle_t *panelHandle) {
|
||||
ESP_LOGI(TAG, "Initializing LCD panel");
|
||||
|
||||
// Configure panel IO
|
||||
const esp_lcd_panel_io_spi_config_t ioConfig =
|
||||
SH8601_PANEL_IO_QSPI_CONFIG(LCD_PIN_CS, lvglFlushReady, &dispDriver);
|
||||
|
||||
sh8601_vendor_config_t vendorConfig = {
|
||||
.init_cmds = lcdInitCmds,
|
||||
.init_cmds_size = sizeof(lcdInitCmds) / sizeof(lcdInitCmds[0]),
|
||||
.flags =
|
||||
{
|
||||
.use_qspi_interface = 1,
|
||||
},
|
||||
};
|
||||
|
||||
esp_err_t err = esp_lcd_new_panel_io_spi(
|
||||
(esp_lcd_spi_bus_handle_t)LCD_SPI_HOST, &ioConfig, ioHandle);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Panel IO init failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Configure panel device
|
||||
const esp_lcd_panel_dev_config_t panelConfig = {
|
||||
.reset_gpio_num = LCD_PIN_RST,
|
||||
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
|
||||
.bits_per_pixel = LCD_BIT_PER_PIXEL,
|
||||
.vendor_config = &vendorConfig,
|
||||
};
|
||||
|
||||
ESP_LOGI(TAG, "Installing SH8601 panel driver");
|
||||
err = esp_lcd_new_panel_sh8601(*ioHandle, &panelConfig, panelHandle);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Panel driver init failed: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize and enable panel
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_reset(*panelHandle));
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_init(*panelHandle));
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(*panelHandle, true));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool initLvgl(esp_lcd_panel_handle_t panelHandle) {
|
||||
ESP_LOGI(TAG, "Initializing LVGL");
|
||||
|
||||
lv_init();
|
||||
|
||||
// Allocate draw buffers with DMA capability
|
||||
lv_color_t *buf1 = heap_caps_malloc(
|
||||
DISPLAY_WIDTH * LVGL_BUFFER_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
|
||||
lv_color_t *buf2 = heap_caps_malloc(
|
||||
DISPLAY_WIDTH * LVGL_BUFFER_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
|
||||
|
||||
if (buf1 == NULL || buf2 == NULL) {
|
||||
ESP_LOGE(TAG, "Failed to allocate LVGL draw buffers");
|
||||
return false;
|
||||
}
|
||||
|
||||
lv_disp_draw_buf_init(&dispBuffer, buf1, buf2,
|
||||
DISPLAY_WIDTH * LVGL_BUFFER_HEIGHT);
|
||||
|
||||
// Register display driver
|
||||
lv_disp_drv_init(&dispDriver);
|
||||
dispDriver.hor_res = DISPLAY_WIDTH;
|
||||
dispDriver.ver_res = DISPLAY_HEIGHT;
|
||||
dispDriver.flush_cb = lvglFlushCallback;
|
||||
dispDriver.rounder_cb = lvglRounderCallback;
|
||||
dispDriver.drv_update_cb = lvglUpdateCallback;
|
||||
dispDriver.draw_buf = &dispBuffer;
|
||||
dispDriver.user_data = panelHandle;
|
||||
lv_disp_drv_register(&dispDriver);
|
||||
|
||||
// Create LVGL tick timer
|
||||
const esp_timer_create_args_t tickTimerArgs = {.callback = lvglTickCallback,
|
||||
.name = "lvgl_tick"};
|
||||
esp_timer_handle_t tickTimer = NULL;
|
||||
ESP_ERROR_CHECK(esp_timer_create(&tickTimerArgs, &tickTimer));
|
||||
ESP_ERROR_CHECK(
|
||||
esp_timer_start_periodic(tickTimer, LVGL_TICK_PERIOD_MS * 1000));
|
||||
|
||||
// Create mutex and port task
|
||||
lvglMutex = xSemaphoreCreateMutex();
|
||||
if (lvglMutex == NULL) {
|
||||
ESP_LOGE(TAG, "Failed to create LVGL mutex");
|
||||
return false;
|
||||
}
|
||||
|
||||
BaseType_t ret = xTaskCreate(lvglPortTask, "lvgl_task", LVGL_TASK_STACK_SIZE,
|
||||
NULL, LVGL_TASK_PRIORITY, NULL);
|
||||
if (ret != pdPASS) {
|
||||
ESP_LOGE(TAG, "Failed to create LVGL task");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// LVGL Callbacks
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void lvglPortTask(void *arg) {
|
||||
ESP_LOGI(TAG, "LVGL task started");
|
||||
uint32_t delayMs = LVGL_TASK_MAX_DELAY_MS;
|
||||
|
||||
while (1) {
|
||||
if (displayDriverLock(-1)) {
|
||||
delayMs = lv_timer_handler();
|
||||
displayDriverUnlock();
|
||||
}
|
||||
|
||||
// Clamp delay to valid range
|
||||
if (delayMs > LVGL_TASK_MAX_DELAY_MS) {
|
||||
delayMs = LVGL_TASK_MAX_DELAY_MS;
|
||||
} else if (delayMs < LVGL_TASK_MIN_DELAY_MS) {
|
||||
delayMs = LVGL_TASK_MIN_DELAY_MS;
|
||||
}
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(delayMs));
|
||||
}
|
||||
}
|
||||
|
||||
static void lvglTickCallback(void *arg) { lv_tick_inc(LVGL_TICK_PERIOD_MS); }
|
||||
|
||||
static bool lvglFlushReady(esp_lcd_panel_io_handle_t panelIo,
|
||||
esp_lcd_panel_io_event_data_t *eventData,
|
||||
void *userCtx) {
|
||||
lv_disp_drv_t *driver = (lv_disp_drv_t *)userCtx;
|
||||
lv_disp_flush_ready(driver);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void lvglFlushCallback(lv_disp_drv_t *drv, const lv_area_t *area,
|
||||
lv_color_t *colorMap) {
|
||||
esp_lcd_panel_handle_t panelHandle = (esp_lcd_panel_handle_t)drv->user_data;
|
||||
const int offsetX1 = area->x1;
|
||||
const int offsetX2 = area->x2;
|
||||
const int offsetY1 = area->y1;
|
||||
const int offsetY2 = area->y2;
|
||||
|
||||
#if LCD_BIT_PER_PIXEL == 24
|
||||
// Convert from LVGL color format to RGB888
|
||||
uint8_t *dest = (uint8_t *)colorMap;
|
||||
uint16_t pixelCount = (offsetX2 - offsetX1 + 1) * (offsetY2 - offsetY1 + 1);
|
||||
|
||||
// Handle first pixel
|
||||
uint8_t temp = colorMap[0].ch.blue;
|
||||
*dest++ = colorMap[0].ch.red;
|
||||
*dest++ = colorMap[0].ch.green;
|
||||
*dest++ = temp;
|
||||
|
||||
// Handle remaining pixels
|
||||
for (int i = 1; i < pixelCount; i++) {
|
||||
*dest++ = colorMap[i].ch.red;
|
||||
*dest++ = colorMap[i].ch.green;
|
||||
*dest++ = colorMap[i].ch.blue;
|
||||
}
|
||||
#endif
|
||||
|
||||
esp_lcd_panel_draw_bitmap(panelHandle, offsetX1, offsetY1, offsetX2 + 1,
|
||||
offsetY2 + 1, colorMap);
|
||||
}
|
||||
|
||||
static void lvglUpdateCallback(lv_disp_drv_t *drv) {
|
||||
esp_lcd_panel_handle_t panelHandle = (esp_lcd_panel_handle_t)drv->user_data;
|
||||
|
||||
switch (drv->rotated) {
|
||||
case LV_DISP_ROT_NONE:
|
||||
esp_lcd_panel_swap_xy(panelHandle, false);
|
||||
esp_lcd_panel_mirror(panelHandle, true, false);
|
||||
break;
|
||||
case LV_DISP_ROT_90:
|
||||
esp_lcd_panel_swap_xy(panelHandle, true);
|
||||
esp_lcd_panel_mirror(panelHandle, true, true);
|
||||
break;
|
||||
case LV_DISP_ROT_180:
|
||||
esp_lcd_panel_swap_xy(panelHandle, false);
|
||||
esp_lcd_panel_mirror(panelHandle, false, true);
|
||||
break;
|
||||
case LV_DISP_ROT_270:
|
||||
esp_lcd_panel_swap_xy(panelHandle, true);
|
||||
esp_lcd_panel_mirror(panelHandle, false, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void lvglRounderCallback(lv_disp_drv_t *drv, lv_area_t *area) {
|
||||
// Round coordinates to even boundaries for SH8601 requirements
|
||||
area->x1 = (area->x1 >> 1) << 1;
|
||||
area->y1 = (area->y1 >> 1) << 1;
|
||||
area->x2 = ((area->x2 >> 1) << 1) + 1;
|
||||
area->y2 = ((area->y2 >> 1) << 1) + 1;
|
||||
}
|
||||
68
main/drivers/display_driver.h
Normal file
68
main/drivers/display_driver.h
Normal file
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* @file display_driver.h
|
||||
* @brief Display driver interface for LCD and LVGL initialization
|
||||
*
|
||||
* This module provides a clean abstraction for display hardware initialization
|
||||
* and LVGL integration. The driver handles SPI bus setup, panel configuration,
|
||||
* IO expander control, and LVGL buffer management.
|
||||
*/
|
||||
|
||||
#ifndef DISPLAY_DRIVER_H
|
||||
#define DISPLAY_DRIVER_H
|
||||
|
||||
#include "lvgl.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Display Driver Interface
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Initialize the display subsystem
|
||||
*
|
||||
* Initializes I2C bus, IO expander, SPI bus, LCD panel driver, and LVGL.
|
||||
* Creates display buffers and starts the LVGL port task.
|
||||
* Must be called before any other display operations.
|
||||
*
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool displayDriverInit(void);
|
||||
|
||||
/**
|
||||
* @brief Acquire LVGL mutex for thread-safe operations
|
||||
*
|
||||
* Call this before any LVGL API calls from outside the LVGL task.
|
||||
* Must be paired with displayDriverUnlock().
|
||||
*
|
||||
* @param timeoutMs Timeout in milliseconds, -1 for infinite wait
|
||||
* @return true if mutex acquired, false on timeout
|
||||
*/
|
||||
bool displayDriverLock(int timeoutMs);
|
||||
|
||||
/**
|
||||
* @brief Release LVGL mutex after thread-safe operations
|
||||
*
|
||||
* Call this after completing LVGL API calls.
|
||||
* Must be preceded by a successful displayDriverLock() call.
|
||||
*/
|
||||
void displayDriverUnlock(void);
|
||||
|
||||
/**
|
||||
* @brief Get the current active LVGL screen
|
||||
*
|
||||
* Convenience wrapper for lv_scr_act() to reduce LVGL coupling.
|
||||
*
|
||||
* @return Pointer to the active screen object
|
||||
*/
|
||||
lv_obj_t *displayDriverGetActiveScreen(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // DISPLAY_DRIVER_H
|
||||
131
main/drivers/touch_driver.c
Normal file
131
main/drivers/touch_driver.c
Normal file
@@ -0,0 +1,131 @@
|
||||
/**
|
||||
* @file touch_driver.c
|
||||
* @brief Touch controller driver implementation for FT5x06
|
||||
*
|
||||
* This module handles touch controller initialization and LVGL integration.
|
||||
* The touch controller uses I2C communication which must be initialized
|
||||
* by the display driver before this module is used.
|
||||
*/
|
||||
|
||||
#include "touch_driver.h"
|
||||
#include "config/display_config.h"
|
||||
#include "config/hardware_config.h"
|
||||
#include "drivers/display_driver.h"
|
||||
|
||||
#include "esp_lcd_panel_io.h"
|
||||
#include "esp_lcd_touch_ft5x06.h"
|
||||
#include "esp_log.h"
|
||||
#include "lvgl.h"
|
||||
|
||||
static const char *TAG = "touch_driver";
|
||||
|
||||
#if TOUCH_ENABLED
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private State
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static esp_lcd_touch_handle_t touchHandle = NULL;
|
||||
static lv_indev_drv_t inputDriver;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private Function Prototypes
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void touchInputCallback(lv_indev_drv_t *drv, lv_indev_data_t *data);
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
bool touchDriverInit(void) {
|
||||
ESP_LOGI(TAG, "Initializing touch controller");
|
||||
|
||||
// Create I2C IO handle for touch controller
|
||||
esp_lcd_panel_io_handle_t tpIoHandle = NULL;
|
||||
const esp_lcd_panel_io_i2c_config_t tpIoConfig =
|
||||
ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
|
||||
|
||||
esp_err_t err = esp_lcd_new_panel_io_i2c(
|
||||
(esp_lcd_i2c_bus_handle_t)I2C_MASTER_PORT, &tpIoConfig, &tpIoHandle);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Failed to create touch panel IO: %s", esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Configure touch controller
|
||||
const esp_lcd_touch_config_t touchConfig = {
|
||||
.x_max = DISPLAY_WIDTH,
|
||||
.y_max = DISPLAY_HEIGHT,
|
||||
.rst_gpio_num = TOUCH_PIN_RST,
|
||||
.int_gpio_num = TOUCH_PIN_INT,
|
||||
.levels =
|
||||
{
|
||||
.reset = 0,
|
||||
.interrupt = 0,
|
||||
},
|
||||
.flags =
|
||||
{
|
||||
.swap_xy = 0,
|
||||
.mirror_x = 0,
|
||||
.mirror_y = 0,
|
||||
},
|
||||
};
|
||||
|
||||
err = esp_lcd_touch_new_i2c_ft5x06(tpIoHandle, &touchConfig, &touchHandle);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Failed to initialize touch controller: %s",
|
||||
esp_err_to_name(err));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Register with LVGL as input device
|
||||
lv_indev_drv_init(&inputDriver);
|
||||
inputDriver.type = LV_INDEV_TYPE_POINTER;
|
||||
inputDriver.read_cb = touchInputCallback;
|
||||
inputDriver.user_data = touchHandle;
|
||||
lv_indev_drv_register(&inputDriver);
|
||||
|
||||
ESP_LOGI(TAG, "Touch controller initialized successfully");
|
||||
return true;
|
||||
}
|
||||
|
||||
esp_lcd_touch_handle_t touchDriverGetHandle(void) { return touchHandle; }
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void touchInputCallback(lv_indev_drv_t *drv, lv_indev_data_t *data) {
|
||||
esp_lcd_touch_handle_t tp = (esp_lcd_touch_handle_t)drv->user_data;
|
||||
if (tp == NULL) {
|
||||
data->state = LV_INDEV_STATE_RELEASED;
|
||||
return;
|
||||
}
|
||||
|
||||
uint16_t x, y;
|
||||
uint8_t count = 0;
|
||||
|
||||
// Read touch data from controller
|
||||
esp_lcd_touch_read_data(tp);
|
||||
bool pressed = esp_lcd_touch_get_coordinates(tp, &x, &y, NULL, &count, 1);
|
||||
|
||||
if (pressed && count > 0) {
|
||||
data->point.x = x;
|
||||
data->point.y = y;
|
||||
data->state = LV_INDEV_STATE_PRESSED;
|
||||
} else {
|
||||
data->state = LV_INDEV_STATE_RELEASED;
|
||||
}
|
||||
}
|
||||
|
||||
#else // TOUCH_ENABLED == 0
|
||||
|
||||
bool touchDriverInit(void) {
|
||||
ESP_LOGI(TAG, "Touch controller disabled in configuration");
|
||||
return true;
|
||||
}
|
||||
|
||||
esp_lcd_touch_handle_t touchDriverGetHandle(void) { return NULL; }
|
||||
|
||||
#endif // TOUCH_ENABLED
|
||||
44
main/drivers/touch_driver.h
Normal file
44
main/drivers/touch_driver.h
Normal file
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
* @file touch_driver.h
|
||||
* @brief Touch controller driver interface
|
||||
*
|
||||
* This module provides abstraction for touch input initialization and
|
||||
* LVGL input device registration. The driver can be enabled/disabled
|
||||
* via TOUCH_ENABLED in hardware_config.h.
|
||||
*/
|
||||
|
||||
#ifndef TOUCH_DRIVER_H
|
||||
#define TOUCH_DRIVER_H
|
||||
|
||||
#include "esp_lcd_touch.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Initialize the touch controller
|
||||
*
|
||||
* Sets up the FT5x06 touch controller over I2C and registers
|
||||
* it as an LVGL input device. The I2C bus must be initialized
|
||||
* before calling this function (done by displayDriverInit).
|
||||
*
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool touchDriverInit(void);
|
||||
|
||||
/**
|
||||
* @brief Get the touch controller handle
|
||||
*
|
||||
* Returns the ESP-LCD touch handle for direct access if needed.
|
||||
*
|
||||
* @return Touch handle, or NULL if not initialized
|
||||
*/
|
||||
esp_lcd_touch_handle_t touchDriverGetHandle(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // TOUCH_DRIVER_H
|
||||
@@ -1,15 +1,18 @@
|
||||
/**
|
||||
* @file blink_animation.c
|
||||
* @file blink_data.h
|
||||
* @brief Embedded blink Lottie animation data
|
||||
*
|
||||
* This file contains the blink.json Lottie animation stored as a C string.
|
||||
* The animation shows two eyes blinking on a 368x448 display at 60fps.
|
||||
* Source file: assets/emotions/blink.json
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#ifndef BLINK_DATA_H
|
||||
#define BLINK_DATA_H
|
||||
|
||||
// Lottie JSON animation data stored in flash
|
||||
const char blink_animation_data[] =
|
||||
// Animation: 368x448, 60fps, 36 frames
|
||||
const char blinkAnimationData[] =
|
||||
"{\"fr\":60,\"h\":448,\"ip\":0,\"layers\":["
|
||||
"{\"ind\":3,\"ty\":4,\"parent\":2,\"ks\":{},\"ip\":0,\"op\":37,\"st\":0,"
|
||||
"\"shapes\":["
|
||||
@@ -17,9 +20,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[48.5,68],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[48.5,13.753],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[48.5,-2.831],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[48.5,0.118],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[48.5,-0.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -28,9 +33,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[48.5,0],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[48.5,54.247],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[48.5,70.831],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[48.5,67.882],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[48.5,68.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -40,9 +47,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[97,136],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[97,27.505],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[97,-5.662],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[97,0.236],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[97,-0.01],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -51,9 +60,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[97,0],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[97,108.495],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[97,141.662],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[97,135.764],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[97,136.01],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -66,9 +77,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[211,88],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[211,142.247],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[211,158.831],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[211,155.882],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[211,156.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -77,9 +90,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[211,156],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[211,101.753],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[211,85.169],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[211,88.118],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[211,87.995],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -92,9 +107,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[48.5,66],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[48.5,13.348],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[48.5,-2.748],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[48.5,0.114],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[48.5,-0.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -103,9 +120,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[48.5,0],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[48.5,54.247],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[48.5,70.831],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[48.5,67.882],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[48.5,68.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -115,9 +134,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[97,132],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[97,26.696],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[97,-5.496],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[97,0.229],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[97,-0.01],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -126,9 +147,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[97,0],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[97,108.495],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[97,141.662],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[97,135.764],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[97,136.01],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -141,9 +164,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":0,\"s\":[48.5,66],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":2.952,\"s\":[48.5,13.348],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":5.898,\"s\":[48.5,-2.748],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":11.802,\"s\":[48.5,0.114],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":17.76,\"s\":[48.5,-0.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -152,9 +177,11 @@ const char blink_animation_data[] =
|
||||
"{\"t\":18,\"s\":[48.5,0],\"i\":{\"x\":[1,0.537],\"y\":[1,0.625]},\"o\":{"
|
||||
"\"x\":[0,0.283],\"y\":[0,0.035]}},"
|
||||
"{\"t\":20.952,\"s\":[48.5,54.247],\"i\":{\"x\":[1,0.69],\"y\":[1,0.998]},"
|
||||
"\"o\":{\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.343],\"y\":[0,0.908]}},"
|
||||
"{\"t\":23.898,\"s\":[48.5,70.831],\"i\":{\"x\":[1,0.282],\"y\":[1,0.996]},"
|
||||
"\"o\":{\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"\"o\":{"
|
||||
"\"x\":[0,0.262],\"y\":[0,0.033]}},"
|
||||
"{\"t\":29.802,\"s\":[48.5,67.882],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
"\"x\":[0,0],\"y\":[0,0]}},"
|
||||
"{\"t\":35.76,\"s\":[48.5,68.005],\"i\":{\"x\":[1,1],\"y\":[1,1]},\"o\":{"
|
||||
@@ -171,3 +198,5 @@ const char blink_animation_data[] =
|
||||
"{\"ind\":0,\"ty\":3,\"ks\":{},\"ip\":0,\"op\":37,\"st\":0}"
|
||||
"],\"meta\":{\"g\":\"https://"
|
||||
"jitter.video\"},\"op\":36,\"v\":\"5.7.4\",\"w\":368}";
|
||||
|
||||
#endif // BLINK_DATA_H
|
||||
90
main/emotion-engine/blink/blink_emotion.c
Normal file
90
main/emotion-engine/blink/blink_emotion.c
Normal file
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* @file blink_emotion.c
|
||||
* @brief Blink emotion animation implementation
|
||||
*
|
||||
* This module implements the idle blink animation using the Lottie player.
|
||||
* It loads the blink animation data and manages playback with natural timing.
|
||||
*/
|
||||
|
||||
#include "emotion-engine/blink/blink_emotion.h"
|
||||
#include "drivers/display_driver.h"
|
||||
#include "emotion-engine/blink/blink_data.h"
|
||||
#include "esp_log.h"
|
||||
#include "ui/lottie_player.h"
|
||||
|
||||
|
||||
static const char *TAG = "blink_emotion";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private State
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static lottie_player_handle_t blinkPlayer = NULL;
|
||||
static bool initialized = false;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
bool blinkEmotionInit(void) {
|
||||
ESP_LOGI(TAG, "Initializing blink emotion");
|
||||
|
||||
// Don't reinitialize if already done
|
||||
if (initialized && blinkPlayer != NULL) {
|
||||
ESP_LOGW(TAG, "Blink emotion already initialized");
|
||||
return true;
|
||||
}
|
||||
|
||||
initialized = true;
|
||||
ESP_LOGI(TAG, "Blink emotion initialized (deferred player creation)");
|
||||
return true;
|
||||
}
|
||||
|
||||
void blinkEmotionPlay(void) {
|
||||
if (!initialized) {
|
||||
ESP_LOGE(TAG, "Blink emotion not initialized");
|
||||
return;
|
||||
}
|
||||
|
||||
// Create player on first play (ensures display is ready)
|
||||
if (blinkPlayer == NULL) {
|
||||
ESP_LOGI(TAG, "Creating blink player");
|
||||
|
||||
lv_obj_t *screen = displayDriverGetActiveScreen();
|
||||
if (screen == NULL) {
|
||||
ESP_LOGE(TAG, "No active screen available");
|
||||
return;
|
||||
}
|
||||
|
||||
blinkPlayer = lottieCreateFromData(screen, blinkAnimationData);
|
||||
if (blinkPlayer == NULL) {
|
||||
ESP_LOGE(TAG, "Failed to create blink player");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Lottie player auto-starts with natural blink mode
|
||||
ESP_LOGI(TAG, "Blink animation active");
|
||||
}
|
||||
|
||||
void blinkEmotionPause(void) {
|
||||
if (blinkPlayer != NULL) {
|
||||
lottiePause(blinkPlayer);
|
||||
}
|
||||
}
|
||||
|
||||
void blinkEmotionStop(void) {
|
||||
if (blinkPlayer != NULL) {
|
||||
lottieDestroy(blinkPlayer);
|
||||
blinkPlayer = NULL;
|
||||
}
|
||||
initialized = false;
|
||||
ESP_LOGI(TAG, "Blink emotion stopped");
|
||||
}
|
||||
|
||||
void blinkEmotionTrigger(void) {
|
||||
if (blinkPlayer != NULL) {
|
||||
lottieSetFrame(blinkPlayer, 0);
|
||||
lottiePlay(blinkPlayer);
|
||||
}
|
||||
}
|
||||
54
main/emotion-engine/blink/blink_emotion.h
Normal file
54
main/emotion-engine/blink/blink_emotion.h
Normal file
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* @file blink_emotion.h
|
||||
* @brief Blink emotion animation interface
|
||||
*
|
||||
* This module handles the idle blink animation using Lottie.
|
||||
* It plays the eyes open/close animation with natural random intervals.
|
||||
*/
|
||||
|
||||
#ifndef BLINK_EMOTION_H
|
||||
#define BLINK_EMOTION_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Initialize the blink emotion
|
||||
*
|
||||
* Loads the blink animation data and prepares the Lottie player.
|
||||
* Must be called after display driver initialization.
|
||||
*
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool blinkEmotionInit(void);
|
||||
|
||||
/**
|
||||
* @brief Start or trigger the blink animation
|
||||
*
|
||||
* Starts the natural blink loop with random intervals.
|
||||
*/
|
||||
void blinkEmotionPlay(void);
|
||||
|
||||
/**
|
||||
* @brief Pause the blink animation
|
||||
*/
|
||||
void blinkEmotionPause(void);
|
||||
|
||||
/**
|
||||
* @brief Stop and cleanup the blink animation
|
||||
*/
|
||||
void blinkEmotionStop(void);
|
||||
|
||||
/**
|
||||
* @brief Trigger a single blink immediately
|
||||
*/
|
||||
void blinkEmotionTrigger(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // BLINK_EMOTION_H
|
||||
107
main/emotion-engine/emotion_manager.c
Normal file
107
main/emotion-engine/emotion_manager.c
Normal file
@@ -0,0 +1,107 @@
|
||||
/**
|
||||
* @file emotion_manager.c
|
||||
* @brief Central emotion coordination system implementation
|
||||
*
|
||||
* This module coordinates all emotion animations. Currently supports
|
||||
* the blink emotion, with architecture ready for additional emotions.
|
||||
*/
|
||||
|
||||
#include "emotion-engine/emotion_manager.h"
|
||||
#include "drivers/display_driver.h"
|
||||
#include "emotion-engine/blink/blink_emotion.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
|
||||
static const char *TAG = "emotion_manager";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private State
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static EmotionType currentEmotion = EMOTION_IDLE;
|
||||
static bool initialized = false;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
bool emotionManagerInit(void) {
|
||||
ESP_LOGI(TAG, "Initializing emotion manager");
|
||||
|
||||
// Initialize blink emotion
|
||||
if (!blinkEmotionInit()) {
|
||||
ESP_LOGE(TAG, "Failed to initialize blink emotion");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Future: Initialize other emotions here
|
||||
// surprisedEmotionInit();
|
||||
// sadEmotionInit();
|
||||
// angryEmotionInit();
|
||||
|
||||
initialized = true;
|
||||
currentEmotion = EMOTION_IDLE;
|
||||
|
||||
ESP_LOGI(TAG, "Emotion manager initialized");
|
||||
return true;
|
||||
}
|
||||
|
||||
void emotionManagerStart(void) {
|
||||
if (!initialized) {
|
||||
ESP_LOGE(TAG, "Emotion manager not initialized");
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Starting emotion engine with idle state");
|
||||
|
||||
// Start the blink animation (idle state with natural blinking)
|
||||
blinkEmotionPlay();
|
||||
currentEmotion = EMOTION_IDLE;
|
||||
}
|
||||
|
||||
void emotionManagerSetEmotion(EmotionType emotion) {
|
||||
if (!initialized) {
|
||||
ESP_LOGE(TAG, "Emotion manager not initialized");
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Setting emotion: %d", emotion);
|
||||
currentEmotion = emotion;
|
||||
|
||||
// Handle emotion transitions
|
||||
switch (emotion) {
|
||||
case EMOTION_IDLE:
|
||||
case EMOTION_BLINK:
|
||||
// Play blink animation
|
||||
blinkEmotionPlay();
|
||||
break;
|
||||
|
||||
case EMOTION_SURPRISED:
|
||||
case EMOTION_SAD:
|
||||
case EMOTION_ANGRY:
|
||||
// Future: Implement other emotion animations
|
||||
// For now, trigger a blink as visual feedback
|
||||
ESP_LOGI(TAG, "Emotion %d not yet implemented, using blink", emotion);
|
||||
blinkEmotionPlay();
|
||||
break;
|
||||
|
||||
default:
|
||||
ESP_LOGW(TAG, "Unknown emotion type: %d", emotion);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
EmotionType emotionManagerGetCurrent(void) { return currentEmotion; }
|
||||
|
||||
void emotionManagerStop(void) {
|
||||
if (!initialized) {
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Stopping emotion manager");
|
||||
|
||||
blinkEmotionStop();
|
||||
// Future: Stop other emotions
|
||||
|
||||
initialized = false;
|
||||
}
|
||||
84
main/emotion-engine/emotion_manager.h
Normal file
84
main/emotion-engine/emotion_manager.h
Normal file
@@ -0,0 +1,84 @@
|
||||
/**
|
||||
* @file emotion_manager.h
|
||||
* @brief Central emotion coordination system
|
||||
*
|
||||
* This module manages all emotion-related animations and coordinates
|
||||
* transitions between emotional states. It provides a unified interface
|
||||
* for triggering emotions from various sources (shake, touch, etc.).
|
||||
*/
|
||||
|
||||
#ifndef EMOTION_MANAGER_H
|
||||
#define EMOTION_MANAGER_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Type Definitions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Supported emotion types
|
||||
*/
|
||||
typedef enum {
|
||||
EMOTION_IDLE = 0, // Default idle state with blink
|
||||
EMOTION_BLINK, // Single blink animation
|
||||
EMOTION_SURPRISED, // Surprised expression
|
||||
EMOTION_SAD, // Sad expression
|
||||
EMOTION_ANGRY, // Angry expression
|
||||
EMOTION_COUNT
|
||||
} EmotionType;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Initialize the emotion engine
|
||||
*
|
||||
* Sets up all emotion animations and prepares the system.
|
||||
* Must be called after display driver initialization.
|
||||
*
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool emotionManagerInit(void);
|
||||
|
||||
/**
|
||||
* @brief Start the emotion engine with default state
|
||||
*
|
||||
* Begins the idle animation with natural blinking.
|
||||
* Call this after splash screen is complete.
|
||||
*/
|
||||
void emotionManagerStart(void);
|
||||
|
||||
/**
|
||||
* @brief Trigger a specific emotion
|
||||
*
|
||||
* Plays the specified emotion animation. The system will
|
||||
* automatically return to idle state after the animation completes.
|
||||
*
|
||||
* @param emotion The emotion to trigger
|
||||
*/
|
||||
void emotionManagerSetEmotion(EmotionType emotion);
|
||||
|
||||
/**
|
||||
* @brief Get the currently active emotion
|
||||
*
|
||||
* @return The current emotion type
|
||||
*/
|
||||
EmotionType emotionManagerGetCurrent(void);
|
||||
|
||||
/**
|
||||
* @brief Stop all emotions and cleanup
|
||||
*/
|
||||
void emotionManagerStop(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // EMOTION_MANAGER_H
|
||||
@@ -1,437 +0,0 @@
|
||||
#include <stdio.h>
|
||||
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/i2c.h"
|
||||
#include "driver/spi_master.h"
|
||||
#include "esp_err.h"
|
||||
#include "esp_lcd_panel_io.h"
|
||||
#include "esp_lcd_panel_ops.h"
|
||||
#include "esp_lcd_panel_vendor.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include <math.h>
|
||||
|
||||
#include "esp_lcd_sh8601.h"
|
||||
#include "esp_lcd_touch_ft5x06.h"
|
||||
#include "lottie_player.h"
|
||||
#include "lvgl.h"
|
||||
|
||||
|
||||
#include "esp_io_expander_tca9554.h"
|
||||
|
||||
#include "shake_detector.h"
|
||||
#include "splash_screen.h"
|
||||
|
||||
static const char *TAG = "example";
|
||||
static SemaphoreHandle_t lvgl_mux = NULL;
|
||||
|
||||
#define LCD_HOST SPI2_HOST
|
||||
#define TOUCH_HOST I2C_NUM_0
|
||||
|
||||
#if CONFIG_LV_COLOR_DEPTH == 32
|
||||
#define LCD_BIT_PER_PIXEL (24)
|
||||
#elif CONFIG_LV_COLOR_DEPTH == 16
|
||||
#define LCD_BIT_PER_PIXEL (16)
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//////////////////// Please update the following configuration according to your
|
||||
/// LCD spec //////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 1
|
||||
#define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL
|
||||
#define EXAMPLE_PIN_NUM_LCD_CS (GPIO_NUM_12)
|
||||
#define EXAMPLE_PIN_NUM_LCD_PCLK (GPIO_NUM_11)
|
||||
#define EXAMPLE_PIN_NUM_LCD_DATA0 (GPIO_NUM_4)
|
||||
#define EXAMPLE_PIN_NUM_LCD_DATA1 (GPIO_NUM_5)
|
||||
#define EXAMPLE_PIN_NUM_LCD_DATA2 (GPIO_NUM_6)
|
||||
#define EXAMPLE_PIN_NUM_LCD_DATA3 (GPIO_NUM_7)
|
||||
#define EXAMPLE_PIN_NUM_LCD_RST (-1)
|
||||
#define EXAMPLE_PIN_NUM_BK_LIGHT (-1)
|
||||
|
||||
// The pixel number in horizontal and vertical
|
||||
#define EXAMPLE_LCD_H_RES 368
|
||||
#define EXAMPLE_LCD_V_RES 448
|
||||
|
||||
#define EXAMPLE_USE_TOUCH 1
|
||||
|
||||
#if EXAMPLE_USE_TOUCH
|
||||
#define EXAMPLE_PIN_NUM_TOUCH_SCL (GPIO_NUM_14)
|
||||
#define EXAMPLE_PIN_NUM_TOUCH_SDA (GPIO_NUM_15)
|
||||
#define EXAMPLE_PIN_NUM_TOUCH_RST (-1)
|
||||
#define EXAMPLE_PIN_NUM_TOUCH_INT (GPIO_NUM_21)
|
||||
|
||||
esp_lcd_touch_handle_t tp = NULL;
|
||||
#endif
|
||||
|
||||
#define EXAMPLE_LVGL_BUF_HEIGHT (EXAMPLE_LCD_V_RES / 4)
|
||||
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
|
||||
#define EXAMPLE_LVGL_TASK_MAX_DELAY_MS 500
|
||||
#define EXAMPLE_LVGL_TASK_MIN_DELAY_MS 1
|
||||
#define EXAMPLE_LVGL_TASK_STACK_SIZE (4 * 1024)
|
||||
#define EXAMPLE_LVGL_TASK_PRIORITY 2
|
||||
|
||||
static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
|
||||
{0x11, (uint8_t[]){0x00}, 0, 120},
|
||||
{0x44, (uint8_t[]){0x01, 0xD1}, 2, 0},
|
||||
{0x35, (uint8_t[]){0x00}, 1, 0},
|
||||
{0x53, (uint8_t[]){0x20}, 1, 10},
|
||||
{0x2A, (uint8_t[]){0x00, 0x00, 0x01, 0x6F}, 4, 0},
|
||||
{0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0},
|
||||
{0x51, (uint8_t[]){0x00}, 1, 10},
|
||||
{0x29, (uint8_t[]){0x00}, 0, 10},
|
||||
{0x51, (uint8_t[]){0xFF}, 1, 0},
|
||||
};
|
||||
|
||||
static bool
|
||||
example_notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io,
|
||||
esp_lcd_panel_io_event_data_t *edata,
|
||||
void *user_ctx) {
|
||||
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
|
||||
lv_disp_flush_ready(disp_driver);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void example_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area,
|
||||
lv_color_t *color_map) {
|
||||
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
|
||||
const int offsetx1 = area->x1;
|
||||
const int offsetx2 = area->x2;
|
||||
const int offsety1 = area->y1;
|
||||
const int offsety2 = area->y2;
|
||||
|
||||
#if LCD_BIT_PER_PIXEL == 24
|
||||
uint8_t *to = (uint8_t *)color_map;
|
||||
uint8_t temp = 0;
|
||||
uint16_t pixel_num = (offsetx2 - offsetx1 + 1) * (offsety2 - offsety1 + 1);
|
||||
|
||||
// Special dealing for first pixel
|
||||
temp = color_map[0].ch.blue;
|
||||
*to++ = color_map[0].ch.red;
|
||||
*to++ = color_map[0].ch.green;
|
||||
*to++ = temp;
|
||||
// Normal dealing for other pixels
|
||||
for (int i = 1; i < pixel_num; i++) {
|
||||
*to++ = color_map[i].ch.red;
|
||||
*to++ = color_map[i].ch.green;
|
||||
*to++ = color_map[i].ch.blue;
|
||||
}
|
||||
#endif
|
||||
|
||||
// copy a buffer's content to a specific area of the display
|
||||
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1,
|
||||
offsety2 + 1, color_map);
|
||||
}
|
||||
|
||||
/* Rotate display and touch, when rotated screen in LVGL. Called when driver
|
||||
* parameters are updated. */
|
||||
static void example_lvgl_update_cb(lv_disp_drv_t *drv) {
|
||||
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
|
||||
|
||||
switch (drv->rotated) {
|
||||
case LV_DISP_ROT_NONE:
|
||||
// Rotate LCD display
|
||||
esp_lcd_panel_swap_xy(panel_handle, false);
|
||||
esp_lcd_panel_mirror(panel_handle, true, false);
|
||||
break;
|
||||
case LV_DISP_ROT_90:
|
||||
// Rotate LCD display
|
||||
esp_lcd_panel_swap_xy(panel_handle, true);
|
||||
esp_lcd_panel_mirror(panel_handle, true, true);
|
||||
break;
|
||||
case LV_DISP_ROT_180:
|
||||
// Rotate LCD display
|
||||
esp_lcd_panel_swap_xy(panel_handle, false);
|
||||
esp_lcd_panel_mirror(panel_handle, false, true);
|
||||
break;
|
||||
case LV_DISP_ROT_270:
|
||||
// Rotate LCD display
|
||||
esp_lcd_panel_swap_xy(panel_handle, true);
|
||||
esp_lcd_panel_mirror(panel_handle, false, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void example_lvgl_rounder_cb(struct _lv_disp_drv_t *disp_drv, lv_area_t *area) {
|
||||
uint16_t x1 = area->x1;
|
||||
uint16_t x2 = area->x2;
|
||||
|
||||
uint16_t y1 = area->y1;
|
||||
uint16_t y2 = area->y2;
|
||||
|
||||
// round the start of coordinate down to the nearest 2M number
|
||||
area->x1 = (x1 >> 1) << 1;
|
||||
area->y1 = (y1 >> 1) << 1;
|
||||
// round the end of coordinate up to the nearest 2N+1 number
|
||||
area->x2 = ((x2 >> 1) << 1) + 1;
|
||||
area->y2 = ((y2 >> 1) << 1) + 1;
|
||||
}
|
||||
|
||||
#if EXAMPLE_USE_TOUCH
|
||||
static void example_lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data) {
|
||||
esp_lcd_touch_handle_t tp = (esp_lcd_touch_handle_t)drv->user_data;
|
||||
assert(tp);
|
||||
|
||||
uint16_t tp_x;
|
||||
uint16_t tp_y;
|
||||
uint8_t tp_cnt = 0;
|
||||
/* Read data from touch controller into memory */
|
||||
esp_lcd_touch_read_data(tp);
|
||||
/* Read data from touch controller */
|
||||
bool tp_pressed =
|
||||
esp_lcd_touch_get_coordinates(tp, &tp_x, &tp_y, NULL, &tp_cnt, 1);
|
||||
if (tp_pressed && tp_cnt > 0) {
|
||||
data->point.x = tp_x;
|
||||
data->point.y = tp_y;
|
||||
data->state = LV_INDEV_STATE_PRESSED;
|
||||
ESP_LOGD(TAG, "Touch position: %d,%d", tp_x, tp_y);
|
||||
} else {
|
||||
data->state = LV_INDEV_STATE_RELEASED;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void example_increase_lvgl_tick(void *arg) {
|
||||
/* Tell LVGL how many milliseconds has elapsed */
|
||||
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
|
||||
}
|
||||
|
||||
static bool example_lvgl_lock(int timeout_ms) {
|
||||
assert(lvgl_mux && "bsp_display_start must be called first");
|
||||
|
||||
const TickType_t timeout_ticks =
|
||||
(timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
|
||||
return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE;
|
||||
}
|
||||
|
||||
static void example_lvgl_unlock(void) {
|
||||
assert(lvgl_mux && "bsp_display_start must be called first");
|
||||
xSemaphoreGive(lvgl_mux);
|
||||
}
|
||||
|
||||
static void example_lvgl_port_task(void *arg) {
|
||||
ESP_LOGI(TAG, "Starting LVGL task");
|
||||
uint32_t task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
|
||||
|
||||
while (1) {
|
||||
// Lock the mutex due to the LVGL APIs being not thread-safe
|
||||
if (example_lvgl_lock(-1)) {
|
||||
task_delay_ms = lv_timer_handler();
|
||||
example_lvgl_unlock();
|
||||
}
|
||||
|
||||
if (task_delay_ms > EXAMPLE_LVGL_TASK_MAX_DELAY_MS) {
|
||||
task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
|
||||
} else if (task_delay_ms < EXAMPLE_LVGL_TASK_MIN_DELAY_MS) {
|
||||
task_delay_ms = EXAMPLE_LVGL_TASK_MIN_DELAY_MS;
|
||||
}
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
|
||||
}
|
||||
}
|
||||
|
||||
static void shake_task(void *arg) {
|
||||
ESP_LOGI(TAG, "Shake task idle");
|
||||
while (1) {
|
||||
vTaskDelay(pdMS_TO_TICKS(1000));
|
||||
}
|
||||
}
|
||||
|
||||
void app_main(void) {
|
||||
esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
|
||||
esp_log_level_set("FT5x06", ESP_LOG_NONE);
|
||||
static lv_disp_draw_buf_t
|
||||
disp_buf; // contains internal graphic buffer(s) called draw buffer(s)
|
||||
static lv_disp_drv_t disp_drv; // contains callback functions
|
||||
|
||||
ESP_LOGI(TAG, "Initialize I2C bus");
|
||||
const i2c_config_t i2c_conf = {
|
||||
.mode = I2C_MODE_MASTER,
|
||||
.sda_io_num = EXAMPLE_PIN_NUM_TOUCH_SDA,
|
||||
.sda_pullup_en = GPIO_PULLUP_ENABLE,
|
||||
.scl_io_num = EXAMPLE_PIN_NUM_TOUCH_SCL,
|
||||
.scl_pullup_en = GPIO_PULLUP_ENABLE,
|
||||
.master.clk_speed = 200 * 1000,
|
||||
};
|
||||
ESP_ERROR_CHECK(i2c_param_config(TOUCH_HOST, &i2c_conf));
|
||||
ESP_ERROR_CHECK(i2c_driver_install(TOUCH_HOST, i2c_conf.mode, 0, 0, 0));
|
||||
|
||||
esp_io_expander_handle_t io_expander = NULL;
|
||||
esp_io_expander_new_i2c_tca9554(
|
||||
TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);
|
||||
|
||||
ESP_ERROR_CHECK(esp_io_expander_new_i2c_tca9554(
|
||||
TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander));
|
||||
|
||||
esp_io_expander_set_dir(io_expander,
|
||||
IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_1 |
|
||||
IO_EXPANDER_PIN_NUM_2,
|
||||
IO_EXPANDER_OUTPUT);
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 0);
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 0);
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 0);
|
||||
vTaskDelay(pdMS_TO_TICKS(200));
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 1);
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 1);
|
||||
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 1);
|
||||
|
||||
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
||||
ESP_LOGI(TAG, "Turn off LCD backlight");
|
||||
gpio_config_t bk_gpio_config = {.mode = GPIO_MODE_OUTPUT,
|
||||
.pin_bit_mask = 1ULL
|
||||
<< EXAMPLE_PIN_NUM_BK_LIGHT};
|
||||
ESP_ERROR_CHECK(gpio_config(&bk_gpio_config));
|
||||
#endif
|
||||
|
||||
ESP_LOGI(TAG, "Initialize SPI bus");
|
||||
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG(
|
||||
EXAMPLE_PIN_NUM_LCD_PCLK, EXAMPLE_PIN_NUM_LCD_DATA0,
|
||||
EXAMPLE_PIN_NUM_LCD_DATA1, EXAMPLE_PIN_NUM_LCD_DATA2,
|
||||
EXAMPLE_PIN_NUM_LCD_DATA3,
|
||||
EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES * LCD_BIT_PER_PIXEL / 8);
|
||||
ESP_ERROR_CHECK(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
|
||||
|
||||
ESP_LOGI(TAG, "Install panel IO");
|
||||
esp_lcd_panel_io_handle_t io_handle = NULL;
|
||||
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(
|
||||
EXAMPLE_PIN_NUM_LCD_CS, example_notify_lvgl_flush_ready, &disp_drv);
|
||||
sh8601_vendor_config_t vendor_config = {
|
||||
.init_cmds = lcd_init_cmds,
|
||||
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
|
||||
.flags =
|
||||
{
|
||||
.use_qspi_interface = 1,
|
||||
},
|
||||
};
|
||||
// Attach the LCD to the SPI bus
|
||||
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST,
|
||||
&io_config, &io_handle));
|
||||
|
||||
esp_lcd_panel_handle_t panel_handle = NULL;
|
||||
const esp_lcd_panel_dev_config_t panel_config = {
|
||||
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
|
||||
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
|
||||
.bits_per_pixel = LCD_BIT_PER_PIXEL,
|
||||
.vendor_config = &vendor_config,
|
||||
};
|
||||
ESP_LOGI(TAG, "Install SH8601 panel driver");
|
||||
ESP_ERROR_CHECK(
|
||||
esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
|
||||
// user can flush pre-defined pattern to the screen before we turn on the
|
||||
// screen or backlight
|
||||
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
|
||||
|
||||
#if EXAMPLE_USE_TOUCH
|
||||
|
||||
esp_lcd_panel_io_handle_t tp_io_handle = NULL;
|
||||
const esp_lcd_panel_io_i2c_config_t tp_io_config =
|
||||
ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
|
||||
// Attach the TOUCH to the I2C bus
|
||||
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TOUCH_HOST,
|
||||
&tp_io_config, &tp_io_handle));
|
||||
|
||||
const esp_lcd_touch_config_t tp_cfg = {
|
||||
.x_max = EXAMPLE_LCD_H_RES,
|
||||
.y_max = EXAMPLE_LCD_V_RES,
|
||||
.rst_gpio_num = EXAMPLE_PIN_NUM_TOUCH_RST,
|
||||
.int_gpio_num = EXAMPLE_PIN_NUM_TOUCH_INT,
|
||||
.levels =
|
||||
{
|
||||
.reset = 0,
|
||||
.interrupt = 0,
|
||||
},
|
||||
.flags =
|
||||
{
|
||||
.swap_xy = 0,
|
||||
.mirror_x = 0,
|
||||
.mirror_y = 0,
|
||||
},
|
||||
};
|
||||
|
||||
ESP_LOGI(TAG, "Initialize touch controller");
|
||||
ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp));
|
||||
|
||||
#endif
|
||||
|
||||
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
||||
ESP_LOGI(TAG, "Turn on LCD backlight");
|
||||
gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL);
|
||||
#endif
|
||||
|
||||
ESP_LOGI(TAG, "Initialize LVGL library");
|
||||
lv_init();
|
||||
// alloc draw buffers used by LVGL
|
||||
// it's recommended to choose the size of the draw buffer(s) to be at least
|
||||
// 1/10 screen sized
|
||||
lv_color_t *buf1 = heap_caps_malloc(
|
||||
EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t),
|
||||
MALLOC_CAP_DMA);
|
||||
assert(buf1);
|
||||
lv_color_t *buf2 = heap_caps_malloc(
|
||||
EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t),
|
||||
MALLOC_CAP_DMA);
|
||||
assert(buf2);
|
||||
// initialize LVGL draw buffers
|
||||
lv_disp_draw_buf_init(&disp_buf, buf1, buf2,
|
||||
EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT);
|
||||
|
||||
ESP_LOGI(TAG, "Register display driver to LVGL");
|
||||
lv_disp_drv_init(&disp_drv);
|
||||
disp_drv.hor_res = EXAMPLE_LCD_H_RES;
|
||||
disp_drv.ver_res = EXAMPLE_LCD_V_RES;
|
||||
disp_drv.flush_cb = example_lvgl_flush_cb;
|
||||
disp_drv.rounder_cb = example_lvgl_rounder_cb;
|
||||
disp_drv.drv_update_cb = example_lvgl_update_cb;
|
||||
disp_drv.draw_buf = &disp_buf;
|
||||
disp_drv.user_data = panel_handle;
|
||||
lv_disp_t *disp = lv_disp_drv_register(&disp_drv);
|
||||
|
||||
ESP_LOGI(TAG, "Install LVGL tick timer");
|
||||
// Tick interface for LVGL (using esp_timer to generate 2ms periodic event)
|
||||
const esp_timer_create_args_t lvgl_tick_timer_args = {
|
||||
.callback = &example_increase_lvgl_tick, .name = "lvgl_tick"};
|
||||
esp_timer_handle_t lvgl_tick_timer = NULL;
|
||||
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
|
||||
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer,
|
||||
EXAMPLE_LVGL_TICK_PERIOD_MS * 1000));
|
||||
|
||||
#if EXAMPLE_USE_TOUCH
|
||||
static lv_indev_drv_t indev_drv; // Input device driver (Touch)
|
||||
lv_indev_drv_init(&indev_drv);
|
||||
indev_drv.type = LV_INDEV_TYPE_POINTER;
|
||||
indev_drv.disp = disp;
|
||||
indev_drv.read_cb = example_lvgl_touch_cb;
|
||||
indev_drv.user_data = tp;
|
||||
lv_indev_drv_register(&indev_drv);
|
||||
#endif
|
||||
|
||||
lvgl_mux = xSemaphoreCreateMutex();
|
||||
assert(lvgl_mux);
|
||||
xTaskCreate(example_lvgl_port_task, "LVGL", EXAMPLE_LVGL_TASK_STACK_SIZE,
|
||||
NULL, EXAMPLE_LVGL_TASK_PRIORITY, NULL);
|
||||
|
||||
// Lock the mutex due to the LVGL APIs are not thread-safe
|
||||
if (example_lvgl_lock(-1)) {
|
||||
// Show splash screen first
|
||||
ESP_LOGI(TAG, "Showing splash screen");
|
||||
splash_screen_show();
|
||||
|
||||
// Start blink animation loop
|
||||
ESP_LOGI(TAG, "Starting blink animation");
|
||||
extern const char blink_animation_data[];
|
||||
lottie_create_from_data(lv_scr_act(), blink_animation_data);
|
||||
|
||||
// Release the mutex
|
||||
example_lvgl_unlock();
|
||||
|
||||
// Initialize Shake Detector
|
||||
if (shake_detector_init()) {
|
||||
// Create a task to poll the shake detector
|
||||
xTaskCreate(shake_task, "shake_task", 4096, NULL, 5, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,985 +0,0 @@
|
||||
/**
|
||||
* @file lottie_player.c
|
||||
* @brief Lightweight Lottie animation player implementation for LVGL on ESP32
|
||||
*
|
||||
* This implementation provides a minimal Lottie JSON parser and renderer
|
||||
* optimized for simple shape-based animations. It supports:
|
||||
* - Rounded rectangle shapes
|
||||
* - Position, size, and corner radius animation
|
||||
* - Keyframe interpolation with bezier easing
|
||||
* - Solid color fills
|
||||
*
|
||||
* The parser extracts only the data needed for rendering, minimizing memory
|
||||
* usage on resource-constrained embedded systems.
|
||||
*/
|
||||
|
||||
#include "lottie_player.h"
|
||||
#include "cJSON.h"
|
||||
#include "esp_heap_caps.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_random.h"
|
||||
#include "esp_timer.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static const char *TAG = "lottie_player";
|
||||
|
||||
// Maximum supported keyframes per property (memory optimization)
|
||||
#define MAX_KEYFRAMES 16
|
||||
|
||||
// Maximum supported layers in animation
|
||||
#define MAX_LAYERS 8
|
||||
|
||||
// Maximum supported shapes per layer
|
||||
#define MAX_SHAPES 4
|
||||
|
||||
/**
|
||||
* Keyframe data structure for animated properties
|
||||
*/
|
||||
typedef struct {
|
||||
float time; // Frame time
|
||||
float value[2]; // Value at this keyframe (x, y or single value)
|
||||
float in_tangent[2]; // Bezier in-tangent
|
||||
float out_tangent[2]; // Bezier out-tangent
|
||||
bool hold; // If true, hold value until next keyframe
|
||||
} lottie_keyframe_t;
|
||||
|
||||
/**
|
||||
* Animated property that can have keyframes or static value
|
||||
*/
|
||||
typedef struct {
|
||||
bool animated;
|
||||
float static_value[2];
|
||||
lottie_keyframe_t keyframes[MAX_KEYFRAMES];
|
||||
uint8_t keyframe_count;
|
||||
} lottie_property_t;
|
||||
|
||||
/**
|
||||
* Rounded rectangle shape definition
|
||||
*/
|
||||
typedef struct {
|
||||
lottie_property_t position; // Center position
|
||||
lottie_property_t size; // Width and height
|
||||
lottie_property_t corner_radius; // Corner radius
|
||||
lv_color_t fill_color; // Fill color
|
||||
uint8_t fill_opacity; // Fill opacity (0-100)
|
||||
bool valid;
|
||||
} lottie_rounded_rect_t;
|
||||
|
||||
/**
|
||||
* Layer in the animation
|
||||
*/
|
||||
typedef struct {
|
||||
int index; // Layer index
|
||||
int parent; // Parent layer index (-1 if none)
|
||||
int type; // Layer type (3=null, 4=shape)
|
||||
lottie_property_t position; // Transform position
|
||||
lottie_property_t anchor; // Anchor point
|
||||
lottie_rounded_rect_t shapes[MAX_SHAPES];
|
||||
uint8_t shape_count;
|
||||
bool valid;
|
||||
} lottie_layer_t;
|
||||
|
||||
/**
|
||||
* Main player state structure
|
||||
*/
|
||||
struct lottie_player_t {
|
||||
// Animation metadata
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
float framerate;
|
||||
uint32_t total_frames;
|
||||
uint32_t in_point; // Start frame
|
||||
uint32_t out_point; // End frame
|
||||
|
||||
// Layers
|
||||
lottie_layer_t layers[MAX_LAYERS];
|
||||
uint8_t layer_count;
|
||||
|
||||
// Playback state
|
||||
float current_frame;
|
||||
bool playing;
|
||||
bool loop;
|
||||
int64_t start_time_us; // Animation start time in microseconds
|
||||
|
||||
// Natural blink mode
|
||||
bool natural_blink_mode; // If true, shows idle state with random blinks
|
||||
lv_timer_t *blink_timer; // Timer for triggering random blinks
|
||||
|
||||
// LVGL objects
|
||||
lv_obj_t *canvas;
|
||||
lv_color_t *canvas_buf;
|
||||
lv_timer_t *timer;
|
||||
};
|
||||
|
||||
// Forward declarations
|
||||
static void lottie_parse_animation(lottie_player_handle_t handle,
|
||||
const cJSON *root);
|
||||
static void lottie_parse_layers(lottie_player_handle_t handle,
|
||||
const cJSON *layers);
|
||||
static void lottie_parse_layer(lottie_layer_t *layer, const cJSON *json);
|
||||
static void lottie_parse_shapes(lottie_layer_t *layer, const cJSON *shapes);
|
||||
static void lottie_parse_property(lottie_property_t *prop, const cJSON *json);
|
||||
static float lottie_interpolate_property(const lottie_property_t *prop,
|
||||
float frame, int index);
|
||||
static void lottie_render_frame(lottie_player_handle_t handle);
|
||||
static void lottie_timer_cb(lv_timer_t *timer);
|
||||
static void lottie_blink_timer_cb(lv_timer_t *timer);
|
||||
static void lottie_schedule_next_blink(lottie_player_handle_t handle);
|
||||
static float lottie_bezier_interpolate(float t, float p0, float p1, float p2,
|
||||
float p3);
|
||||
|
||||
/**
|
||||
* Create a Lottie player from JSON data
|
||||
*/
|
||||
lottie_player_handle_t lottie_create_from_data(lv_obj_t *parent,
|
||||
const char *json_data) {
|
||||
if (!parent || !json_data) {
|
||||
ESP_LOGE(TAG, "Invalid parameters");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Parse JSON
|
||||
cJSON *root = cJSON_Parse(json_data);
|
||||
if (!root) {
|
||||
ESP_LOGE(TAG, "Failed to parse JSON: %s", cJSON_GetErrorPtr());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Allocate player structure
|
||||
lottie_player_handle_t handle = calloc(1, sizeof(struct lottie_player_t));
|
||||
if (!handle) {
|
||||
ESP_LOGE(TAG, "Failed to allocate player");
|
||||
cJSON_Delete(root);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Set defaults
|
||||
handle->playing = false;
|
||||
handle->loop = true;
|
||||
handle->current_frame = 0;
|
||||
|
||||
// Parse animation data
|
||||
lottie_parse_animation(handle, root);
|
||||
|
||||
// Cleanup JSON (we've extracted what we need)
|
||||
cJSON_Delete(root);
|
||||
|
||||
// Validate parsed data
|
||||
if (handle->width == 0 || handle->height == 0 || handle->total_frames == 0) {
|
||||
ESP_LOGE(TAG, "Invalid animation data");
|
||||
free(handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Parsed animation: %dx%d, %lu frames at %.1f fps",
|
||||
handle->width, handle->height, (unsigned long)handle->total_frames,
|
||||
handle->framerate);
|
||||
ESP_LOGI(TAG, "Loaded %d layers", handle->layer_count);
|
||||
|
||||
// Allocate canvas buffer
|
||||
size_t buf_size = handle->width * handle->height * sizeof(lv_color_t);
|
||||
handle->canvas_buf =
|
||||
heap_caps_malloc(buf_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if (!handle->canvas_buf) {
|
||||
// Try regular RAM if SPIRAM not available
|
||||
handle->canvas_buf = malloc(buf_size);
|
||||
}
|
||||
if (!handle->canvas_buf) {
|
||||
ESP_LOGE(TAG, "Failed to allocate canvas buffer (%u bytes)",
|
||||
(unsigned)buf_size);
|
||||
free(handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Create LVGL canvas
|
||||
handle->canvas = lv_canvas_create(parent);
|
||||
lv_canvas_set_buffer(handle->canvas, handle->canvas_buf, handle->width,
|
||||
handle->height, LV_IMG_CF_TRUE_COLOR);
|
||||
lv_obj_center(handle->canvas);
|
||||
|
||||
// Speed up animation for snappier blinks (2x speed)
|
||||
// The canvas rendering is slow (~110ms per frame), so we need faster playback
|
||||
handle->framerate *= 2.0f;
|
||||
|
||||
// Create timer for animation playback (use faster period for responsiveness)
|
||||
uint32_t period_ms = 16; // ~60Hz refresh attempts
|
||||
handle->timer = lv_timer_create(lottie_timer_cb, period_ms, handle);
|
||||
lv_timer_pause(handle->timer);
|
||||
|
||||
// Enable natural blink mode by default
|
||||
handle->natural_blink_mode = true;
|
||||
handle->loop = false; // Don't loop in natural mode
|
||||
|
||||
// Show idle state (last frame = eyes open)
|
||||
handle->current_frame = handle->total_frames - 1;
|
||||
lottie_render_frame(handle);
|
||||
|
||||
// Create blink timer with random initial delay (2-5 seconds)
|
||||
uint32_t initial_delay = 2000 + (esp_random() % 3000);
|
||||
handle->blink_timer =
|
||||
lv_timer_create(lottie_blink_timer_cb, initial_delay, handle);
|
||||
lv_timer_set_repeat_count(handle->blink_timer,
|
||||
1); // One-shot, will be recreated
|
||||
|
||||
ESP_LOGI(TAG, "Natural blink mode enabled, first blink in %lu ms",
|
||||
(unsigned long)initial_delay);
|
||||
|
||||
return handle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse top-level animation properties
|
||||
*/
|
||||
static void lottie_parse_animation(lottie_player_handle_t handle,
|
||||
const cJSON *root) {
|
||||
cJSON *item;
|
||||
|
||||
// Width
|
||||
item = cJSON_GetObjectItem(root, "w");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->width = (uint16_t)item->valueint;
|
||||
}
|
||||
|
||||
// Height
|
||||
item = cJSON_GetObjectItem(root, "h");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->height = (uint16_t)item->valueint;
|
||||
}
|
||||
|
||||
// Framerate
|
||||
item = cJSON_GetObjectItem(root, "fr");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->framerate = (float)item->valuedouble;
|
||||
}
|
||||
|
||||
// In point (start frame)
|
||||
item = cJSON_GetObjectItem(root, "ip");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->in_point = (uint32_t)item->valueint;
|
||||
}
|
||||
|
||||
// Out point (end frame)
|
||||
item = cJSON_GetObjectItem(root, "op");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->out_point = (uint32_t)item->valueint;
|
||||
}
|
||||
|
||||
handle->total_frames = handle->out_point - handle->in_point;
|
||||
|
||||
// Parse layers
|
||||
item = cJSON_GetObjectItem(root, "layers");
|
||||
if (item && cJSON_IsArray(item)) {
|
||||
lottie_parse_layers(handle, item);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse layers array
|
||||
*/
|
||||
static void lottie_parse_layers(lottie_player_handle_t handle,
|
||||
const cJSON *layers) {
|
||||
int count = cJSON_GetArraySize(layers);
|
||||
if (count > MAX_LAYERS) {
|
||||
ESP_LOGW(TAG, "Truncating %d layers to %d", count, MAX_LAYERS);
|
||||
count = MAX_LAYERS;
|
||||
}
|
||||
|
||||
handle->layer_count = 0;
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *layer_json = cJSON_GetArrayItem(layers, i);
|
||||
if (layer_json) {
|
||||
lottie_layer_t *layer = &handle->layers[handle->layer_count];
|
||||
memset(layer, 0, sizeof(lottie_layer_t));
|
||||
layer->parent = -1;
|
||||
lottie_parse_layer(layer, layer_json);
|
||||
if (layer->valid) {
|
||||
handle->layer_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a single layer
|
||||
*/
|
||||
static void lottie_parse_layer(lottie_layer_t *layer, const cJSON *json) {
|
||||
cJSON *item;
|
||||
|
||||
// Layer index
|
||||
item = cJSON_GetObjectItem(json, "ind");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->index = item->valueint;
|
||||
}
|
||||
|
||||
// Layer type
|
||||
item = cJSON_GetObjectItem(json, "ty");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->type = item->valueint;
|
||||
}
|
||||
|
||||
// Parent index
|
||||
item = cJSON_GetObjectItem(json, "parent");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->parent = item->valueint;
|
||||
}
|
||||
|
||||
// Transform (ks)
|
||||
cJSON *ks = cJSON_GetObjectItem(json, "ks");
|
||||
if (ks) {
|
||||
// Position
|
||||
item = cJSON_GetObjectItem(ks, "p");
|
||||
if (item) {
|
||||
lottie_parse_property(&layer->position, item);
|
||||
}
|
||||
|
||||
// Anchor point
|
||||
item = cJSON_GetObjectItem(ks, "a");
|
||||
if (item) {
|
||||
lottie_parse_property(&layer->anchor, item);
|
||||
}
|
||||
}
|
||||
|
||||
// Shapes (for shape layers, type 4)
|
||||
if (layer->type == 4) {
|
||||
item = cJSON_GetObjectItem(json, "shapes");
|
||||
if (item && cJSON_IsArray(item)) {
|
||||
lottie_parse_shapes(layer, item);
|
||||
}
|
||||
}
|
||||
|
||||
layer->valid = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse shapes array for a layer
|
||||
* Uses two-pass approach: first find fill color, then parse shapes
|
||||
*/
|
||||
static void lottie_parse_shapes(lottie_layer_t *layer, const cJSON *shapes) {
|
||||
int count = cJSON_GetArraySize(shapes);
|
||||
layer->shape_count = 0;
|
||||
|
||||
// PASS 1: Find fill color (it may come before or after shapes in the array)
|
||||
lv_color_t fill_color = lv_color_white();
|
||||
uint8_t fill_opacity = 100;
|
||||
bool fill_found = false;
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *shape = cJSON_GetArrayItem(shapes, i);
|
||||
if (!shape)
|
||||
continue;
|
||||
|
||||
cJSON *ty = cJSON_GetObjectItem(shape, "ty");
|
||||
if (!ty || !cJSON_IsString(ty))
|
||||
continue;
|
||||
|
||||
const char *type = ty->valuestring;
|
||||
|
||||
// Fill color
|
||||
if (strcmp(type, "fl") == 0) {
|
||||
cJSON *c = cJSON_GetObjectItem(shape, "c");
|
||||
if (c) {
|
||||
cJSON *k = cJSON_GetObjectItem(c, "k");
|
||||
if (k && cJSON_IsArray(k) && cJSON_GetArraySize(k) >= 3) {
|
||||
float r = (float)cJSON_GetArrayItem(k, 0)->valuedouble;
|
||||
float g = (float)cJSON_GetArrayItem(k, 1)->valuedouble;
|
||||
float b = (float)cJSON_GetArrayItem(k, 2)->valuedouble;
|
||||
fill_color = lv_color_make((uint8_t)(r * 255), (uint8_t)(g * 255),
|
||||
(uint8_t)(b * 255));
|
||||
fill_found = true;
|
||||
ESP_LOGI(TAG, "Found fill: RGB(%.2f,%.2f,%.2f) -> (%d,%d,%d)", r, g,
|
||||
b, (int)(r * 255), (int)(g * 255), (int)(b * 255));
|
||||
}
|
||||
}
|
||||
cJSON *o = cJSON_GetObjectItem(shape, "o");
|
||||
if (o) {
|
||||
cJSON *k = cJSON_GetObjectItem(o, "k");
|
||||
if (k && cJSON_IsNumber(k)) {
|
||||
fill_opacity = (uint8_t)k->valueint;
|
||||
}
|
||||
}
|
||||
break; // Found fill, stop searching
|
||||
}
|
||||
}
|
||||
|
||||
if (!fill_found) {
|
||||
ESP_LOGW(TAG, "No fill found for layer, using default white");
|
||||
}
|
||||
|
||||
// PASS 2: Parse shapes and apply the found fill color
|
||||
for (int i = 0; i < count && layer->shape_count < MAX_SHAPES; i++) {
|
||||
cJSON *shape = cJSON_GetArrayItem(shapes, i);
|
||||
if (!shape)
|
||||
continue;
|
||||
|
||||
cJSON *ty = cJSON_GetObjectItem(shape, "ty");
|
||||
if (!ty || !cJSON_IsString(ty))
|
||||
continue;
|
||||
|
||||
const char *type = ty->valuestring;
|
||||
|
||||
// Rounded rectangle
|
||||
if (strcmp(type, "rc") == 0) {
|
||||
lottie_rounded_rect_t *rect = &layer->shapes[layer->shape_count];
|
||||
memset(rect, 0, sizeof(lottie_rounded_rect_t));
|
||||
|
||||
// Position
|
||||
cJSON *p = cJSON_GetObjectItem(shape, "p");
|
||||
if (p) {
|
||||
lottie_parse_property(&rect->position, p);
|
||||
}
|
||||
|
||||
// Size
|
||||
cJSON *s = cJSON_GetObjectItem(shape, "s");
|
||||
if (s) {
|
||||
lottie_parse_property(&rect->size, s);
|
||||
}
|
||||
|
||||
// Corner radius
|
||||
cJSON *r = cJSON_GetObjectItem(shape, "r");
|
||||
if (r) {
|
||||
lottie_parse_property(&rect->corner_radius, r);
|
||||
}
|
||||
|
||||
rect->fill_color = fill_color;
|
||||
rect->fill_opacity = fill_opacity;
|
||||
rect->valid = true;
|
||||
layer->shape_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an animated or static property
|
||||
*/
|
||||
static void lottie_parse_property(lottie_property_t *prop, const cJSON *json) {
|
||||
memset(prop, 0, sizeof(lottie_property_t));
|
||||
|
||||
cJSON *a = cJSON_GetObjectItem(json, "a");
|
||||
cJSON *k = cJSON_GetObjectItem(json, "k");
|
||||
|
||||
if (!k)
|
||||
return;
|
||||
|
||||
// Check if animated
|
||||
if (a && cJSON_IsNumber(a) && a->valueint == 1) {
|
||||
prop->animated = true;
|
||||
|
||||
// Parse keyframes
|
||||
if (cJSON_IsArray(k)) {
|
||||
int count = cJSON_GetArraySize(k);
|
||||
if (count > MAX_KEYFRAMES) {
|
||||
count = MAX_KEYFRAMES;
|
||||
}
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *kf = cJSON_GetArrayItem(k, i);
|
||||
if (!kf)
|
||||
continue;
|
||||
|
||||
lottie_keyframe_t *keyframe = &prop->keyframes[prop->keyframe_count];
|
||||
|
||||
// Time
|
||||
cJSON *t = cJSON_GetObjectItem(kf, "t");
|
||||
if (t && cJSON_IsNumber(t)) {
|
||||
keyframe->time = (float)t->valuedouble;
|
||||
}
|
||||
|
||||
// Hold
|
||||
cJSON *h = cJSON_GetObjectItem(kf, "h");
|
||||
if (h && cJSON_IsNumber(h)) {
|
||||
keyframe->hold = h->valueint == 1;
|
||||
}
|
||||
|
||||
// Start value (s)
|
||||
cJSON *s = cJSON_GetObjectItem(kf, "s");
|
||||
if (s && cJSON_IsArray(s)) {
|
||||
int vcount = cJSON_GetArraySize(s);
|
||||
for (int v = 0; v < vcount && v < 2; v++) {
|
||||
cJSON *val = cJSON_GetArrayItem(s, v);
|
||||
if (val && cJSON_IsNumber(val)) {
|
||||
keyframe->value[v] = (float)val->valuedouble;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// In tangent (i)
|
||||
cJSON *in_tan = cJSON_GetObjectItem(kf, "i");
|
||||
if (in_tan) {
|
||||
cJSON *x = cJSON_GetObjectItem(in_tan, "x");
|
||||
cJSON *y = cJSON_GetObjectItem(in_tan, "y");
|
||||
if (x && cJSON_IsArray(x) && cJSON_GetArraySize(x) > 0) {
|
||||
keyframe->in_tangent[0] =
|
||||
(float)cJSON_GetArrayItem(x, 0)->valuedouble;
|
||||
} else if (x && cJSON_IsNumber(x)) {
|
||||
keyframe->in_tangent[0] = (float)x->valuedouble;
|
||||
}
|
||||
if (y && cJSON_IsArray(y) && cJSON_GetArraySize(y) > 0) {
|
||||
keyframe->in_tangent[1] =
|
||||
(float)cJSON_GetArrayItem(y, 0)->valuedouble;
|
||||
} else if (y && cJSON_IsNumber(y)) {
|
||||
keyframe->in_tangent[1] = (float)y->valuedouble;
|
||||
}
|
||||
}
|
||||
|
||||
// Out tangent (o)
|
||||
cJSON *out_tan = cJSON_GetObjectItem(kf, "o");
|
||||
if (out_tan) {
|
||||
cJSON *x = cJSON_GetObjectItem(out_tan, "x");
|
||||
cJSON *y = cJSON_GetObjectItem(out_tan, "y");
|
||||
if (x && cJSON_IsArray(x) && cJSON_GetArraySize(x) > 0) {
|
||||
keyframe->out_tangent[0] =
|
||||
(float)cJSON_GetArrayItem(x, 0)->valuedouble;
|
||||
} else if (x && cJSON_IsNumber(x)) {
|
||||
keyframe->out_tangent[0] = (float)x->valuedouble;
|
||||
}
|
||||
if (y && cJSON_IsArray(y) && cJSON_GetArraySize(y) > 0) {
|
||||
keyframe->out_tangent[1] =
|
||||
(float)cJSON_GetArrayItem(y, 0)->valuedouble;
|
||||
} else if (y && cJSON_IsNumber(y)) {
|
||||
keyframe->out_tangent[1] = (float)y->valuedouble;
|
||||
}
|
||||
}
|
||||
|
||||
prop->keyframe_count++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Static value
|
||||
prop->animated = false;
|
||||
if (cJSON_IsArray(k)) {
|
||||
int count = cJSON_GetArraySize(k);
|
||||
for (int i = 0; i < count && i < 2; i++) {
|
||||
cJSON *val = cJSON_GetArrayItem(k, i);
|
||||
if (val && cJSON_IsNumber(val)) {
|
||||
prop->static_value[i] = (float)val->valuedouble;
|
||||
}
|
||||
}
|
||||
} else if (cJSON_IsNumber(k)) {
|
||||
prop->static_value[0] = (float)k->valuedouble;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cubic bezier interpolation
|
||||
*/
|
||||
static float lottie_bezier_interpolate(float t, float p0, float p1, float p2,
|
||||
float p3) {
|
||||
float u = 1.0f - t;
|
||||
float tt = t * t;
|
||||
float uu = u * u;
|
||||
float uuu = uu * u;
|
||||
float ttt = tt * t;
|
||||
|
||||
float result = uuu * p0;
|
||||
result += 3.0f * uu * t * p1;
|
||||
result += 3.0f * u * tt * p2;
|
||||
result += ttt * p3;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Interpolate a property value at a given frame
|
||||
*/
|
||||
static float lottie_interpolate_property(const lottie_property_t *prop,
|
||||
float frame, int index) {
|
||||
if (!prop->animated) {
|
||||
return prop->static_value[index];
|
||||
}
|
||||
|
||||
if (prop->keyframe_count == 0) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
// Find surrounding keyframes
|
||||
const lottie_keyframe_t *prev = NULL;
|
||||
const lottie_keyframe_t *next = NULL;
|
||||
|
||||
for (int i = 0; i < prop->keyframe_count; i++) {
|
||||
if (prop->keyframes[i].time <= frame) {
|
||||
prev = &prop->keyframes[i];
|
||||
}
|
||||
if (prop->keyframes[i].time >= frame && next == NULL) {
|
||||
next = &prop->keyframes[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Clamp to boundaries
|
||||
if (!prev) {
|
||||
return prop->keyframes[0].value[index];
|
||||
}
|
||||
if (!next || prev == next) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
// Check for hold keyframe
|
||||
if (prev->hold) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
// Calculate interpolation factor
|
||||
float duration = next->time - prev->time;
|
||||
if (duration <= 0) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
float t = (frame - prev->time) / duration;
|
||||
|
||||
// Apply bezier easing if tangents are present
|
||||
if (prev->out_tangent[0] != 0 || prev->out_tangent[1] != 0 ||
|
||||
next->in_tangent[0] != 0 || next->in_tangent[1] != 0) {
|
||||
// Approximate bezier curve for timing
|
||||
t = lottie_bezier_interpolate(t, 0.0f, prev->out_tangent[1],
|
||||
next->in_tangent[1], 1.0f);
|
||||
t = fmaxf(0.0f, fminf(1.0f, t));
|
||||
}
|
||||
|
||||
// Linear interpolation between values
|
||||
return prev->value[index] + t * (next->value[index] - prev->value[index]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get layer by index
|
||||
*/
|
||||
static lottie_layer_t *lottie_get_layer_by_index(lottie_player_handle_t handle,
|
||||
int index) {
|
||||
for (int i = 0; i < handle->layer_count; i++) {
|
||||
if (handle->layers[i].index == index) {
|
||||
return &handle->layers[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate cumulative transform for a layer (following parent chain)
|
||||
* In Lottie, transform = position - anchor for each layer in the hierarchy
|
||||
*/
|
||||
static void lottie_get_layer_transform(lottie_player_handle_t handle,
|
||||
lottie_layer_t *layer, float frame,
|
||||
float *offset_x, float *offset_y) {
|
||||
*offset_x = 0;
|
||||
*offset_y = 0;
|
||||
|
||||
lottie_layer_t *current = layer;
|
||||
while (current) {
|
||||
// Add this layer's position and subtract anchor
|
||||
float pos_x = lottie_interpolate_property(¤t->position, frame, 0);
|
||||
float pos_y = lottie_interpolate_property(¤t->position, frame, 1);
|
||||
float anc_x = lottie_interpolate_property(¤t->anchor, frame, 0);
|
||||
float anc_y = lottie_interpolate_property(¤t->anchor, frame, 1);
|
||||
|
||||
*offset_x += pos_x - anc_x;
|
||||
*offset_y += pos_y - anc_y;
|
||||
|
||||
// Follow parent chain
|
||||
if (current->parent >= 0) {
|
||||
current = lottie_get_layer_by_index(handle, current->parent);
|
||||
} else {
|
||||
current = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a rounded rectangle on the canvas
|
||||
*/
|
||||
static void lottie_draw_rounded_rect(lottie_player_handle_t handle,
|
||||
lv_coord_t x, lv_coord_t y, lv_coord_t w,
|
||||
lv_coord_t h, lv_coord_t radius,
|
||||
lv_color_t color) {
|
||||
lv_draw_rect_dsc_t rect_dsc;
|
||||
lv_draw_rect_dsc_init(&rect_dsc);
|
||||
rect_dsc.bg_color = color;
|
||||
rect_dsc.bg_opa = LV_OPA_COVER;
|
||||
rect_dsc.radius = radius;
|
||||
rect_dsc.border_width = 0;
|
||||
|
||||
lv_area_t area;
|
||||
area.x1 = x - w / 2;
|
||||
area.y1 = y - h / 2;
|
||||
area.x2 = area.x1 + w - 1;
|
||||
area.y2 = area.y1 + h - 1;
|
||||
|
||||
lv_canvas_draw_rect(handle->canvas, area.x1, area.y1, w, h, &rect_dsc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Render current frame to canvas
|
||||
*/
|
||||
static void lottie_render_frame(lottie_player_handle_t handle) {
|
||||
static bool first_frame_logged = false;
|
||||
|
||||
// Clear canvas to black
|
||||
lv_canvas_fill_bg(handle->canvas, lv_color_black(), LV_OPA_COVER);
|
||||
|
||||
float frame = handle->current_frame + handle->in_point;
|
||||
|
||||
// Render layers in reverse order (last layer = bottom)
|
||||
for (int i = handle->layer_count - 1; i >= 0; i--) {
|
||||
lottie_layer_t *layer = &handle->layers[i];
|
||||
if (!layer->valid || layer->type != 4) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Get cumulative transform
|
||||
float offset_x = 0, offset_y = 0;
|
||||
lottie_get_layer_transform(handle, layer, frame, &offset_x, &offset_y);
|
||||
|
||||
// Render shapes
|
||||
for (int s = 0; s < layer->shape_count; s++) {
|
||||
lottie_rounded_rect_t *rect = &layer->shapes[s];
|
||||
if (!rect->valid) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Get animated properties
|
||||
float px = lottie_interpolate_property(&rect->position, frame, 0);
|
||||
float py = lottie_interpolate_property(&rect->position, frame, 1);
|
||||
float w = lottie_interpolate_property(&rect->size, frame, 0);
|
||||
float h = lottie_interpolate_property(&rect->size, frame, 1);
|
||||
float r = lottie_interpolate_property(&rect->corner_radius, frame, 0);
|
||||
|
||||
// Apply layer offset
|
||||
px += offset_x;
|
||||
py += offset_y;
|
||||
|
||||
// Debug logging for first frame
|
||||
if (!first_frame_logged) {
|
||||
ESP_LOGI(TAG,
|
||||
"Layer %d shape %d: pos=(%.1f,%.1f) size=(%.1f,%.1f) "
|
||||
"radius=%.1f offset=(%.1f,%.1f)",
|
||||
layer->index, s, px - offset_x, py - offset_y, w, h, r,
|
||||
offset_x, offset_y);
|
||||
}
|
||||
|
||||
// Only draw if visible
|
||||
if (w > 0 && h > 0) {
|
||||
lottie_draw_rounded_rect(handle, (lv_coord_t)px, (lv_coord_t)py,
|
||||
(lv_coord_t)w, (lv_coord_t)h, (lv_coord_t)r,
|
||||
rect->fill_color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!first_frame_logged) {
|
||||
first_frame_logged = true;
|
||||
}
|
||||
|
||||
// Invalidate canvas to trigger redraw
|
||||
lv_obj_invalidate(handle->canvas);
|
||||
}
|
||||
|
||||
/**
|
||||
* Timer callback for animation playback
|
||||
* Uses time-based animation for accurate playback speed
|
||||
*/
|
||||
static void lottie_timer_cb(lv_timer_t *timer) {
|
||||
lottie_player_handle_t handle = (lottie_player_handle_t)timer->user_data;
|
||||
if (!handle || !handle->playing) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate current frame based on elapsed time
|
||||
int64_t now_us = esp_timer_get_time();
|
||||
int64_t elapsed_us = now_us - handle->start_time_us;
|
||||
float elapsed_sec = (float)elapsed_us / 1000000.0f;
|
||||
float frame = elapsed_sec * handle->framerate;
|
||||
|
||||
// Debug: log first few frames
|
||||
static int frame_log_count = 0;
|
||||
if (frame_log_count < 5) {
|
||||
ESP_LOGI(TAG, "Frame calc: elapsed=%.3fs, frame=%.1f/%lu", elapsed_sec,
|
||||
frame, (unsigned long)handle->total_frames);
|
||||
frame_log_count++;
|
||||
}
|
||||
|
||||
// Handle end of animation
|
||||
if (frame >= handle->total_frames) {
|
||||
if (handle->loop) {
|
||||
// Reset start time for smooth looping
|
||||
float cycles = frame / handle->total_frames;
|
||||
int full_cycles = (int)cycles;
|
||||
handle->start_time_us += (int64_t)(full_cycles * handle->total_frames /
|
||||
handle->framerate * 1000000.0f);
|
||||
frame = frame - (full_cycles * handle->total_frames);
|
||||
} else {
|
||||
// Animation complete - return to idle state
|
||||
ESP_LOGI(TAG, "Blink animation complete after %.3fs", elapsed_sec);
|
||||
frame_log_count = 0; // Reset for next blink
|
||||
|
||||
handle->playing = false;
|
||||
lv_timer_pause(handle->timer);
|
||||
handle->current_frame = handle->total_frames - 1; // Eyes open
|
||||
lottie_render_frame(handle);
|
||||
|
||||
// Schedule next blink if in natural mode
|
||||
if (handle->natural_blink_mode) {
|
||||
lottie_schedule_next_blink(handle);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
handle->current_frame = frame;
|
||||
|
||||
// Render the new frame
|
||||
lottie_render_frame(handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule next random blink
|
||||
*/
|
||||
static void lottie_schedule_next_blink(lottie_player_handle_t handle) {
|
||||
if (!handle || !handle->natural_blink_mode) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Random delay between 3-6 seconds for natural feel
|
||||
uint32_t delay_ms = 3000 + (esp_random() % 3000);
|
||||
|
||||
// Create new timer (old one was already deleted or is NULL)
|
||||
handle->blink_timer =
|
||||
lv_timer_create(lottie_blink_timer_cb, delay_ms, handle);
|
||||
lv_timer_set_repeat_count(handle->blink_timer, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Blink timer callback - triggers a blink animation
|
||||
*/
|
||||
static void lottie_blink_timer_cb(lv_timer_t *timer) {
|
||||
lottie_player_handle_t handle = (lottie_player_handle_t)timer->user_data;
|
||||
|
||||
// Mark timer as gone (one-shot timers auto-delete after callback returns)
|
||||
if (handle) {
|
||||
handle->blink_timer = NULL;
|
||||
}
|
||||
|
||||
if (!handle || !handle->natural_blink_mode) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Start blink animation from frame 0
|
||||
ESP_LOGI(TAG, "Blink triggered! Starting animation from frame 0");
|
||||
handle->current_frame = 0;
|
||||
lottie_play(handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* Start/resume playback
|
||||
*/
|
||||
void lottie_play(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
|
||||
// Set start time for time-based animation
|
||||
// Adjust for current frame position if resuming
|
||||
int64_t frame_offset_us =
|
||||
(int64_t)(handle->current_frame / handle->framerate * 1000000.0f);
|
||||
handle->start_time_us = esp_timer_get_time() - frame_offset_us;
|
||||
|
||||
handle->playing = true;
|
||||
lv_timer_resume(handle->timer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pause playback
|
||||
*/
|
||||
void lottie_pause(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->playing = false;
|
||||
lv_timer_pause(handle->timer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop playback and reset to first frame
|
||||
*/
|
||||
void lottie_stop(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->playing = false;
|
||||
handle->current_frame = 0;
|
||||
lv_timer_pause(handle->timer);
|
||||
lottie_render_frame(handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set loop mode
|
||||
*/
|
||||
void lottie_set_loop(lottie_player_handle_t handle, bool loop) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->loop = loop;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if playing
|
||||
*/
|
||||
bool lottie_is_playing(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return false;
|
||||
return handle->playing;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current frame number
|
||||
*/
|
||||
uint32_t lottie_get_current_frame(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return 0;
|
||||
return (uint32_t)handle->current_frame;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get total frame count
|
||||
*/
|
||||
uint32_t lottie_get_total_frames(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return 0;
|
||||
return handle->total_frames;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set current frame
|
||||
*/
|
||||
void lottie_set_frame(lottie_player_handle_t handle, uint32_t frame) {
|
||||
if (!handle)
|
||||
return;
|
||||
if (frame >= handle->total_frames) {
|
||||
frame = handle->total_frames - 1;
|
||||
}
|
||||
handle->current_frame = (float)frame;
|
||||
lottie_render_frame(handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy player and free resources
|
||||
*/
|
||||
void lottie_destroy(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
|
||||
// Stop timer
|
||||
if (handle->timer) {
|
||||
lv_timer_del(handle->timer);
|
||||
}
|
||||
|
||||
// Delete canvas
|
||||
if (handle->canvas) {
|
||||
lv_obj_del(handle->canvas);
|
||||
}
|
||||
|
||||
// Free canvas buffer
|
||||
if (handle->canvas_buf) {
|
||||
free(handle->canvas_buf);
|
||||
}
|
||||
|
||||
// Free player structure
|
||||
free(handle);
|
||||
|
||||
ESP_LOGI(TAG, "Lottie player destroyed");
|
||||
}
|
||||
125
main/main.c
Normal file
125
main/main.c
Normal file
@@ -0,0 +1,125 @@
|
||||
/**
|
||||
* @file main.c
|
||||
* @brief Application entry point for iroBot display system
|
||||
*
|
||||
* This is the main entry point for the iroBot display firmware.
|
||||
* It initializes all subsystems in the proper order and starts
|
||||
* the main application loop.
|
||||
*
|
||||
* Architecture Overview:
|
||||
* - drivers/: Hardware abstraction (display, touch)
|
||||
* - sensors/: Motion detection (shake detector)
|
||||
* - ui/: Visual components (splash screen, lottie player)
|
||||
* - emotion-engine/: Emotion management and animations
|
||||
*
|
||||
* Startup Sequence:
|
||||
* 1. Initialize display driver (I2C, SPI, LCD, LVGL)
|
||||
* 2. Initialize touch driver
|
||||
* 3. Initialize shake detector sensor
|
||||
* 4. Show splash screen
|
||||
* 5. Initialize and start emotion engine
|
||||
*/
|
||||
|
||||
#include "drivers/display_driver.h"
|
||||
#include "drivers/touch_driver.h"
|
||||
#include "emotion-engine/emotion_manager.h"
|
||||
#include "sensors/shake_detector.h"
|
||||
#include "ui/splash_screen.h"
|
||||
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
static const char *TAG = "main";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Shake Detection Task
|
||||
// Polls the accelerometer for shake events and triggers emotions.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void shakeTask(void *arg) {
|
||||
ESP_LOGI(TAG, "Shake detection task started");
|
||||
|
||||
while (1) {
|
||||
ShakeEvent event = shakeDetectorUpdate();
|
||||
|
||||
if (event != SHAKE_NONE) {
|
||||
// Map shake events to emotions
|
||||
EmotionType emotion = EMOTION_IDLE;
|
||||
switch (event) {
|
||||
case SHAKE_SURPRISED:
|
||||
emotion = EMOTION_SURPRISED;
|
||||
break;
|
||||
case SHAKE_SAD:
|
||||
emotion = EMOTION_SAD;
|
||||
break;
|
||||
case SHAKE_ANGRY:
|
||||
emotion = EMOTION_ANGRY;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (emotion != EMOTION_IDLE) {
|
||||
// Acquire LVGL lock before modifying emotions
|
||||
if (displayDriverLock(100)) {
|
||||
emotionManagerSetEmotion(emotion);
|
||||
displayDriverUnlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Poll at 20Hz for responsive shake detection
|
||||
vTaskDelay(pdMS_TO_TICKS(50));
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Application Entry Point
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void app_main(void) {
|
||||
ESP_LOGI(TAG, "Starting iroBot Display System");
|
||||
|
||||
// Initialize display subsystem (I2C, SPI, LCD, LVGL)
|
||||
if (!displayDriverInit()) {
|
||||
ESP_LOGE(TAG, "Display initialization failed");
|
||||
return;
|
||||
}
|
||||
|
||||
// Initialize touch controller
|
||||
if (!touchDriverInit()) {
|
||||
ESP_LOGW(TAG, "Touch initialization failed (continuing)");
|
||||
}
|
||||
|
||||
// Initialize shake detector
|
||||
if (!shakeDetectorInit()) {
|
||||
ESP_LOGW(TAG, "Shake detector initialization failed (continuing)");
|
||||
}
|
||||
|
||||
// Show splash screen (blocks for SPLASH_SCREEN_DURATION_MS)
|
||||
if (displayDriverLock(-1)) {
|
||||
ESP_LOGI(TAG, "Showing splash screen");
|
||||
splashScreenShow();
|
||||
displayDriverUnlock();
|
||||
}
|
||||
|
||||
// Initialize emotion engine
|
||||
if (!emotionManagerInit()) {
|
||||
ESP_LOGE(TAG, "Emotion manager initialization failed");
|
||||
return;
|
||||
}
|
||||
|
||||
// Start emotion engine (begins idle animation with natural blink)
|
||||
if (displayDriverLock(-1)) {
|
||||
ESP_LOGI(TAG, "Starting emotion engine");
|
||||
emotionManagerStart();
|
||||
displayDriverUnlock();
|
||||
}
|
||||
|
||||
// Start shake detection task
|
||||
xTaskCreate(shakeTask, "shake_task", 4096, NULL, 5, NULL);
|
||||
|
||||
ESP_LOGI(TAG, "iroBot Display System initialized successfully");
|
||||
}
|
||||
213
main/sensors/shake_detector.cpp
Normal file
213
main/sensors/shake_detector.cpp
Normal file
@@ -0,0 +1,213 @@
|
||||
/**
|
||||
* @file shake_detector.cpp
|
||||
* @brief Shake detection implementation using QMI8658 IMU sensor
|
||||
*
|
||||
* This module implements shake detection using the SensorLib QMI8658 driver.
|
||||
* It performs baseline calibration at startup and detects acceleration
|
||||
* deviations that indicate device movement or shaking.
|
||||
*/
|
||||
|
||||
#include "sensors/shake_detector.h"
|
||||
#include "SensorQMI8658.hpp"
|
||||
#include "config/hardware_config.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
|
||||
|
||||
static const char *TAG = "shake_detector";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Private State
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static SensorQMI8658 qmiSensor;
|
||||
|
||||
static uint32_t lastTriggerTime = 0;
|
||||
static float lastAccelX = 0, lastAccelY = 0, lastAccelZ = 0;
|
||||
static float baselineX = 0, baselineY = 0, baselineZ = 0;
|
||||
static bool baselineReady = false;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Helper Functions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static uint32_t getMillis() { return (uint32_t)(esp_timer_get_time() / 1000); }
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
extern "C" bool shakeDetectorInit(void) {
|
||||
ESP_LOGI(TAG, "Initializing shake detector (QMI8658)");
|
||||
|
||||
// Initialize sensor (I2C driver should already be installed by display
|
||||
// driver)
|
||||
if (!qmiSensor.begin(QMI8658_I2C_PORT, QMI8658_I2C_ADDR, QMI8658_PIN_SDA,
|
||||
QMI8658_PIN_SCL)) {
|
||||
ESP_LOGE(TAG, "Failed to initialize QMI8658");
|
||||
return false;
|
||||
}
|
||||
|
||||
uint8_t chipId = qmiSensor.getChipID();
|
||||
ESP_LOGI(TAG, "Sensor initialized. Chip ID: 0x%02x", chipId);
|
||||
|
||||
// Configure accelerometer (4G range, 1000Hz ODR)
|
||||
ESP_LOGI(TAG, "Configuring accelerometer...");
|
||||
int retAccel = qmiSensor.configAccelerometer(SensorQMI8658::ACC_RANGE_4G,
|
||||
SensorQMI8658::ACC_ODR_1000Hz,
|
||||
SensorQMI8658::LPF_MODE_0, true);
|
||||
if (retAccel != 0) {
|
||||
ESP_LOGE(TAG, "Accelerometer config failed: %d", retAccel);
|
||||
return false;
|
||||
}
|
||||
ESP_LOGI(TAG, "Accelerometer configured");
|
||||
|
||||
// Configure gyroscope (64DPS range, 896.8Hz ODR)
|
||||
ESP_LOGI(TAG, "Configuring gyroscope...");
|
||||
int retGyro = qmiSensor.configGyroscope(SensorQMI8658::GYR_RANGE_64DPS,
|
||||
SensorQMI8658::GYR_ODR_896_8Hz,
|
||||
SensorQMI8658::LPF_MODE_3, true);
|
||||
if (retGyro != 0) {
|
||||
ESP_LOGW(TAG, "Gyroscope config failed: %d (continuing)", retGyro);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "Gyroscope configured");
|
||||
}
|
||||
|
||||
// Enable sensors
|
||||
qmiSensor.enableGyroscope();
|
||||
qmiSensor.enableAccelerometer();
|
||||
ESP_LOGI(TAG, "Sensors enabled");
|
||||
|
||||
// Verify sensor is responding
|
||||
vTaskDelay(pdMS_TO_TICKS(50));
|
||||
if (qmiSensor.getDataReady()) {
|
||||
float testX, testY, testZ;
|
||||
if (qmiSensor.getAccelerometer(testX, testY, testZ)) {
|
||||
ESP_LOGI(TAG, "First reading: x=%.3f y=%.3f z=%.3f", testX, testY, testZ);
|
||||
}
|
||||
}
|
||||
|
||||
baselineReady = false;
|
||||
ESP_LOGI(TAG, "Shake detector ready. Calibrating baseline...");
|
||||
return true;
|
||||
}
|
||||
|
||||
extern "C" ShakeEvent shakeDetectorUpdate(void) {
|
||||
uint32_t now = getMillis();
|
||||
|
||||
if (!qmiSensor.getDataReady()) {
|
||||
static uint32_t lastNotReadyLog = 0;
|
||||
if (now - lastNotReadyLog > 3000) {
|
||||
ESP_LOGW(TAG, "Sensor data not ready");
|
||||
lastNotReadyLog = now;
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
float x, y, z;
|
||||
if (!qmiSensor.getAccelerometer(x, y, z)) {
|
||||
static uint32_t lastReadFailLog = 0;
|
||||
if (now - lastReadFailLog > 3000) {
|
||||
ESP_LOGW(TAG, "Failed to read accelerometer");
|
||||
lastReadFailLog = now;
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
lastAccelX = x;
|
||||
lastAccelY = y;
|
||||
lastAccelZ = z;
|
||||
|
||||
// Baseline calibration phase
|
||||
if (!baselineReady) {
|
||||
static uint32_t baselineCount = 0;
|
||||
static float baselineSumX = 0, baselineSumY = 0, baselineSumZ = 0;
|
||||
|
||||
baselineSumX += x;
|
||||
baselineSumY += y;
|
||||
baselineSumZ += z;
|
||||
baselineCount++;
|
||||
|
||||
ESP_LOGI(TAG, "[%2lu/%d] x=%+.3f y=%+.3f z=%+.3f",
|
||||
(unsigned long)baselineCount, SHAKE_BASELINE_SAMPLES, x, y, z);
|
||||
|
||||
if (baselineCount >= SHAKE_BASELINE_SAMPLES) {
|
||||
baselineX = baselineSumX / SHAKE_BASELINE_SAMPLES;
|
||||
baselineY = baselineSumY / SHAKE_BASELINE_SAMPLES;
|
||||
baselineZ = baselineSumZ / SHAKE_BASELINE_SAMPLES;
|
||||
baselineReady = true;
|
||||
|
||||
// Reset for potential future recalibration
|
||||
baselineCount = 0;
|
||||
baselineSumX = baselineSumY = baselineSumZ = 0;
|
||||
|
||||
float magnitude = sqrtf(baselineX * baselineX + baselineY * baselineY +
|
||||
baselineZ * baselineZ);
|
||||
ESP_LOGI(TAG, "Baseline calibrated: x=%+.3f y=%+.3f z=%+.3f (mag: %.3f)",
|
||||
baselineX, baselineY, baselineZ, magnitude);
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
// Calculate deviation from baseline
|
||||
float deltaX = x - baselineX;
|
||||
float deltaY = y - baselineY;
|
||||
float deltaZ = z - baselineZ;
|
||||
float deviation = sqrtf(deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ);
|
||||
|
||||
// Periodic logging for monitoring
|
||||
static uint32_t lastLogTime = 0;
|
||||
if (now - lastLogTime > 1000) {
|
||||
ESP_LOGI(TAG, "ACCEL: x=%+.3f y=%+.3f z=%+.3f | deviation=%.3f", x, y, z,
|
||||
deviation);
|
||||
lastLogTime = now;
|
||||
}
|
||||
|
||||
// Debounce check
|
||||
if (now - lastTriggerTime < SHAKE_DEBOUNCE_MS) {
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
// Shake detection
|
||||
if (deviation > SHAKE_ACCEL_THRESHOLD) {
|
||||
ESP_LOGI(TAG, "SHAKE DETECTED! deviation=%.3f > threshold=%.3f", deviation,
|
||||
SHAKE_ACCEL_THRESHOLD);
|
||||
|
||||
lastTriggerTime = now;
|
||||
|
||||
// Random emotion selection
|
||||
int r = rand() % 3;
|
||||
switch (r) {
|
||||
case 0:
|
||||
ESP_LOGI(TAG, "Emotion: SURPRISED");
|
||||
return SHAKE_SURPRISED;
|
||||
case 1:
|
||||
ESP_LOGI(TAG, "Emotion: SAD");
|
||||
return SHAKE_SAD;
|
||||
case 2:
|
||||
ESP_LOGI(TAG, "Emotion: ANGRY");
|
||||
return SHAKE_ANGRY;
|
||||
default:
|
||||
return SHAKE_SURPRISED;
|
||||
}
|
||||
}
|
||||
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
extern "C" bool shakeDetectorGetRawAccel(float *x, float *y, float *z) {
|
||||
if (!qmiSensor.getDataReady()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!qmiSensor.getAccelerometer(*x, *y, *z)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lastAccelX = *x;
|
||||
lastAccelY = *y;
|
||||
lastAccelZ = *z;
|
||||
return true;
|
||||
}
|
||||
86
main/sensors/shake_detector.h
Normal file
86
main/sensors/shake_detector.h
Normal file
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* @file shake_detector.h
|
||||
* @brief Shake detection interface using QMI8658 IMU sensor
|
||||
*
|
||||
* This module provides motion detection capabilities using the QMI8658
|
||||
* accelerometer/gyroscope. It detects shake gestures and can trigger
|
||||
* emotional responses in the display system.
|
||||
*/
|
||||
|
||||
#ifndef SHAKE_DETECTOR_H
|
||||
#define SHAKE_DETECTOR_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Acceleration deviation threshold to detect shake (in G)
|
||||
#define SHAKE_ACCEL_THRESHOLD 0.5f
|
||||
|
||||
// Debounce time between shake detections (milliseconds)
|
||||
#define SHAKE_DEBOUNCE_MS 2000
|
||||
|
||||
// Number of samples to average for baseline calibration
|
||||
#define SHAKE_BASELINE_SAMPLES 10
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Type Definitions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Shake event types with associated emotions
|
||||
*/
|
||||
typedef enum {
|
||||
SHAKE_NONE = 0, // No shake detected
|
||||
SHAKE_SURPRISED, // Quick shake - surprised emotion
|
||||
SHAKE_SAD, // Shake detected - sad emotion
|
||||
SHAKE_ANGRY // Shake detected - angry emotion
|
||||
} ShakeEvent;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Initialize the shake detector and IMU sensor
|
||||
*
|
||||
* Configures the QMI8658 accelerometer and gyroscope for shake detection.
|
||||
* The I2C bus must be initialized before calling this function.
|
||||
*
|
||||
* @return true on successful initialization, false on failure
|
||||
*/
|
||||
bool shakeDetectorInit(void);
|
||||
|
||||
/**
|
||||
* @brief Poll the shake detector for events
|
||||
*
|
||||
* Should be called periodically (e.g., every 50ms) to check for shakes.
|
||||
* Performs baseline calibration on first several calls.
|
||||
*
|
||||
* @return The detected shake event, or SHAKE_NONE if no shake
|
||||
*/
|
||||
ShakeEvent shakeDetectorUpdate(void);
|
||||
|
||||
/**
|
||||
* @brief Get raw accelerometer readings
|
||||
*
|
||||
* Retrieves the latest accelerometer values in G units.
|
||||
*
|
||||
* @param x Pointer to store X-axis acceleration
|
||||
* @param y Pointer to store Y-axis acceleration
|
||||
* @param z Pointer to store Z-axis acceleration
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool shakeDetectorGetRawAccel(float *x, float *y, float *z);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // SHAKE_DETECTOR_H
|
||||
@@ -1,213 +0,0 @@
|
||||
/**
|
||||
* @file shake_detector.cpp
|
||||
* @brief Shake detection implementation using SensorLib QMI8658
|
||||
*/
|
||||
|
||||
#include "shake_detector.h"
|
||||
#include "SensorQMI8658.hpp"
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include <math.h>
|
||||
|
||||
static const char *TAG = "shake_detector";
|
||||
|
||||
// Sensor instance
|
||||
static SensorQMI8658 qmi;
|
||||
|
||||
// I2C Pins (Matches example_qspi_with_ram.c)
|
||||
#define I2C_MASTER_SCL 14
|
||||
#define I2C_MASTER_SDA 15
|
||||
#define I2C_MASTER_NUM I2C_NUM_0
|
||||
#define QMI8658_ADDR 0x6B
|
||||
|
||||
// Shake detection thresholds
|
||||
#define SHAKE_ACCEL_THRESHOLD 0.5f // 0.5G deviation from baseline
|
||||
#define SHAKE_DEBOUNCE_MS 2000 // Debounce time between detections
|
||||
#define BASELINE_SAMPLES 10 // Number of samples to average for baseline
|
||||
|
||||
static uint32_t last_trigger_time = 0;
|
||||
// Store latest readings and baseline
|
||||
static float last_acc_x = 0, last_acc_y = 0, last_acc_z = 0;
|
||||
static float baseline_x = 0, baseline_y = 0, baseline_z = 0;
|
||||
static bool baseline_ready = false;
|
||||
|
||||
static uint32_t get_millis() { return (uint32_t)(esp_timer_get_time() / 1000); }
|
||||
|
||||
extern "C" bool shake_detector_init(void) {
|
||||
ESP_LOGI(TAG, "Initializing Shake Detector (QMI8658)");
|
||||
|
||||
// Initialize sensor (I2C driver already installed by main app)
|
||||
if (!qmi.begin(I2C_MASTER_NUM, QMI8658_ADDR, I2C_MASTER_SDA,
|
||||
I2C_MASTER_SCL)) {
|
||||
ESP_LOGE(TAG, "Failed to initialize QMI8658!");
|
||||
return false;
|
||||
}
|
||||
|
||||
uint8_t chip_id = qmi.getChipID();
|
||||
ESP_LOGI(TAG, "✓ Sensor initialized. Chip ID: 0x%02x", chip_id);
|
||||
|
||||
// Configure accelerometer (match vendor demo settings exactly)
|
||||
ESP_LOGI(TAG, "Configuring accelerometer (4G, 1000Hz, LPF_MODE_0)...");
|
||||
int ret_accel = qmi.configAccelerometer(SensorQMI8658::ACC_RANGE_4G,
|
||||
SensorQMI8658::ACC_ODR_1000Hz,
|
||||
SensorQMI8658::LPF_MODE_0, true);
|
||||
if (ret_accel != 0) {
|
||||
ESP_LOGE(TAG, "Failed to configure accelerometer: %d", ret_accel);
|
||||
return false;
|
||||
}
|
||||
ESP_LOGI(TAG, "✓ Accelerometer configured");
|
||||
|
||||
// Configure gyroscope (match vendor demo settings)
|
||||
ESP_LOGI(TAG, "Configuring gyroscope (64DPS, 896.8Hz, LPF_MODE_3)...");
|
||||
int ret_gyro = qmi.configGyroscope(SensorQMI8658::GYR_RANGE_64DPS,
|
||||
SensorQMI8658::GYR_ODR_896_8Hz,
|
||||
SensorQMI8658::LPF_MODE_3, true);
|
||||
if (ret_gyro != 0) {
|
||||
ESP_LOGW(TAG, "Gyroscope config failed: %d (will continue)", ret_gyro);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "✓ Gyroscope configured");
|
||||
}
|
||||
|
||||
// Enable sensors (gyro first, then accel - as in vendor demo)
|
||||
// Enable sensors (vendor demo doesn't check return values - they're buggy in SensorLib)
|
||||
// The SensorLib enable functions have backwards logic: they return bool but compare to DEV_WIRE_NONE (0)
|
||||
// This causes them to always appear to fail even when they succeed
|
||||
qmi.enableGyroscope();
|
||||
qmi.enableAccelerometer();
|
||||
|
||||
ESP_LOGI(TAG, "✓ Gyroscope enabled");
|
||||
ESP_LOGI(TAG, "✓ Accelerometer enabled");
|
||||
|
||||
// Test reading
|
||||
vTaskDelay(pdMS_TO_TICKS(50));
|
||||
if (qmi.getDataReady()) {
|
||||
float test_x, test_y, test_z;
|
||||
if (qmi.getAccelerometer(test_x, test_y, test_z)) {
|
||||
ESP_LOGI(TAG, "✓ First reading OK: x=%.3f y=%.3f z=%.3f", test_x, test_y, test_z);
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Data ready but read failed");
|
||||
}
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Sensor not ready for first read");
|
||||
}
|
||||
|
||||
baseline_ready = false;
|
||||
ESP_LOGI(TAG, "Shake Detector ready. Calibrating baseline...");
|
||||
return true;
|
||||
}
|
||||
|
||||
extern "C" shake_event_t shake_detector_update(void) {
|
||||
uint32_t now = get_millis();
|
||||
|
||||
if (!qmi.getDataReady()) {
|
||||
// Log occasionally if data is not ready, to see if sensor is stuck
|
||||
static uint32_t last_not_ready_time = 0;
|
||||
if (now - last_not_ready_time > 3000) {
|
||||
ESP_LOGW(TAG, "QMI8658 Data Not Ready - sensor may be unresponsive");
|
||||
last_not_ready_time = now;
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
float x, y, z;
|
||||
if (!qmi.getAccelerometer(x, y, z)) {
|
||||
static uint32_t last_read_fail_time = 0;
|
||||
if (now - last_read_fail_time > 3000) {
|
||||
ESP_LOGW(TAG, "Failed to read accelerometer data");
|
||||
last_read_fail_time = now;
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
last_acc_x = x;
|
||||
last_acc_y = y;
|
||||
last_acc_z = z;
|
||||
|
||||
// Baseline calibration: collect first N samples to establish device orientation
|
||||
if (!baseline_ready) {
|
||||
static uint32_t baseline_count = 0;
|
||||
static float baseline_sum_x = 0, baseline_sum_y = 0, baseline_sum_z = 0;
|
||||
|
||||
baseline_sum_x += x;
|
||||
baseline_sum_y += y;
|
||||
baseline_sum_z += z;
|
||||
baseline_count++;
|
||||
|
||||
ESP_LOGI(TAG, "[%2d/10] x=%+.3f y=%+.3f z=%+.3f",
|
||||
baseline_count, x, y, z);
|
||||
|
||||
if (baseline_count >= BASELINE_SAMPLES) {
|
||||
baseline_x = baseline_sum_x / BASELINE_SAMPLES;
|
||||
baseline_y = baseline_sum_y / BASELINE_SAMPLES;
|
||||
baseline_z = baseline_sum_z / BASELINE_SAMPLES;
|
||||
baseline_ready = true;
|
||||
baseline_count = 0;
|
||||
baseline_sum_x = baseline_sum_y = baseline_sum_z = 0;
|
||||
|
||||
ESP_LOGI(TAG, "✓ Baseline: x=%+.3f y=%+.3f z=%+.3f (magnitude: %.3f)",
|
||||
baseline_x, baseline_y, baseline_z,
|
||||
sqrtf(baseline_x*baseline_x + baseline_y*baseline_y + baseline_z*baseline_z));
|
||||
}
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
// Calculate deviation from baseline
|
||||
float delta_x = x - baseline_x;
|
||||
float delta_y = y - baseline_y;
|
||||
float delta_z = z - baseline_z;
|
||||
float deviation = sqrtf(delta_x * delta_x + delta_y * delta_y + delta_z * delta_z);
|
||||
|
||||
// Log raw values every 1 second for monitoring
|
||||
static uint32_t last_log_time = 0;
|
||||
if (now - last_log_time > 1000) {
|
||||
ESP_LOGI(TAG, "ACCEL: x=%+.3f y=%+.3f z=%+.3f | Δ=%+.3f",
|
||||
x, y, z, deviation);
|
||||
last_log_time = now;
|
||||
}
|
||||
|
||||
// Debounce: ignore if we just triggered a shake
|
||||
if (now - last_trigger_time < SHAKE_DEBOUNCE_MS) {
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
// Detect shake: acceleration deviation exceeds threshold
|
||||
if (deviation > SHAKE_ACCEL_THRESHOLD) {
|
||||
ESP_LOGI(TAG, "SHAKE! Δ=%.3f > Thr=%.3f | accel:[%+.2f,%+.2f,%+.2f]",
|
||||
deviation, SHAKE_ACCEL_THRESHOLD, x, y, z);
|
||||
|
||||
last_trigger_time = now;
|
||||
|
||||
// Pick a random emotion for the shake
|
||||
int r = rand() % 3;
|
||||
switch (r) {
|
||||
case 0:
|
||||
ESP_LOGI(TAG, "→ Emotion: SURPRISED");
|
||||
return SHAKE_SURPRISED;
|
||||
case 1:
|
||||
ESP_LOGI(TAG, "→ Emotion: SAD");
|
||||
return SHAKE_SAD;
|
||||
case 2:
|
||||
ESP_LOGI(TAG, "→ Emotion: ANGRY");
|
||||
return SHAKE_ANGRY;
|
||||
default:
|
||||
return SHAKE_SURPRISED;
|
||||
}
|
||||
}
|
||||
|
||||
return SHAKE_NONE;
|
||||
}
|
||||
|
||||
extern "C" bool shake_detector_get_raw_accel(float *x, float *y, float *z) {
|
||||
if (!qmi.getDataReady()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!qmi.getAccelerometer(*x, *y, *z)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
last_acc_x = *x;
|
||||
last_acc_y = *y;
|
||||
last_acc_z = *z;
|
||||
return true;
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
/**
|
||||
* @file shake_detector.h
|
||||
* @brief Shake detection using QMI8658 sensor
|
||||
*/
|
||||
|
||||
#ifndef SHAKE_DETECTOR_H
|
||||
#define SHAKE_DETECTOR_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Configuration types of shakes
|
||||
typedef enum {
|
||||
SHAKE_NONE = 0,
|
||||
SHAKE_SURPRISED,
|
||||
SHAKE_SAD,
|
||||
SHAKE_ANGRY,
|
||||
SHAKE_COUNT
|
||||
} shake_event_t;
|
||||
|
||||
/**
|
||||
* @brief Initialize the shake detector and QMI8658 sensor
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool shake_detector_init(void);
|
||||
|
||||
/**
|
||||
* @brief Check for shake events. Call this loop periodically.
|
||||
* @return Detected shake event, or SHAKE_NONE
|
||||
*/
|
||||
shake_event_t shake_detector_update(void);
|
||||
|
||||
/**
|
||||
* @brief Get the latest raw accelerometer reading
|
||||
* @param x Pointer to store X acceleration
|
||||
* @param y Pointer to store Y acceleration
|
||||
* @param z Pointer to store Z acceleration
|
||||
* @return true if data is available
|
||||
*/
|
||||
bool shake_detector_get_raw_accel(float *x, float *y, float *z);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // SHAKE_DETECTOR_H
|
||||
@@ -1,55 +0,0 @@
|
||||
/**
|
||||
* @file splash_screen.c
|
||||
* @brief Splash screen implementation for LVGL
|
||||
*/
|
||||
|
||||
#include "splash_screen.h"
|
||||
#include "lvgl.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
// Include the logo image data
|
||||
#include "../assets/logoIro.c"
|
||||
|
||||
static const char *TAG = "splash_screen";
|
||||
|
||||
// Splash screen display duration in milliseconds
|
||||
#define SPLASH_SCREEN_DURATION_MS 2000
|
||||
|
||||
void splash_screen_show(void)
|
||||
{
|
||||
ESP_LOGI(TAG, "Showing splash screen");
|
||||
|
||||
// Create a new screen for the splash
|
||||
lv_obj_t *splash_screen = lv_obj_create(NULL);
|
||||
// Set background color and opacity using LVGL v8 style API (selector LV_PART_MAIN|LV_STATE_DEFAULT)
|
||||
lv_obj_set_style_bg_color(splash_screen, lv_color_black(), LV_PART_MAIN | LV_STATE_DEFAULT);
|
||||
lv_obj_set_style_bg_opa(splash_screen, LV_OPA_COVER, LV_PART_MAIN | LV_STATE_DEFAULT);
|
||||
// Removed redundant old style call (LVGL v7 API)
|
||||
|
||||
// Create the logo image
|
||||
lv_obj_t *logo_img = lv_img_create(splash_screen);
|
||||
lv_img_set_src(logo_img, &logoIro);
|
||||
lv_obj_center(logo_img);
|
||||
|
||||
// Load the splash screen
|
||||
lv_scr_load(splash_screen);
|
||||
|
||||
// Force a refresh to ensure the splash screen is displayed
|
||||
lv_refr_now(NULL);
|
||||
|
||||
ESP_LOGI(TAG, "Splash screen displayed, waiting %d ms", SPLASH_SCREEN_DURATION_MS);
|
||||
|
||||
// Wait for the splash screen duration
|
||||
vTaskDelay(pdMS_TO_TICKS(SPLASH_SCREEN_DURATION_MS));
|
||||
|
||||
ESP_LOGI(TAG, "Splash screen done");
|
||||
|
||||
// Clean up: Delete the logo image object before returning
|
||||
// This ensures LVGL's internal state is clean before lv_demo_music() runs
|
||||
lv_obj_del(logo_img);
|
||||
|
||||
// Note: We delete the image but keep the screen active.
|
||||
// The next screen (lv_demo_music) will replace it automatically.
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
/**
|
||||
* @file splash_screen.h
|
||||
* @brief Splash screen module for displaying logo on startup
|
||||
*/
|
||||
|
||||
#ifndef SPLASH_SCREEN_H
|
||||
#define SPLASH_SCREEN_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Display the splash screen with the logo image
|
||||
*
|
||||
* Creates a full-screen LVGL display showing the logo image,
|
||||
* waits for the configured duration, then cleans up.
|
||||
* This function blocks for the splash screen duration.
|
||||
*
|
||||
* @note Must be called after LVGL is initialized and the display driver is registered
|
||||
*/
|
||||
void splash_screen_show(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* SPLASH_SCREEN_H */
|
||||
25
main/ui/assets/splash_screen/logo_iro.h
Normal file
25
main/ui/assets/splash_screen/logo_iro.h
Normal file
@@ -0,0 +1,25 @@
|
||||
/**
|
||||
* @file logo_iro.h
|
||||
* @brief Declaration of embedded logo image
|
||||
*
|
||||
* This header exposes the `logoIro` image descriptor for use in the UI.
|
||||
* The image data is defined in logo_iro.c.
|
||||
*/
|
||||
|
||||
#ifndef LOGO_IRO_H
|
||||
#define LOGO_IRO_H
|
||||
|
||||
#include "lvgl.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Defined in logo_iro.c
|
||||
extern const lv_img_dsc_t logoIro;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // LOGO_IRO_H
|
||||
836
main/ui/lottie_player.c
Normal file
836
main/ui/lottie_player.c
Normal file
@@ -0,0 +1,836 @@
|
||||
/**
|
||||
* @file lottie_player.c
|
||||
* @brief Lightweight Lottie animation player implementation for LVGL on ESP32
|
||||
*
|
||||
* This implementation provides a minimal Lottie JSON parser and renderer
|
||||
* optimized for simple shape-based animations. It supports:
|
||||
* - Rounded rectangle shapes
|
||||
* - Position, size, and corner radius animation
|
||||
* - Keyframe interpolation with bezier easing
|
||||
* - Solid color fills
|
||||
* - Natural blink mode with random intervals
|
||||
*
|
||||
* The parser extracts only the data needed for rendering, minimizing memory
|
||||
* usage on resource-constrained embedded systems.
|
||||
*/
|
||||
|
||||
#include "ui/lottie_player.h"
|
||||
#include "cJSON.h"
|
||||
#include "esp_heap_caps.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_random.h"
|
||||
#include "esp_timer.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static const char *TAG = "lottie_player";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Internal Type Definitions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Keyframe data structure for animated properties
|
||||
*/
|
||||
typedef struct {
|
||||
float time;
|
||||
float value[2];
|
||||
float inTangent[2];
|
||||
float outTangent[2];
|
||||
bool hold;
|
||||
} LottieKeyframe;
|
||||
|
||||
/**
|
||||
* Animated property that can have keyframes or static value
|
||||
*/
|
||||
typedef struct {
|
||||
bool animated;
|
||||
float staticValue[2];
|
||||
LottieKeyframe keyframes[LOTTIE_MAX_KEYFRAMES];
|
||||
uint8_t keyframeCount;
|
||||
} LottieProperty;
|
||||
|
||||
/**
|
||||
* Rounded rectangle shape definition
|
||||
*/
|
||||
typedef struct {
|
||||
LottieProperty position;
|
||||
LottieProperty size;
|
||||
LottieProperty cornerRadius;
|
||||
lv_color_t fillColor;
|
||||
uint8_t fillOpacity;
|
||||
bool valid;
|
||||
} LottieRoundedRect;
|
||||
|
||||
/**
|
||||
* Layer in the animation
|
||||
*/
|
||||
typedef struct {
|
||||
int index;
|
||||
int parent;
|
||||
int type;
|
||||
LottieProperty position;
|
||||
LottieProperty anchor;
|
||||
LottieRoundedRect shapes[LOTTIE_MAX_SHAPES];
|
||||
uint8_t shapeCount;
|
||||
bool valid;
|
||||
} LottieLayer;
|
||||
|
||||
/**
|
||||
* Main player state structure
|
||||
*/
|
||||
struct lottie_player_t {
|
||||
// Animation metadata
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
float framerate;
|
||||
uint32_t totalFrames;
|
||||
uint32_t inPoint;
|
||||
uint32_t outPoint;
|
||||
|
||||
// Layers
|
||||
LottieLayer layers[LOTTIE_MAX_LAYERS];
|
||||
uint8_t layerCount;
|
||||
|
||||
// Playback state
|
||||
float currentFrame;
|
||||
bool playing;
|
||||
bool loop;
|
||||
int64_t startTimeUs;
|
||||
|
||||
// Natural blink mode
|
||||
bool naturalBlinkMode;
|
||||
lv_timer_t *blinkTimer;
|
||||
|
||||
// LVGL objects
|
||||
lv_obj_t *canvas;
|
||||
lv_color_t *canvasBuffer;
|
||||
lv_timer_t *animTimer;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Forward Declarations
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void parseAnimation(lottie_player_handle_t handle, const cJSON *root);
|
||||
static void parseLayers(lottie_player_handle_t handle, const cJSON *layers);
|
||||
static void parseLayer(LottieLayer *layer, const cJSON *json);
|
||||
static void parseShapes(LottieLayer *layer, const cJSON *shapes);
|
||||
static void parseProperty(LottieProperty *prop, const cJSON *json);
|
||||
static float interpolateProperty(const LottieProperty *prop, float frame,
|
||||
int index);
|
||||
static void renderFrame(lottie_player_handle_t handle);
|
||||
static void animTimerCallback(lv_timer_t *timer);
|
||||
static void blinkTimerCallback(lv_timer_t *timer);
|
||||
static void scheduleNextBlink(lottie_player_handle_t handle);
|
||||
static float bezierInterpolate(float t, float p0, float p1, float p2, float p3);
|
||||
static LottieLayer *getLayerByIndex(lottie_player_handle_t handle, int index);
|
||||
static void getLayerTransform(lottie_player_handle_t handle, LottieLayer *layer,
|
||||
float frame, float *offsetX, float *offsetY);
|
||||
static void drawRoundedRect(lottie_player_handle_t handle, lv_coord_t x,
|
||||
lv_coord_t y, lv_coord_t w, lv_coord_t h,
|
||||
lv_coord_t radius, lv_color_t color);
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
lottie_player_handle_t lottieCreateFromData(lv_obj_t *parent,
|
||||
const char *jsonData) {
|
||||
if (!parent || !jsonData) {
|
||||
ESP_LOGE(TAG, "Invalid parameters");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Parse JSON
|
||||
cJSON *root = cJSON_Parse(jsonData);
|
||||
if (!root) {
|
||||
ESP_LOGE(TAG, "Failed to parse JSON: %s", cJSON_GetErrorPtr());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Allocate player structure
|
||||
lottie_player_handle_t handle = calloc(1, sizeof(struct lottie_player_t));
|
||||
if (!handle) {
|
||||
ESP_LOGE(TAG, "Failed to allocate player");
|
||||
cJSON_Delete(root);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Set defaults
|
||||
handle->playing = false;
|
||||
handle->loop = true;
|
||||
handle->currentFrame = 0;
|
||||
|
||||
// Parse animation data
|
||||
parseAnimation(handle, root);
|
||||
cJSON_Delete(root);
|
||||
|
||||
// Validate parsed data
|
||||
if (handle->width == 0 || handle->height == 0 || handle->totalFrames == 0) {
|
||||
ESP_LOGE(TAG, "Invalid animation data");
|
||||
free(handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Parsed animation: %dx%d, %lu frames at %.1f fps",
|
||||
handle->width, handle->height, (unsigned long)handle->totalFrames,
|
||||
handle->framerate);
|
||||
ESP_LOGI(TAG, "Loaded %d layers", handle->layerCount);
|
||||
|
||||
// Allocate canvas buffer (prefer SPIRAM for large buffers)
|
||||
size_t bufSize = handle->width * handle->height * sizeof(lv_color_t);
|
||||
handle->canvasBuffer =
|
||||
heap_caps_malloc(bufSize, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if (!handle->canvasBuffer) {
|
||||
handle->canvasBuffer = malloc(bufSize);
|
||||
}
|
||||
if (!handle->canvasBuffer) {
|
||||
ESP_LOGE(TAG, "Failed to allocate canvas buffer (%u bytes)",
|
||||
(unsigned)bufSize);
|
||||
free(handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Create LVGL canvas
|
||||
handle->canvas = lv_canvas_create(parent);
|
||||
lv_canvas_set_buffer(handle->canvas, handle->canvasBuffer, handle->width,
|
||||
handle->height, LV_IMG_CF_TRUE_COLOR);
|
||||
lv_obj_center(handle->canvas);
|
||||
|
||||
// Speed up animation for snappier blinks (2x speed)
|
||||
handle->framerate *= 2.0f;
|
||||
|
||||
// Create animation timer
|
||||
handle->animTimer =
|
||||
lv_timer_create(animTimerCallback, LOTTIE_TIMER_PERIOD_MS, handle);
|
||||
lv_timer_pause(handle->animTimer);
|
||||
|
||||
// Enable natural blink mode by default
|
||||
handle->naturalBlinkMode = true;
|
||||
handle->loop = false;
|
||||
|
||||
// Show idle state (last frame = eyes open)
|
||||
handle->currentFrame = handle->totalFrames - 1;
|
||||
renderFrame(handle);
|
||||
|
||||
// Schedule first blink with random delay
|
||||
uint32_t initialDelay =
|
||||
LOTTIE_BLINK_MIN_MS +
|
||||
(esp_random() % (LOTTIE_BLINK_MAX_MS - LOTTIE_BLINK_MIN_MS));
|
||||
handle->blinkTimer =
|
||||
lv_timer_create(blinkTimerCallback, initialDelay, handle);
|
||||
lv_timer_set_repeat_count(handle->blinkTimer, 1);
|
||||
|
||||
ESP_LOGI(TAG, "Natural blink mode enabled, first blink in %lu ms",
|
||||
(unsigned long)initialDelay);
|
||||
|
||||
return handle;
|
||||
}
|
||||
|
||||
void lottiePlay(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
|
||||
int64_t frameOffsetUs =
|
||||
(int64_t)(handle->currentFrame / handle->framerate * 1000000.0f);
|
||||
handle->startTimeUs = esp_timer_get_time() - frameOffsetUs;
|
||||
handle->playing = true;
|
||||
lv_timer_resume(handle->animTimer);
|
||||
}
|
||||
|
||||
void lottiePause(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->playing = false;
|
||||
lv_timer_pause(handle->animTimer);
|
||||
}
|
||||
|
||||
void lottieStop(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->playing = false;
|
||||
handle->currentFrame = 0;
|
||||
lv_timer_pause(handle->animTimer);
|
||||
renderFrame(handle);
|
||||
}
|
||||
|
||||
void lottieSetLoop(lottie_player_handle_t handle, bool loop) {
|
||||
if (!handle)
|
||||
return;
|
||||
handle->loop = loop;
|
||||
}
|
||||
|
||||
bool lottieIsPlaying(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return false;
|
||||
return handle->playing;
|
||||
}
|
||||
|
||||
uint32_t lottieGetCurrentFrame(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return 0;
|
||||
return (uint32_t)handle->currentFrame;
|
||||
}
|
||||
|
||||
uint32_t lottieGetTotalFrames(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return 0;
|
||||
return handle->totalFrames;
|
||||
}
|
||||
|
||||
void lottieSetFrame(lottie_player_handle_t handle, uint32_t frame) {
|
||||
if (!handle)
|
||||
return;
|
||||
if (frame >= handle->totalFrames) {
|
||||
frame = handle->totalFrames - 1;
|
||||
}
|
||||
handle->currentFrame = (float)frame;
|
||||
renderFrame(handle);
|
||||
}
|
||||
|
||||
void lottieDestroy(lottie_player_handle_t handle) {
|
||||
if (!handle)
|
||||
return;
|
||||
|
||||
if (handle->animTimer) {
|
||||
lv_timer_del(handle->animTimer);
|
||||
}
|
||||
if (handle->blinkTimer) {
|
||||
lv_timer_del(handle->blinkTimer);
|
||||
}
|
||||
if (handle->canvas) {
|
||||
lv_obj_del(handle->canvas);
|
||||
}
|
||||
if (handle->canvasBuffer) {
|
||||
free(handle->canvasBuffer);
|
||||
}
|
||||
free(handle);
|
||||
|
||||
ESP_LOGI(TAG, "Lottie player destroyed");
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// JSON Parsing Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void parseAnimation(lottie_player_handle_t handle, const cJSON *root) {
|
||||
cJSON *item;
|
||||
|
||||
item = cJSON_GetObjectItem(root, "w");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->width = (uint16_t)item->valueint;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(root, "h");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->height = (uint16_t)item->valueint;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(root, "fr");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->framerate = (float)item->valuedouble;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(root, "ip");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->inPoint = (uint32_t)item->valueint;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(root, "op");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
handle->outPoint = (uint32_t)item->valueint;
|
||||
}
|
||||
|
||||
handle->totalFrames = handle->outPoint - handle->inPoint;
|
||||
|
||||
item = cJSON_GetObjectItem(root, "layers");
|
||||
if (item && cJSON_IsArray(item)) {
|
||||
parseLayers(handle, item);
|
||||
}
|
||||
}
|
||||
|
||||
static void parseLayers(lottie_player_handle_t handle, const cJSON *layers) {
|
||||
int count = cJSON_GetArraySize(layers);
|
||||
if (count > LOTTIE_MAX_LAYERS) {
|
||||
ESP_LOGW(TAG, "Truncating %d layers to %d", count, LOTTIE_MAX_LAYERS);
|
||||
count = LOTTIE_MAX_LAYERS;
|
||||
}
|
||||
|
||||
handle->layerCount = 0;
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *layerJson = cJSON_GetArrayItem(layers, i);
|
||||
if (layerJson) {
|
||||
LottieLayer *layer = &handle->layers[handle->layerCount];
|
||||
memset(layer, 0, sizeof(LottieLayer));
|
||||
layer->parent = -1;
|
||||
parseLayer(layer, layerJson);
|
||||
if (layer->valid) {
|
||||
handle->layerCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void parseLayer(LottieLayer *layer, const cJSON *json) {
|
||||
cJSON *item;
|
||||
|
||||
item = cJSON_GetObjectItem(json, "ind");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->index = item->valueint;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(json, "ty");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->type = item->valueint;
|
||||
}
|
||||
|
||||
item = cJSON_GetObjectItem(json, "parent");
|
||||
if (item && cJSON_IsNumber(item)) {
|
||||
layer->parent = item->valueint;
|
||||
}
|
||||
|
||||
cJSON *ks = cJSON_GetObjectItem(json, "ks");
|
||||
if (ks) {
|
||||
item = cJSON_GetObjectItem(ks, "p");
|
||||
if (item) {
|
||||
parseProperty(&layer->position, item);
|
||||
}
|
||||
item = cJSON_GetObjectItem(ks, "a");
|
||||
if (item) {
|
||||
parseProperty(&layer->anchor, item);
|
||||
}
|
||||
}
|
||||
|
||||
if (layer->type == 4) {
|
||||
item = cJSON_GetObjectItem(json, "shapes");
|
||||
if (item && cJSON_IsArray(item)) {
|
||||
parseShapes(layer, item);
|
||||
}
|
||||
}
|
||||
|
||||
layer->valid = true;
|
||||
}
|
||||
|
||||
static void parseShapes(LottieLayer *layer, const cJSON *shapes) {
|
||||
int count = cJSON_GetArraySize(shapes);
|
||||
layer->shapeCount = 0;
|
||||
|
||||
// Pass 1: Find fill color
|
||||
lv_color_t fillColor = lv_color_white();
|
||||
uint8_t fillOpacity = 100;
|
||||
bool fillFound = false;
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *shape = cJSON_GetArrayItem(shapes, i);
|
||||
if (!shape)
|
||||
continue;
|
||||
|
||||
cJSON *ty = cJSON_GetObjectItem(shape, "ty");
|
||||
if (!ty || !cJSON_IsString(ty))
|
||||
continue;
|
||||
|
||||
const char *type = ty->valuestring;
|
||||
|
||||
if (strcmp(type, "fl") == 0) {
|
||||
cJSON *c = cJSON_GetObjectItem(shape, "c");
|
||||
if (c) {
|
||||
cJSON *k = cJSON_GetObjectItem(c, "k");
|
||||
if (k && cJSON_IsArray(k) && cJSON_GetArraySize(k) >= 3) {
|
||||
float r = (float)cJSON_GetArrayItem(k, 0)->valuedouble;
|
||||
float g = (float)cJSON_GetArrayItem(k, 1)->valuedouble;
|
||||
float b = (float)cJSON_GetArrayItem(k, 2)->valuedouble;
|
||||
fillColor = lv_color_make((uint8_t)(r * 255), (uint8_t)(g * 255),
|
||||
(uint8_t)(b * 255));
|
||||
fillFound = true;
|
||||
}
|
||||
}
|
||||
cJSON *o = cJSON_GetObjectItem(shape, "o");
|
||||
if (o) {
|
||||
cJSON *k = cJSON_GetObjectItem(o, "k");
|
||||
if (k && cJSON_IsNumber(k)) {
|
||||
fillOpacity = (uint8_t)k->valueint;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!fillFound) {
|
||||
ESP_LOGW(TAG, "No fill found for layer, using default white");
|
||||
}
|
||||
|
||||
// Pass 2: Parse shapes
|
||||
for (int i = 0; i < count && layer->shapeCount < LOTTIE_MAX_SHAPES; i++) {
|
||||
cJSON *shape = cJSON_GetArrayItem(shapes, i);
|
||||
if (!shape)
|
||||
continue;
|
||||
|
||||
cJSON *ty = cJSON_GetObjectItem(shape, "ty");
|
||||
if (!ty || !cJSON_IsString(ty))
|
||||
continue;
|
||||
|
||||
const char *type = ty->valuestring;
|
||||
|
||||
if (strcmp(type, "rc") == 0) {
|
||||
LottieRoundedRect *rect = &layer->shapes[layer->shapeCount];
|
||||
memset(rect, 0, sizeof(LottieRoundedRect));
|
||||
|
||||
cJSON *p = cJSON_GetObjectItem(shape, "p");
|
||||
if (p)
|
||||
parseProperty(&rect->position, p);
|
||||
|
||||
cJSON *s = cJSON_GetObjectItem(shape, "s");
|
||||
if (s)
|
||||
parseProperty(&rect->size, s);
|
||||
|
||||
cJSON *r = cJSON_GetObjectItem(shape, "r");
|
||||
if (r)
|
||||
parseProperty(&rect->cornerRadius, r);
|
||||
|
||||
rect->fillColor = fillColor;
|
||||
rect->fillOpacity = fillOpacity;
|
||||
rect->valid = true;
|
||||
layer->shapeCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void parseProperty(LottieProperty *prop, const cJSON *json) {
|
||||
memset(prop, 0, sizeof(LottieProperty));
|
||||
|
||||
cJSON *a = cJSON_GetObjectItem(json, "a");
|
||||
cJSON *k = cJSON_GetObjectItem(json, "k");
|
||||
|
||||
if (!k)
|
||||
return;
|
||||
|
||||
if (a && cJSON_IsNumber(a) && a->valueint == 1) {
|
||||
prop->animated = true;
|
||||
|
||||
if (cJSON_IsArray(k)) {
|
||||
int count = cJSON_GetArraySize(k);
|
||||
if (count > LOTTIE_MAX_KEYFRAMES) {
|
||||
count = LOTTIE_MAX_KEYFRAMES;
|
||||
}
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
cJSON *kf = cJSON_GetArrayItem(k, i);
|
||||
if (!kf)
|
||||
continue;
|
||||
|
||||
LottieKeyframe *keyframe = &prop->keyframes[prop->keyframeCount];
|
||||
|
||||
cJSON *t = cJSON_GetObjectItem(kf, "t");
|
||||
if (t && cJSON_IsNumber(t)) {
|
||||
keyframe->time = (float)t->valuedouble;
|
||||
}
|
||||
|
||||
cJSON *h = cJSON_GetObjectItem(kf, "h");
|
||||
if (h && cJSON_IsNumber(h)) {
|
||||
keyframe->hold = h->valueint == 1;
|
||||
}
|
||||
|
||||
cJSON *s = cJSON_GetObjectItem(kf, "s");
|
||||
if (s && cJSON_IsArray(s)) {
|
||||
int vcount = cJSON_GetArraySize(s);
|
||||
for (int v = 0; v < vcount && v < 2; v++) {
|
||||
cJSON *val = cJSON_GetArrayItem(s, v);
|
||||
if (val && cJSON_IsNumber(val)) {
|
||||
keyframe->value[v] = (float)val->valuedouble;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cJSON *inTan = cJSON_GetObjectItem(kf, "i");
|
||||
if (inTan) {
|
||||
cJSON *x = cJSON_GetObjectItem(inTan, "x");
|
||||
cJSON *y = cJSON_GetObjectItem(inTan, "y");
|
||||
if (x && cJSON_IsArray(x) && cJSON_GetArraySize(x) > 0) {
|
||||
keyframe->inTangent[0] =
|
||||
(float)cJSON_GetArrayItem(x, 0)->valuedouble;
|
||||
} else if (x && cJSON_IsNumber(x)) {
|
||||
keyframe->inTangent[0] = (float)x->valuedouble;
|
||||
}
|
||||
if (y && cJSON_IsArray(y) && cJSON_GetArraySize(y) > 0) {
|
||||
keyframe->inTangent[1] =
|
||||
(float)cJSON_GetArrayItem(y, 0)->valuedouble;
|
||||
} else if (y && cJSON_IsNumber(y)) {
|
||||
keyframe->inTangent[1] = (float)y->valuedouble;
|
||||
}
|
||||
}
|
||||
|
||||
cJSON *outTan = cJSON_GetObjectItem(kf, "o");
|
||||
if (outTan) {
|
||||
cJSON *x = cJSON_GetObjectItem(outTan, "x");
|
||||
cJSON *y = cJSON_GetObjectItem(outTan, "y");
|
||||
if (x && cJSON_IsArray(x) && cJSON_GetArraySize(x) > 0) {
|
||||
keyframe->outTangent[0] =
|
||||
(float)cJSON_GetArrayItem(x, 0)->valuedouble;
|
||||
} else if (x && cJSON_IsNumber(x)) {
|
||||
keyframe->outTangent[0] = (float)x->valuedouble;
|
||||
}
|
||||
if (y && cJSON_IsArray(y) && cJSON_GetArraySize(y) > 0) {
|
||||
keyframe->outTangent[1] =
|
||||
(float)cJSON_GetArrayItem(y, 0)->valuedouble;
|
||||
} else if (y && cJSON_IsNumber(y)) {
|
||||
keyframe->outTangent[1] = (float)y->valuedouble;
|
||||
}
|
||||
}
|
||||
|
||||
prop->keyframeCount++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
prop->animated = false;
|
||||
if (cJSON_IsArray(k)) {
|
||||
int count = cJSON_GetArraySize(k);
|
||||
for (int i = 0; i < count && i < 2; i++) {
|
||||
cJSON *val = cJSON_GetArrayItem(k, i);
|
||||
if (val && cJSON_IsNumber(val)) {
|
||||
prop->staticValue[i] = (float)val->valuedouble;
|
||||
}
|
||||
}
|
||||
} else if (cJSON_IsNumber(k)) {
|
||||
prop->staticValue[0] = (float)k->valuedouble;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Animation Interpolation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static float bezierInterpolate(float t, float p0, float p1, float p2,
|
||||
float p3) {
|
||||
float u = 1.0f - t;
|
||||
float tt = t * t;
|
||||
float uu = u * u;
|
||||
float uuu = uu * u;
|
||||
float ttt = tt * t;
|
||||
|
||||
float result = uuu * p0;
|
||||
result += 3.0f * uu * t * p1;
|
||||
result += 3.0f * u * tt * p2;
|
||||
result += ttt * p3;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static float interpolateProperty(const LottieProperty *prop, float frame,
|
||||
int index) {
|
||||
if (!prop->animated) {
|
||||
return prop->staticValue[index];
|
||||
}
|
||||
|
||||
if (prop->keyframeCount == 0) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
const LottieKeyframe *prev = NULL;
|
||||
const LottieKeyframe *next = NULL;
|
||||
|
||||
for (int i = 0; i < prop->keyframeCount; i++) {
|
||||
if (prop->keyframes[i].time <= frame) {
|
||||
prev = &prop->keyframes[i];
|
||||
}
|
||||
if (prop->keyframes[i].time >= frame && next == NULL) {
|
||||
next = &prop->keyframes[i];
|
||||
}
|
||||
}
|
||||
|
||||
if (!prev) {
|
||||
return prop->keyframes[0].value[index];
|
||||
}
|
||||
if (!next || prev == next) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
if (prev->hold) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
float duration = next->time - prev->time;
|
||||
if (duration <= 0) {
|
||||
return prev->value[index];
|
||||
}
|
||||
|
||||
float t = (frame - prev->time) / duration;
|
||||
|
||||
if (prev->outTangent[0] != 0 || prev->outTangent[1] != 0 ||
|
||||
next->inTangent[0] != 0 || next->inTangent[1] != 0) {
|
||||
t = bezierInterpolate(t, 0.0f, prev->outTangent[1], next->inTangent[1],
|
||||
1.0f);
|
||||
t = fmaxf(0.0f, fminf(1.0f, t));
|
||||
}
|
||||
|
||||
return prev->value[index] + t * (next->value[index] - prev->value[index]);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Rendering
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static LottieLayer *getLayerByIndex(lottie_player_handle_t handle, int index) {
|
||||
for (int i = 0; i < handle->layerCount; i++) {
|
||||
if (handle->layers[i].index == index) {
|
||||
return &handle->layers[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void getLayerTransform(lottie_player_handle_t handle, LottieLayer *layer,
|
||||
float frame, float *offsetX, float *offsetY) {
|
||||
*offsetX = 0;
|
||||
*offsetY = 0;
|
||||
|
||||
LottieLayer *current = layer;
|
||||
while (current) {
|
||||
float posX = interpolateProperty(¤t->position, frame, 0);
|
||||
float posY = interpolateProperty(¤t->position, frame, 1);
|
||||
float ancX = interpolateProperty(¤t->anchor, frame, 0);
|
||||
float ancY = interpolateProperty(¤t->anchor, frame, 1);
|
||||
|
||||
*offsetX += posX - ancX;
|
||||
*offsetY += posY - ancY;
|
||||
|
||||
if (current->parent >= 0) {
|
||||
current = getLayerByIndex(handle, current->parent);
|
||||
} else {
|
||||
current = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void drawRoundedRect(lottie_player_handle_t handle, lv_coord_t x,
|
||||
lv_coord_t y, lv_coord_t w, lv_coord_t h,
|
||||
lv_coord_t radius, lv_color_t color) {
|
||||
lv_draw_rect_dsc_t rectDsc;
|
||||
lv_draw_rect_dsc_init(&rectDsc);
|
||||
rectDsc.bg_color = color;
|
||||
rectDsc.bg_opa = LV_OPA_COVER;
|
||||
rectDsc.radius = radius;
|
||||
rectDsc.border_width = 0;
|
||||
|
||||
lv_canvas_draw_rect(handle->canvas, x - w / 2, y - h / 2, w, h, &rectDsc);
|
||||
}
|
||||
|
||||
static void renderFrame(lottie_player_handle_t handle) {
|
||||
static bool firstFrameLogged = false;
|
||||
|
||||
lv_canvas_fill_bg(handle->canvas, lv_color_black(), LV_OPA_COVER);
|
||||
|
||||
float frame = handle->currentFrame + handle->inPoint;
|
||||
|
||||
// Render layers in reverse order (last layer = bottom)
|
||||
for (int i = handle->layerCount - 1; i >= 0; i--) {
|
||||
LottieLayer *layer = &handle->layers[i];
|
||||
if (!layer->valid || layer->type != 4) {
|
||||
continue;
|
||||
}
|
||||
|
||||
float offsetX = 0, offsetY = 0;
|
||||
getLayerTransform(handle, layer, frame, &offsetX, &offsetY);
|
||||
|
||||
for (int s = 0; s < layer->shapeCount; s++) {
|
||||
LottieRoundedRect *rect = &layer->shapes[s];
|
||||
if (!rect->valid)
|
||||
continue;
|
||||
|
||||
float px = interpolateProperty(&rect->position, frame, 0);
|
||||
float py = interpolateProperty(&rect->position, frame, 1);
|
||||
float w = interpolateProperty(&rect->size, frame, 0);
|
||||
float h = interpolateProperty(&rect->size, frame, 1);
|
||||
float r = interpolateProperty(&rect->cornerRadius, frame, 0);
|
||||
|
||||
px += offsetX;
|
||||
py += offsetY;
|
||||
|
||||
if (!firstFrameLogged) {
|
||||
ESP_LOGI(TAG, "Layer %d shape %d: pos=(%.1f,%.1f) size=(%.1f,%.1f)",
|
||||
layer->index, s, px, py, w, h);
|
||||
}
|
||||
|
||||
if (w > 0 && h > 0) {
|
||||
drawRoundedRect(handle, (lv_coord_t)px, (lv_coord_t)py, (lv_coord_t)w,
|
||||
(lv_coord_t)h, (lv_coord_t)r, rect->fillColor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!firstFrameLogged) {
|
||||
firstFrameLogged = true;
|
||||
}
|
||||
|
||||
lv_obj_invalidate(handle->canvas);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Timer Callbacks
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static void animTimerCallback(lv_timer_t *timer) {
|
||||
lottie_player_handle_t handle = (lottie_player_handle_t)timer->user_data;
|
||||
if (!handle || !handle->playing) {
|
||||
return;
|
||||
}
|
||||
|
||||
int64_t nowUs = esp_timer_get_time();
|
||||
int64_t elapsedUs = nowUs - handle->startTimeUs;
|
||||
float elapsedSec = (float)elapsedUs / 1000000.0f;
|
||||
float frame = elapsedSec * handle->framerate;
|
||||
|
||||
if (frame >= handle->totalFrames) {
|
||||
if (handle->loop) {
|
||||
float cycles = frame / handle->totalFrames;
|
||||
int fullCycles = (int)cycles;
|
||||
handle->startTimeUs += (int64_t)(fullCycles * handle->totalFrames /
|
||||
handle->framerate * 1000000.0f);
|
||||
frame = frame - (fullCycles * handle->totalFrames);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "Blink animation complete");
|
||||
handle->playing = false;
|
||||
lv_timer_pause(handle->animTimer);
|
||||
handle->currentFrame = handle->totalFrames - 1;
|
||||
renderFrame(handle);
|
||||
|
||||
if (handle->naturalBlinkMode) {
|
||||
scheduleNextBlink(handle);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
handle->currentFrame = frame;
|
||||
renderFrame(handle);
|
||||
}
|
||||
|
||||
static void scheduleNextBlink(lottie_player_handle_t handle) {
|
||||
if (!handle || !handle->naturalBlinkMode) {
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t delayMs =
|
||||
LOTTIE_BLINK_MIN_MS +
|
||||
(esp_random() % (LOTTIE_BLINK_MAX_MS - LOTTIE_BLINK_MIN_MS));
|
||||
handle->blinkTimer = lv_timer_create(blinkTimerCallback, delayMs, handle);
|
||||
lv_timer_set_repeat_count(handle->blinkTimer, 1);
|
||||
}
|
||||
|
||||
static void blinkTimerCallback(lv_timer_t *timer) {
|
||||
lottie_player_handle_t handle = (lottie_player_handle_t)timer->user_data;
|
||||
|
||||
if (handle) {
|
||||
handle->blinkTimer = NULL;
|
||||
}
|
||||
|
||||
if (!handle || !handle->naturalBlinkMode) {
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Blink triggered");
|
||||
handle->currentFrame = 0;
|
||||
lottiePlay(handle);
|
||||
}
|
||||
@@ -2,9 +2,9 @@
|
||||
* @file lottie_player.h
|
||||
* @brief Lightweight Lottie animation player for LVGL on ESP32
|
||||
*
|
||||
* This module provides a minimal Lottie JSON animation player optimized for
|
||||
* embedded systems. It supports basic shape types (rounded rectangles) with
|
||||
* keyframe animation and bezier curve interpolation.
|
||||
* This module provides a minimal Lottie JSON animation player optimized
|
||||
* for embedded systems. It supports basic shape types (rounded rectangles)
|
||||
* with keyframe animation and bezier curve interpolation.
|
||||
*
|
||||
* Designed for simple animations like blinking eyes on resource-constrained
|
||||
* devices. Does not support the full Lottie specification.
|
||||
@@ -22,42 +22,70 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Configuration (Modify as needed for different animations)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Maximum number of layers supported in animation
|
||||
#define LOTTIE_MAX_LAYERS 8
|
||||
|
||||
// Maximum shapes per layer
|
||||
#define LOTTIE_MAX_SHAPES 4
|
||||
|
||||
// Maximum keyframes per animated property
|
||||
#define LOTTIE_MAX_KEYFRAMES 24
|
||||
|
||||
// Animation timer update interval (milliseconds)
|
||||
#define LOTTIE_TIMER_PERIOD_MS 16
|
||||
|
||||
// Random blink interval range (milliseconds)
|
||||
#define LOTTIE_BLINK_MIN_MS 2000
|
||||
#define LOTTIE_BLINK_MAX_MS 6000
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Type Definitions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Forward declaration of internal structure
|
||||
typedef struct lottie_player_t *lottie_player_handle_t;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Create a Lottie animation player from embedded JSON data
|
||||
*
|
||||
* Parses the Lottie JSON and creates an LVGL object hierarchy for rendering.
|
||||
* The animation starts in paused state - call lottie_play() to begin playback.
|
||||
* Parses the Lottie JSON and creates an LVGL canvas for rendering.
|
||||
* The animation auto-starts with random blink interval enabled.
|
||||
*
|
||||
* @param parent Parent LVGL object to attach the animation to
|
||||
* @param json_data Pointer to null-terminated JSON string in flash
|
||||
* @param jsonData Pointer to null-terminated JSON string
|
||||
* @return Handle to the player instance, or NULL on failure
|
||||
*/
|
||||
lottie_player_handle_t lottie_create_from_data(lv_obj_t *parent,
|
||||
const char *json_data);
|
||||
lottie_player_handle_t lottieCreateFromData(lv_obj_t *parent,
|
||||
const char *jsonData);
|
||||
|
||||
/**
|
||||
* @brief Start or resume animation playback
|
||||
*
|
||||
* @param handle Handle to the Lottie player instance
|
||||
*/
|
||||
void lottie_play(lottie_player_handle_t handle);
|
||||
void lottiePlay(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Pause animation playback
|
||||
*
|
||||
* @param handle Handle to the Lottie player instance
|
||||
*/
|
||||
void lottie_pause(lottie_player_handle_t handle);
|
||||
void lottiePause(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Stop animation and reset to first frame
|
||||
*
|
||||
* @param handle Handle to the Lottie player instance
|
||||
*/
|
||||
void lottie_stop(lottie_player_handle_t handle);
|
||||
void lottieStop(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Set whether the animation should loop
|
||||
@@ -65,7 +93,7 @@ void lottie_stop(lottie_player_handle_t handle);
|
||||
* @param handle Handle to the Lottie player instance
|
||||
* @param loop True to enable looping, false for single playthrough
|
||||
*/
|
||||
void lottie_set_loop(lottie_player_handle_t handle, bool loop);
|
||||
void lottieSetLoop(lottie_player_handle_t handle, bool loop);
|
||||
|
||||
/**
|
||||
* @brief Check if animation is currently playing
|
||||
@@ -73,7 +101,7 @@ void lottie_set_loop(lottie_player_handle_t handle, bool loop);
|
||||
* @param handle Handle to the Lottie player instance
|
||||
* @return True if playing, false if paused or stopped
|
||||
*/
|
||||
bool lottie_is_playing(lottie_player_handle_t handle);
|
||||
bool lottieIsPlaying(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Get the current frame number
|
||||
@@ -81,7 +109,7 @@ bool lottie_is_playing(lottie_player_handle_t handle);
|
||||
* @param handle Handle to the Lottie player instance
|
||||
* @return Current frame number (0-indexed)
|
||||
*/
|
||||
uint32_t lottie_get_current_frame(lottie_player_handle_t handle);
|
||||
uint32_t lottieGetCurrentFrame(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Get total number of frames in the animation
|
||||
@@ -89,7 +117,7 @@ uint32_t lottie_get_current_frame(lottie_player_handle_t handle);
|
||||
* @param handle Handle to the Lottie player instance
|
||||
* @return Total frame count
|
||||
*/
|
||||
uint32_t lottie_get_total_frames(lottie_player_handle_t handle);
|
||||
uint32_t lottieGetTotalFrames(lottie_player_handle_t handle);
|
||||
|
||||
/**
|
||||
* @brief Set the current frame manually
|
||||
@@ -97,17 +125,17 @@ uint32_t lottie_get_total_frames(lottie_player_handle_t handle);
|
||||
* @param handle Handle to the Lottie player instance
|
||||
* @param frame Frame number to seek to (clamped to valid range)
|
||||
*/
|
||||
void lottie_set_frame(lottie_player_handle_t handle, uint32_t frame);
|
||||
void lottieSetFrame(lottie_player_handle_t handle, uint32_t frame);
|
||||
|
||||
/**
|
||||
* @brief Destroy the Lottie player and free all resources
|
||||
*
|
||||
* @param handle Handle to the Lottie player instance
|
||||
*/
|
||||
void lottie_destroy(lottie_player_handle_t handle);
|
||||
void lottieDestroy(lottie_player_handle_t handle);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* LOTTIE_PLAYER_H */
|
||||
#endif // LOTTIE_PLAYER_H
|
||||
54
main/ui/splash_screen.c
Normal file
54
main/ui/splash_screen.c
Normal file
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* @file splash_screen.c
|
||||
* @brief Splash screen implementation for LVGL
|
||||
*
|
||||
* Displays the company logo on startup for a configured duration.
|
||||
* The implementation creates a temporary screen, renders the logo,
|
||||
* and then cleans up to prepare for the main application UI.
|
||||
*/
|
||||
|
||||
#include "ui/splash_screen.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "lvgl.h"
|
||||
|
||||
#include "ui/assets/splash_screen/logo_iro.h"
|
||||
|
||||
static const char *TAG = "splash_screen";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public API Implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void splashScreenShow(void) {
|
||||
ESP_LOGI(TAG, "Showing splash screen");
|
||||
|
||||
// Create a temporary screen for the splash
|
||||
lv_obj_t *splashScreen = lv_obj_create(NULL);
|
||||
lv_obj_set_style_bg_color(splashScreen, lv_color_black(),
|
||||
LV_PART_MAIN | LV_STATE_DEFAULT);
|
||||
lv_obj_set_style_bg_opa(splashScreen, LV_OPA_COVER,
|
||||
LV_PART_MAIN | LV_STATE_DEFAULT);
|
||||
|
||||
// Create and center the logo image
|
||||
lv_obj_t *logoImage = lv_img_create(splashScreen);
|
||||
lv_img_set_src(logoImage, &logoIro);
|
||||
lv_obj_center(logoImage);
|
||||
|
||||
// Activate the splash screen
|
||||
lv_scr_load(splashScreen);
|
||||
lv_refr_now(NULL);
|
||||
|
||||
ESP_LOGI(TAG, "Splash screen displayed, waiting %d ms",
|
||||
SPLASH_SCREEN_DURATION_MS);
|
||||
|
||||
// Block for the display duration
|
||||
vTaskDelay(pdMS_TO_TICKS(SPLASH_SCREEN_DURATION_MS));
|
||||
|
||||
// Clean up the logo image before transitioning
|
||||
lv_obj_del(logoImage);
|
||||
|
||||
ESP_LOGI(TAG, "Splash screen complete");
|
||||
}
|
||||
46
main/ui/splash_screen.h
Normal file
46
main/ui/splash_screen.h
Normal file
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* @file splash_screen.h
|
||||
* @brief Splash screen display interface
|
||||
*
|
||||
* This module displays a startup splash screen with the company logo.
|
||||
* The splash screen blocks for a configurable duration before returning.
|
||||
*/
|
||||
|
||||
#ifndef SPLASH_SCREEN_H
|
||||
#define SPLASH_SCREEN_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Configuration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Duration the splash screen is displayed (milliseconds)
|
||||
#define SPLASH_SCREEN_DURATION_MS 2000
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Public Interface
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Display the splash screen
|
||||
*
|
||||
* Creates a temporary LVGL screen, displays the logo image centered,
|
||||
* waits for the configured duration, then cleans up.
|
||||
* This function blocks for SPLASH_SCREEN_DURATION_MS.
|
||||
*
|
||||
* @note The display driver must be initialized before calling this.
|
||||
* @note This function should be called with the LVGL mutex held.
|
||||
*/
|
||||
void splashScreenShow(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // SPLASH_SCREEN_H
|
||||
Reference in New Issue
Block a user