Каким был бы лучший способ динамического "изменения" экземпляров относительно динамической памяти?

arduino-mega memory-usage memory

Поскольку я очень привык к объектно-ориентированному программированию, я хотел бы использовать это в своем дизайне. Мое приложение будет иметь 4 светодиодные полосы, и каждая светодиодная полоса будет иметь "шаблон", работающий на нем. Для этого мне нравится создавать базовый класс и для каждого шаблона производный класс. Таким образом, это означает, что у меня есть 4 экземпляра к шаблону. Однако шаблон может изменяться динамически (на основе музыкального MIDI-входа). Каждый паттерн имеет от 10 до 16 параметров.

Я знаю, что динамическое выделение памяти в основном не является хорошей идеей в Arduino. Я использую Мега, который имеет 8 КБ. Я нашел несколько "решений", но ни в одном из них я не уверен. Первый-это не решение, а то, как я должен это сделать, когда у меня есть "много" SRAM (и упрощено):

class Pattern
{
   public:
      virtual void Process();
}

class PatternA: Pattern
{
   public:
      void Process();

      // В примере я использую только 2 из 10-16 параметров
      uint8_t SetColor(uint8_t colorIndex);
      uint8_t SetSpeed(uint8_t speed);

   private:
      uint8_t _colorIndex;
      uint8_t _speed;
}

// В этом примере я использую только 2 из 24 шаблонов
class PatternB: Pattern
(like PatternA but with its own implementation)

class LedStrip
{
   public:
       void SetPattern(Pattern* pattern);

   private:
       Pattern* _pattern;
}

Другие производные классы могут иметь другие (именованные) параметры.

При смене экземпляров я получал бы что-то вроде этого:

LedStrip::SetPattern(Pattern* pattern)
{
    delete _pattern;
    _pattern = pattern;
}

pattern* pattern = new PatternA(...);
ledStrip1.SetPattern(pattern);

Однако, поскольку новый паттерн может использовать больше памяти, чем удаленный паттерн, возникнет пробел в памяти. Так что это не подходит для Arduino для использования я предполагаю.

Решения:

1. Создайте все возможные шаблоны заранее.

Предположим, я бы реализовал 24 шаблона и создал любую возможную комбинацию, у меня было бы 4 (светодиодные полосы) * 24 (шаблоны) * 13,5 (среднее количество параметров) = 1296 байт. Это кажется немного чересчур, так как только 4 из них "активны".

class LedStrip
{
   public: 
      enum EPattern {A, B}

      void SetPattern(EPattern pattern);

   private:
      PatternA* _patternA;
      PatternB* _patternB;

      Pattern* _pattern;
}

Чтобы изменить шаблон:

void LedStrip::SetPattern(EPatternpattern)
{
case EPatternA: _pattern = _patternA; break;
case EPatternB: _pattern = _patternB; break;
}


ledStrip1.SetPattern(EPattern::A);

Конечно, я мог бы также передать шаблон, где шаблоны создаются глобально, но это не имеет значения для данного примера. Идея состоит в том, чтобы заранее создать 4 экземпляра (светодиодные полосы) * 24 экземпляра (узоры) и никогда не использовать delete. Это означает, что из 4 * 24 паттернов используются только 4, по 1 на светодиодную ленту.

Конечно, это приводит к большому количеству неиспользуемой памяти.

2. Создать/Удалить

Я создаю 4 правильных производных экземпляра, и когда один шаблон (экземпляр) изменяется, я удаляю экземпляр и создаю новый. Когда я не помещаю никаких переменных (экземпляров) в производный класс, это может сработать, но у меня есть некоторые конкретные вопросы относительно этого решения:

Я позабочусь о том, чтобы все было по максимуму. параметры находятся в базовом классе, и я "бросаю" 4 экземпляра базового класса в производный класс. Это кажется немного "хитрым" решением.

class Pattern
{
   public:
      SetParameter(uint8_t parameter, uint8_t parameterValue);
      uint8_t parameter GetParameter(uint8_t parameter);

   private:
      uint8_t _parameters[16];
}

class PatternA: Pattern
... (does not have any variables)

Чтобы изменить шаблон:

delete ledStrip1.pattern;
ledStrip1.pattern = new PatternA();

Вопрос: могу ли я предположить, что удаленная память старого шаблона будет заменена новым шаблоном, поскольку использование памяти равно?

Недостатком этого способа является то, что каждый шаблон будет иметь наихудшее количество параметров в каждом случае, но это не проблема (у меня есть только 4 светодиодные полосы).

class Pattern
{
public:
    virtual void process();
};

class Pattern8 : public Pattern
{
public:
    void process() { Serial.println(8000 + param); }
    void set_param(uint8_t param8) { param = param8; }
private:
    uint8_t param;
};

class Pattern16 : public Pattern
{
public:
    void process() { Serial.println(16000 + param); }
    void set_param(uint8_t param16) { param = param16; }
private:
    uint16_t param;
};

// Это помеченный союз.
struct AnyPattern : public Pattern
{
    AnyPattern() {}  // должен быть явно определен
    void process() {
        switch (type) {
            case TYPE8: pattern8.process(); break;
            case TYPE16: pattern16.process(); break;
        }
    }
    enum { TYPE8, TYPE16 } type;
    union {
        Pattern8 pattern8;
        Pattern16 pattern16;
    };
};

void setup() {
    AnyPattern patterns[2];
    patterns[0].type = AnyPattern::TYPE8;
    patterns[0].pattern8.set_param(21);
    patterns[1].type = AnyPattern::TYPE16;
    patterns[1].pattern16.set_param(42);
    Serial.begin(9600);
    patterns[0].process();
    patterns[1].process();
}

void loop(){}