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:
2026-01-24 15:21:50 +05:30
parent 2c731c72e3
commit 8aeaed8a15
69 changed files with 2650 additions and 10338 deletions

View File

@@ -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

View File

@@ -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

View File

@@ -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;
}

View File

@@ -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

View File

@@ -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();
}

View File

@@ -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

View File

@@ -1,8 +0,0 @@
#ifndef COMMON_h
#define COMMON_h
#include <U8g2lib.h>
extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
#endif

View File

@@ -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();
}

View File

@@ -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

View File

@@ -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);
}

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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;
}

View File

@@ -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

View File

@@ -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;
}

View File

@@ -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

View File

@@ -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;;
}

View File

@@ -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

View File

@@ -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();
}

View File

@@ -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

View File

@@ -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;
}
}

View File

@@ -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

View File

@@ -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

View File

@@ -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);
}

View File

@@ -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

View File

@@ -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>.

View File

@@ -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);
}
}

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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();
}

View File

@@ -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
)

View File

@@ -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;
}

View File

@@ -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 */

View File

@@ -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");
}

View File

@@ -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 */

View 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

View 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

View 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;
}

View 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
View 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

View 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

View File

@@ -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

View 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);
}
}

View 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

View 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;
}

View 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

View File

@@ -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);
}
}
}

View File

@@ -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(&current->position, frame, 0);
float pos_y = lottie_interpolate_property(&current->position, frame, 1);
float anc_x = lottie_interpolate_property(&current->anchor, frame, 0);
float anc_y = lottie_interpolate_property(&current->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
View 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");
}

View 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;
}

View 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

View File

@@ -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;
}

View File

@@ -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

View File

@@ -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.
}

View File

@@ -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 */

View 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
View 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(&current->position, frame, 0);
float posY = interpolateProperty(&current->position, frame, 1);
float ancX = interpolateProperty(&current->anchor, frame, 0);
float ancY = interpolateProperty(&current->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);
}

View File

@@ -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
View 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
View 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