#include <Arduino.h>
#include <FastLED.h>
#include "ProtogenHead.h"
#include "AnimationBook.h"
#include "config.h"
#include "loop.h"

ProtogenHead head;
// AnimationBook *book;
uint8_t loop_count = 0;
void setup()
{
  Serial.begin(115200); // Any baud rate should work

  Serial.println("=======Proto-proto-proto-gen!=======");

  // initialize FastLED
  Serial.println("LED initialization...");

  FastLED.addLeds<NEOPIXEL, DATA_PIN_LEFT>(head.left_leds, LEDS_PER_DISPLAY);
  FastLED.setBrightness(BRIGHTNESS);

  Serial.println("LED initializaion done.");

  // initialize animations
  Serial.println("AnimationBook initialization...");

  // book = makeAnimationBook();
  Serial.println("AnimationBook initialization done.");
  Serial.println("=======Setup finshed=======");
}

void loop()
{
  Serial.print("=======Loop ");
  Serial.print(loop_count);
  Serial.println("=======");

  head.left_leds[loop_count].b = 255;
  // FastLED.delay(10
  delay(10);
  Serial.println("After loop");
  
  head.left_leds[loop_count].b = 0;
  
  loop_count = (loop_count + 1) % 256;

  // animation_frame(&head, *book);
}


sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

ArduinoJson
FastLED
Dictionary

libraries.txt


// SW INITIALIZATION
#define ANIMATION_BOOK_JSON_SIZE 2000 // set number equal to length of the JSON string or more

// HW INITIALIZAITON
#define LED_DISPLAY_WIDTH 16
#define LED_DISPLAY_HEIGHT 16
#define LEDS_PER_DISPLAY LED_DISPLAY_WIDTH *LED_DISPLAY_HEIGHT
#define DATA_PIN_LEFT 4
#define DATA_PIN_RIGHT 14
#define BRIGHTNESS 2

// BEHAVIOUR INITIALIZATION
#define STARTUP_ANIMATION "idle"


config.h

#include <Arduino.h>
#include <ArduinoJson.h>
#include "config.h"

String animationBookJson = R"(
{
    "idle": {
        "mode": "mirror",
        "mirror": {
            "open": "00000000000000000000FF00000000000000FFFFFFFFF000000000000000000000000000000000000000FFFFFFFFFF000000FF00F00F000000000FF000FF0000000000FFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
            "semi": "00000000000000000000FF00000000000000FFFFFFFFF000000000000000000000000000000000000000FFFFFFFFFF000000FF00F0FF000000000FFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
            "closed": "000000000000000000000F00000000000000FFFFFFFFF000000000000000000000000000000000000000FFFFFFFFFF0000000FFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
        },
        "frame-sequence": [
            {
                "frame": "open",
                "duration": 1000
            },
            {
                "frame": "semi",
                "duration": 50
            },
            {
                "frame": "closed",
                "duration": 250
            },
            {
                "frame": "semi",
                "duration": 50
            }
        ]
    }
}
)";

typedef struct Expression
{
    String name;
    const char *data;

} Expression;

typedef struct Frame
{
    String expression_name;
    uint16_t duration;
} Frame;

typedef struct AnimationBook
{
    Expression *expressions;
    int8_t expression_count;
    Frame *frame_sequence;
    int8_t frame_count;
} AnimationBook;

AnimationBook *makeAnimationBook()
{
    StaticJsonDocument<ANIMATION_BOOK_JSON_SIZE> parsedBook;
    Serial.println("Deserializing JSON...");

    DeserializationError error = deserializeJson(parsedBook, animationBookJson);

    if (error)
    {
        Serial.print(F("deserializeJson() failed: "));
        Serial.println(error.f_str());
        return nullptr;
    }

    JsonObject idle = parsedBook["idle"];
    String mode = parsedBook["mode"];

    JsonObject expressionsJson = idle["mirror"];
    JsonArray frameSequenceJson = idle["frame-sequence"];

    int8_t numExpressions = expressionsJson.size();
    int8_t numFrames = frameSequenceJson.size();
    Expression *expressions = new Expression[numExpressions];
    Frame *frameSequence = new Frame[numFrames];
    Serial.println("Looking up expressions...");

    int8_t expression_i = 0;
    for (auto expr : expressionsJson)
    {

        String name = expr.key().c_str();
        String data = expr.value().as<String>();
        Expression expression = {name, data.c_str()};
        expressions[expression_i] = expression;
        Serial.print("Expression ");
        Serial.print(expression_i, DEC);
        Serial.print(" named ");
        Serial.print(name);
        Serial.print(" contains ");
        Serial.println(data);

        expression_i++;
    }

    int8_t frame_i = 0;
    for (auto frameObj : frameSequenceJson)
    {
        const char *frameName = frameObj["frame"];
        uint16_t duration = frameObj["duration"];
        // String durationStr = String(durationChars);
        // int8_t duration = durationStr.toInt();

        Serial.print("Frame ");
        Serial.print(frame_i, DEC);
        Serial.print(" named ");
        Serial.print(frameName);
        Serial.print(" for ");
        Serial.println(duration, DEC);

        Frame frame = {frameName, duration};
        frameSequence[frame_i] = frame;

        frame_i++;
    }

    AnimationBook *book = new AnimationBook;
    book->expressions = expressions;
    book->expression_count = numExpressions;
    book->frame_sequence = frameSequence;
    book->frame_count = numFrames;

    return book;
}

AnimationBook.h

#include <Arduino.h>
#include "config.h"

uint8_t hexxCharToByte(char c)
{
    if (c >= '0' && c <= '9')
    {
        return (c - '0') * 16;
    }
    if (c >= 'A' && c <= 'F')
    {
        return (c - 'A' + 10) * 16;
    }
    return 0;
}

uint8_t getColorMonochromeHex(const char *data, int x, int y)
{
    return hexxCharToByte(data[x * 16 + y]);
}


draw.h

#include <FastLED.h>
#include "ProtogenHead.h"
#include "draw.h"

int8_t current_frame = 0;
int8_t debug_current_index = 0;

void animation_frame(ProtogenHead *head, AnimationBook book)
{
    uint16_t duration = book.frame_sequence[current_frame].duration;
    Serial.print("Frame ");
    Serial.print(current_frame, DEC);
    Serial.print(" of ");
    Serial.print(book.frame_count);
    Serial.print(" for ");
    Serial.println(duration);

    Expression currentExpression;
    for (int8_t i = 0; i < book.expression_count; i++)
    {
        head->left_leds[0].r = 0;

        if (book.expressions[i].name.equals(book.frame_sequence[current_frame].expression_name))
        {
            currentExpression = book.expressions[i];
            head->left_leds[0].r = 255;

            Serial.print("Expression ");
            Serial.println(currentExpression.name);
        }
    }

    for (int8_t x = 1; x < LED_DISPLAY_HEIGHT - 1; x++)
    {
        for (int8_t y = 1; y < LED_DISPLAY_WIDTH - 1; y++)
        {
            uint8_t value = getColorMonochromeHex(currentExpression.data, x, y);
            uint8_t index = XY(x, y);
            Serial.print("Setting postion [");
            Serial.print(x);
            Serial.print(", ");
            Serial.print(y);
            Serial.print("] (index ");
            Serial.print(index);
            Serial.print(") to ");
            Serial.println(value);
            head->left_leds[index].b = value;
        }
    }

    Serial.print("Starting delay for ");
    Serial.print(duration);
    Serial.print("... ");
    FastLED.show();
    Serial.println("Done!");

    current_frame += 1;
    current_frame %= book.frame_count;
}

loop.h

#ifndef PROTOGENHEAD_H
#define PROTOGENHEAD_H

#include "config.h"
#include <FastLED.h>

typedef struct ProtogenHead
{
    CRGB left_leds[LEDS_PER_DISPLAY];
    CRGB right_leds[LEDS_PER_DISPLAY];
} ProtogenHead;

uint8_t XY(uint8_t x, uint8_t y)
{
    // any out of bounds address maps to the first hidden pixel
    if ((x >= LED_DISPLAY_WIDTH) || (y >= LED_DISPLAY_HEIGHT))
    {
        return 0;
    }

    const uint8_t XYTable[] = {
        0, 31, 32, 63, 64, 95, 96, 127, 128, 159, 160, 191, 192, 223, 224, 255,
        1, 30, 33, 62, 65, 94, 97, 126, 129, 158, 161, 190, 193, 222, 225, 254,
        2, 29, 34, 61, 66, 93, 98, 125, 130, 157, 162, 189, 194, 221, 226, 253,
        3, 28, 35, 60, 67, 92, 99, 124, 131, 156, 163, 188, 195, 220, 227, 252,
        4, 27, 36, 59, 68, 91, 100, 123, 132, 155, 164, 187, 196, 219, 228, 251,
        5, 26, 37, 58, 69, 90, 101, 122, 133, 154, 165, 186, 197, 218, 229, 250,
        6, 25, 38, 57, 70, 89, 102, 121, 134, 153, 166, 185, 198, 217, 230, 249,
        7, 24, 39, 56, 71, 88, 103, 120, 135, 152, 167, 184, 199, 216, 231, 248,
        8, 23, 40, 55, 72, 87, 104, 119, 136, 151, 168, 183, 200, 215, 232, 247,
        9, 22, 41, 54, 73, 86, 105, 118, 137, 150, 169, 182, 201, 214, 233, 246,
        10, 21, 42, 53, 74, 85, 106, 117, 138, 149, 170, 181, 202, 213, 234, 245,
        11, 20, 43, 52, 75, 84, 107, 116, 139, 148, 171, 180, 203, 212, 235, 244,
        12, 19, 44, 51, 76, 83, 108, 115, 140, 147, 172, 179, 204, 211, 236, 243,
        13, 18, 45, 50, 77, 82, 109, 114, 141, 146, 173, 178, 205, 210, 237, 242,
        14, 17, 46, 49, 78, 81, 110, 113, 142, 145, 174, 177, 206, 209, 238, 241,
        15, 16, 47, 48, 79, 80, 111, 112, 143, 144, 175, 176, 207, 208, 239, 240};

    uint8_t i = (y * LED_DISPLAY_WIDTH) + x;
    uint8_t j = XYTable[i];

    return j;
}

#endif