MALedsController.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MALedsController.hpp"

#include "core/MADevice.hpp"
#include "core/MARandomness.hpp"
#include "core/MAValueGenerators.hpp"
#include "types/skits/MALedSkit.hpp"
#include "types/MARobotState.hpp"
#include "types/MATorso.hpp"

#include <MCLog.hpp>

#include <boost/algorithm/string/predicate.hpp>

namespace MA
{
MCThreadLocalData<MALedsController> Leds(false);
}

namespace
{
// Current face mode (0 or 1)
MCThreadLocalData<int> FaceMode(true);

void CheckStaticLedsVariables()
{
  if (unlikely(!FaceMode.get()))
  {
    FaceMode.reset(new int);
    *FaceMode = 0;
  }
}
}

MALedsController::MALedsController() : MAController(MA::LedController), LedModeForSkitter(-1),
  ShownBatteryLevel(-1), MaximumValue(0.4, 0.05, 1.0)
{
  CheckStaticLedsVariables();
  if (MA::Leds.get())
  {
    MC_WARNING("The global leds controller is overridden.");
  }
  MA::Leds.reset(this);

  MA_BIND_TRANSITION_ACTION(MALedsController, ShowSleepingEyes)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowAwakenEyes)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowBatteryChargingAnim)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowCrownStrokedAnim)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowHappyAnim)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowSadAnim)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowBatteryLevel)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowDataUploadStatus)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowClientConnectedStatus)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowNoNetworkStatus)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowStartup)
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowAngryFace)
  MA_BIND_TRANSITION_ACTION(MALedsController, HeavyCalculation);
  MA_BIND_TRANSITION_ACTION(MALedsController, SwitchSoundProfile);
  MA_BIND_TRANSITION_ACTION(MALedsController, NormalVolumeControl);
  MA_BIND_TRANSITION_ACTION(MALedsController, AdaptiveVolumeControl);
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowPickUpMode);
  MA_BIND_TRANSITION_ACTION(MALedsController, ShowGameMode);
  MA_BIND_TRANSITION_ACTION(MALedsController, FadeOutEarsGreen);
  MA_BIND_TRANSITION_ACTION(MALedsController, FadeOutEarsRed);
  MA_BIND_TRANSITION_ACTION(MALedsController, FadeOutCrownWhite);

  // Specify the expression LED modes
  TransitionLedModes[ShowBatteryChargingAnimStr] = 0;
  TransitionLedModes[ShowHappyAnimStr] = 1;
  TransitionLedModes[ShowSadAnimStr] = 1;
  TransitionLedModes[ShowAngryFaceStr] = 0;
}


MALedsController::~MALedsController()
{
  if (MA::Leds.get() == this)
    MA::Leds.release();
}


void MALedsController::UpdateRobotState(MARobotState&)
{
  // Nothing to do
}


MA::DeviceList MALedsController::GetMotors() const
{
  // No motors for the controller
  return MA::DeviceList();
}


int MALedsController::StartTransition(const std::string& name)
{
  // The expression is already active
  if (IsTransitionActive(name))
    return 0;

  // Check and set new face LED mode if needed
  auto LedModeIter = TransitionLedModes.find(name);

  if (LedModeIter != TransitionLedModes.end() && (int)LedModeIter->second != *FaceMode)
  {
    *FaceMode = (int)LedModeIter->second;
  }
  if (LedModeForSkitter >= 0)
    *FaceMode = LedModeForSkitter;

  return MAController::StartTransition(name);
}


void MALedsController::StopTransition(const std::string& name)
{
  auto TransitionIter = Transitions.find(name);

  if (TransitionIter == Transitions.end())
  {
    // Call to have warning message for the missing transition
    MAController::StopTransition(name);
    return;
  }
  LedModeForSkitter = -1;
  MA::DeviceGeneratorsMap& ContainerMap = TransitionIter->second.get<2>();

  MA_CONTAINER_LOCK_OTHER_FILE(Transitions)
  for (auto& container : ContainerMap)
  {
    MADevice* Device = container.first;
    MAGeneratorContainer* Container = container.second;

    // Make sure that the container exists
    if (Device->HasGeneratorContainer(*Container))
    {
      Container->BlockExpiredSignal();
      if (!Container->IsStarted())
      {
        // If the container has not been started yet, it can be removed...
        Device->DeleteGeneratorContainer(*Container);
      } else {
        // ...otherwise swapping the generators inside with a fade out animation
        MAGeneratorContainer* NewContainer = nullptr;

        NewContainer = new MAGeneratorContainer(*new MASimpleGenerator(MCFloatInfinity(), 0.0, 300));
        Device->SwapGeneratorContainer(*Container, *NewContainer);
        Container->CalculateCurrentValue(Device->GetRealSensorValue());
        NewContainer->Start(Container->GetCurrentValue());
        delete Container;
      }
    }
  }
  MAController::StopTransition(name);

  if (name == ShowBatteryLevelStr)
  {
    ShownBatteryLevel = -1;
  }
}


int MALedsController::GetFaceMode()
{
  CheckStaticLedsVariables();
  return *FaceMode;
}


void MALedsController::ResetSkitterFaceMode()
{
  LedModeForSkitter = -1;
}


void MALedsController::SetMaximumValue(float new_value)
{
  MANum<float> NewValue(new_value, MaximumValue.GetMin(), MaximumValue.GetMax());

  if (NewValue == MaximumValue)
    return;

  MaximumValue = (float)NewValue;

  // Apply the new limit to the devices
  for (int i = 0; i < 14; i++)
  {
    Face[i]->SetSoftLimit(MaximumValue);
  }
  BackFBlue->SetSoftLimit(MaximumValue);
  BackMOrange->SetSoftLimit(MaximumValue);
  BackRRed->SetSoftLimit(MaximumValue);
  BackFWhite->SetSoftLimit(MaximumValue);
  BackMWhite->SetSoftLimit(MaximumValue);
  BackRWhite->SetSoftLimit(MaximumValue);
}


float MALedsController::GetMaximumValue() const
{
  return (float)MaximumValue;
}


int MALedsController::GetShownBatteryLevel() const
{
  return ShownBatteryLevel;
}


MA::DeviceGeneratorsMap MALedsController::ShowAwakenEyes()
{
  MAGeneratorBase* Generator = nullptr;
  MA::DeviceGeneratorsMap DeviceGenerators;

  Generator = new MASimpleGenerator(0.0, (float)MaximumValue, 2000);
  AddGenerator(DeviceGenerators, *Face[8], *Face[8]->AddGenerator(*Generator), true);
  Generator = new MASimpleGenerator(0.0, (float)MaximumValue, 2000);
  AddGenerator(DeviceGenerators, *Face[9], *Face[9]->AddGenerator(*Generator), true);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowSleepingEyes()
{
  MAGeneratorBase* Generator = nullptr;
  MA::DeviceGeneratorsMap DeviceGenerators;

  Generator = new MAPeriodicGenerator(0.0, 0.2, 0, 3000, 0, 3000, 0, true);
  AddGenerator(DeviceGenerators, *Face[8], *Face[8]->AddGenerator(*Generator), true);
  Generator = new MAPeriodicGenerator(0.0, 0.2, 0, 3000, 0, 3000, 0, true);
  AddGenerator(DeviceGenerators, *Face[9], *Face[9]->AddGenerator(*Generator), true);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowBatteryChargingAnim()
{
  MAGeneratorBase* Generator = nullptr;
  MA::DeviceGeneratorsMap DeviceGenerators;

  float MaxValue = MCMin((float)0.3, (float)MaximumValue);
  int Speed = 1000;

  Generator = new MAPeriodicGenerator(0.0, MaxValue, 0, Speed, 4*Speed, Speed, 4*Speed, true);
  AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator), true);
  Generator = new MAPeriodicGenerator(0.0, MaxValue, Speed, Speed, 4*Speed, Speed, 3*Speed, true);
  AddGenerator(DeviceGenerators, *Face[4].get(), *Face[4]->AddGenerator(*Generator), true);
  Generator = new MAPeriodicGenerator(0.0, MaxValue, Speed*2, Speed, 4*Speed, Speed, 2*Speed, true);
  AddGenerator(DeviceGenerators, *Face[11].get(), *Face[11]->AddGenerator(*Generator), true);
  Generator = new MAPeriodicGenerator(0.0, MaxValue, Speed*3, Speed, 4*Speed, Speed, Speed, true);
  AddGenerator(DeviceGenerators, *Face[5].get(), *Face[5]->AddGenerator(*Generator), true);
  Generator = new MAPeriodicGenerator(0.0, MaxValue, Speed*4, Speed, 4*Speed, Speed, 0, true);
  AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator), true);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowCrownStrokedAnim()
{
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;
  MA::DeviceGeneratorsMap DeviceGenerators;

  Generator = new MAPeriodicGenerator(0.0, 1.0, 200, 0, 200, 0, 0);
  Container = HeadYellow->AddGenerator(*Generator);
  Generator = new MAPeriodicGenerator(0.0, 1.0, 200, 0, 200, 0, 0); // -V760 (PVS Studio suppression)
  Container->AddGenerator(*Generator);
  Generator = new MAPeriodicGenerator(0.0, 1.0, 200, 0, 200, 0, 0);
  Container->AddGenerator(*Generator);
  AddGenerator(DeviceGenerators, *HeadYellow, *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowHappyAnim()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MA_RANDOM_POINT_1(HappyAnim, 1, 6);

  // Happy expression #1
  if (HappyAnim == 1)
  {
    // Animation direction: <- ->
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
  }
  // Happy expression #2
  if (HappyAnim == 2)
  {
    // Animation direction: -> <-
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
  }
  // Happy expression #3
  if (HappyAnim == 3)
  {
    // Animation direction: ->
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 100, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 300, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
  }
  // Happy expression #4
  if (HappyAnim == 4)
  {
    // Animation direction: <-
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 100, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 300, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
  }
  // Happy expression #5
  if (HappyAnim == 5)
  {
    // Increasing together, but decreasing separately
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
  }
  // Happy expression #6
  if (HappyAnim == 6)
  {
    // Increasing together, but decreasing separately
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[0].get(), *Face[0]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[1].get(), *Face[1]->AddGenerator(*Generator));
  }
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowSadAnim()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MA_RANDOM_POINT_1(SadAnim, 1, 4);

  // Sad expression #1
  if (SadAnim == 1)
  {
    // Animation direction: <- ->
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[12].get(), *Face[12]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[13].get(), *Face[13]->AddGenerator(*Generator));
  }
  // Sad expression #2
  if (SadAnim == 2)
  {
    // Animation direction: -> <-
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[13].get(), *Face[13]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 200, 200, 100, 300, 0);
    AddGenerator(DeviceGenerators, *Face[12].get(), *Face[12]->AddGenerator(*Generator));
  }
  // Sad expression #3
  if (SadAnim == 3)
  {
    // Increasing together, but decreasing separately
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[12].get(), *Face[12]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[13].get(), *Face[13]->AddGenerator(*Generator));
  }
  // Sad expression #4
  if (SadAnim == 4)
  {
    // Increasing together, but decreasing separately
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 400, 300, 0);
    AddGenerator(DeviceGenerators, *Face[12].get(), *Face[12]->AddGenerator(*Generator));
    Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 100, 300, 300, 0);
    AddGenerator(DeviceGenerators, *Face[13].get(), *Face[13]->AddGenerator(*Generator));
  }
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowBatteryLevel()
{
  if (ShownBatteryLevel == (int)MA::RobotState->Torso->BatteryLevel)
  {
    return MA::DeviceGeneratorsMap();
  }
  MA::DeviceGeneratorsMap DeviceGenerators;
  MA::DeviceList DevicesToClear;
  MAGeneratorBase* Generator = nullptr;

  ShownBatteryLevel = (int)MA::RobotState->Torso->BatteryLevel;

  // The intensity of the first LED (MaxValue -> 0.0) follows the battery level
  // 100 % -> 66 %
  if (ShownBatteryLevel >= 66)
  {
    Generator = new MASimpleGenerator(BackFBlue->GetSensorValue(),
                                      ((float)ShownBatteryLevel-66.0) / 34.0*(float)MaximumValue, 2000);
    AddGenerator(DeviceGenerators, *BackFBlue.get(), *BackFBlue->AddGenerator(*Generator), true);
    if (ShownBatteryLevel > 82)
    {
      DevicesToClear.push_back(BackMOrange.get());
    }
    DevicesToClear.push_back(BackRRed.get());
  }

  // The intensity of the second LED (0.0 <- MaxValue / 2 -> 0.0) follows the battery level
  // 82 % <- 50 % -> 18 %
  if (ShownBatteryLevel >= 18 && ShownBatteryLevel <= 82)
  {
    float Level = (int)ShownBatteryLevel >= 50 ? 82-ShownBatteryLevel : (int)ShownBatteryLevel-18;

    Generator = new MASimpleGenerator(BackMOrange->GetSensorValue(),
                                      Level / 32.0*(float)MaximumValue, 2000);
    AddGenerator(DeviceGenerators, *BackMOrange.get(), *BackMOrange->AddGenerator(*Generator), true);
    if (ShownBatteryLevel < 66)
    {
      DevicesToClear.push_back(BackFBlue.get());
    }
    if (ShownBatteryLevel > 32 && ShownBatteryLevel < 66)
    {
      DevicesToClear.push_back(BackRRed.get());
    }
  }

  // The intensity of the third LED (0.0 -> ~?) follows the battery level
  // 32 % -> 10 %
  if (ShownBatteryLevel >= 10 && ShownBatteryLevel <= 32)
  {
    // Remove old value generators by force
    Generator = new MASimpleGenerator(BackRRed->GetSensorValue(),
                                      (float)(32.0-ShownBatteryLevel) / 32.0*(float)MaximumValue, 2000);
    AddGenerator(DeviceGenerators, *BackRRed.get(), *BackRRed->AddGenerator(*Generator), true);
    if (ShownBatteryLevel < 18)
    {
      DevicesToClear.push_back(BackMOrange.get());
      DevicesToClear.push_back(BackFBlue.get());
    }
  } else
  // Start the low battery animation
  if (ShownBatteryLevel < 10)
  {
    // Setup the periodic animation with start value
    float MaxValue = 22.0 / 32.0*(float)MaximumValue;

    Generator = new MAPeriodicGenerator(0.0, MaxValue, 0, 3000, 0, 3000, 0, true);
    Generator->Start(BackRRed->GetSensorValue());
    AddGenerator(DeviceGenerators, *BackRRed.get(), *BackRRed->AddGenerator(*Generator), true);
    DevicesToClear.push_back(BackMOrange.get());
    DevicesToClear.push_back(BackFBlue.get());
  }

  // Clear the device values if needed
  for (auto& device : DevicesToClear)
  {
    if (device->GetNextValue() > 0.0)
    {
      Generator = new MASimpleGenerator(device->GetSensorValue(), 0.0, 2000);
      device->AddGenerator(*Generator);
    }
  }
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowDataUploadStatus()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;

  Generator = new MAPeriodicGenerator(0, 1, 100, 0, 800, 0, 100, false);
  AddGenerator(DeviceGenerators, *HeadWifi.get(), *HeadWifi->AddGenerator(*Generator));
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowClientConnectedStatus()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;

  Generator = new MAPeriodicGenerator(0, 1, 100, 0, 1000, 0, 100, false);
  AddGenerator(DeviceGenerators, *EarsBlue.get(), *EarsBlue->AddGenerator(*Generator));
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowNoNetworkStatus()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  Generator = new MAPeriodicGenerator(0, 1.0, 300, 0, 200, 0, 300);
  Container = new MAGeneratorContainer(*Generator);
  Generator = new MAPeriodicGenerator(0, 1.0, 100, 0, 200, 0, 300);
  Container->AddGenerator(*Generator);
  EarsBlue->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *EarsBlue.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowStartup()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;

  Generator = new MAPeriodicGenerator(0.0, 0.6, 0, 3000, 9000, 3000, 0);
  AddGenerator(DeviceGenerators, *BackFWhite.get(), *BackFWhite->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, 0.6, 3000, 3000, 6000, 3000, 0);
  AddGenerator(DeviceGenerators, *BackMWhite.get(), *BackMWhite->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, 0.6, 6000, 3000, 3000, 3000, 0);
  AddGenerator(DeviceGenerators, *BackRWhite.get(), *BackRWhite->AddGenerator(*Generator));
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowAngryFace()
{
  MAGeneratorBase* Generator = nullptr;
  MA::DeviceGeneratorsMap DeviceGenerators;

  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[2].get(), *Face[2]->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[3].get(), *Face[3]->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[4].get(), *Face[4]->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[5].get(), *Face[5]->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[12].get(), *Face[12]->AddGenerator(*Generator));
  Generator = new MAPeriodicGenerator(0.0, MaximumValue, 0, 200, 300, 300, 0);
  AddGenerator(DeviceGenerators, *Face[13].get(), *Face[13]->AddGenerator(*Generator));
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::HeavyCalculation()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorContainer* Container = nullptr;

  Container = new MAGeneratorContainer(*new MASimpleGenerator(HeadWhite->GetNextValue(), 1.0, 10));
  Container->AddGenerator(*new MADelayGenerator(300));
  Container->AddGenerator(*new MASimpleGenerator(MCFloatInfinity(), 0.0, 10));
  HeadWhite->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *HeadWhite.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::SwitchSoundProfile()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  Generator = new MASimpleGenerator(BackFWhite->GetNextValue(), 0, 100);
  Container = new MAGeneratorContainer(*Generator);
  Generator = new MAPeriodicGenerator(0, MaximumValue, 100, 0, 800, 0, 100, false);
  Container->AddGenerator(*Generator);
  BackFWhite->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *BackFWhite.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::NormalVolumeControl()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  Generator = new MASimpleGenerator(BackRWhite->GetNextValue(), 0, 100);
  Container = new MAGeneratorContainer(*Generator);
  Generator = new MAPeriodicGenerator(0, MaximumValue, 100, 0, 800, 0, 100, false);
  Container->AddGenerator(*Generator);
  BackRWhite->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *BackRWhite.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::AdaptiveVolumeControl()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  Generator = new MASimpleGenerator(BackRWhite->GetNextValue(), 0, 100);
  Container = new MAGeneratorContainer(*Generator);
  Generator = new MAPeriodicGenerator(0, MaximumValue, 100, 0, 800, 0, 100, false); // -V760 (PVS Studio suppression)
  Container->AddGenerator(*Generator);
  Generator = new MAPeriodicGenerator(0, MaximumValue, 100, 0, 800, 0, 100, false);
  Container->AddGenerator(*Generator);
  BackRWhite->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *BackRWhite.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowPickUpMode()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  // Suppress the other ear LEDs
  Generator = new MAPeriodicGenerator(0, -1, 0, 0, 3600000, 0, 0, false);
  AddGenerator(DeviceGenerators, *EarsBlue.get(), *EarsBlue->AddGenerator(*Generator), false);
  Generator = new MAPeriodicGenerator(0, -1, 0, 0, 3600000, 0, 0, false);
  AddGenerator(DeviceGenerators, *EarsRed.get(), *EarsRed->AddGenerator(*Generator), false);
  // Generators for pick-up mode
  Generator = new MASimpleGenerator(EarsGreen->GetNextValue(), 0, 200);
  Container = new MAGeneratorContainer(*Generator);
  Generator = new MAPeriodicGenerator(0, 1, 300, 0, 800, 0, 300, true);
  Container->AddGenerator(*Generator);
  EarsGreen->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *EarsGreen.get(), *Container, true);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::ShowGameMode()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  // Suppress the other ear LEDs
  Generator = new MAPeriodicGenerator(0, -1, 0, 0, 3600000, 0, 0, false);
  AddGenerator(DeviceGenerators, *EarsBlue.get(), *EarsBlue->AddGenerator(*Generator), false);
  Generator = new MAPeriodicGenerator(0, -1, 0, 0, 3600000, 0, 0, false);
  AddGenerator(DeviceGenerators, *EarsGreen.get(), *EarsGreen->AddGenerator(*Generator), false);
  // Generators for game mode
  Container = new MAGeneratorContainer(*new MASimpleGenerator(EarsRed->GetNextValue(), 0, 200));
  Container->AddGenerator(*new MASimpleGenerator(1, 1, 1000));
  EarsRed->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *EarsRed.get(), *Container, false);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::FadeOutEarsGreen()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorContainer* Container = nullptr;

  Container = new MAGeneratorContainer(*new MASimpleGenerator(0, 0, 600));
  EarsGreen->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *EarsGreen.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::FadeOutEarsRed()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorContainer* Container = nullptr;

  Container = new MAGeneratorContainer(*new MASimpleGenerator(0, 0, 600));
  EarsRed->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *EarsRed.get(), *Container);
  return DeviceGenerators;
}


MA::DeviceGeneratorsMap MALedsController::FadeOutCrownWhite()
{
  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorBase* Generator = nullptr;
  MAGeneratorContainer* Container = nullptr;

  Generator = new MASimpleGenerator(0, 0, 600);
  Container = new MAGeneratorContainer(*Generator);
  HeadWhite->AddGeneratorContainer(*Container);
  AddGenerator(DeviceGenerators, *HeadWhite.get(), *Container);
  return DeviceGenerators;
}


void MALedsController::AddGenerator(MA::DeviceGeneratorsMap& device_generators, MADevice& device,
                                    MAGeneratorContainer& container, bool permanent)
{
  if (!permanent && container.GetDuration() < 0)
  {
    MC_WARNING("The generator container can not be infinite for a temporary transition!");
    return;
  }
  if (!permanent && container.GetStartingValue() != 0.0)
  {
    MC_WARNING("The generator container must start with zero for a temporary transition!");
    return;
  }
  if (!device.HasGeneratorContainer(container))
  {
    MC_WARNING("The device does not have this container!");
    return;
  }
  // Note: Permanent expressions can end up in non-zero target values
  if (boost::starts_with(device.GetDisplayName(), "Face") && !permanent && container.GetTargetValue() != 0.0)
  {
    MC_WARNING("The generator container does not decrease back to zero!");
    return;
  }
  if (!container.IsAbsolute())
  {
    MC_WARNING("The generator container has uncertain start or target value!");
    return;
  }
  // Add an infinite delay to the end of the container of a permanent expression if needed
  if (permanent && container.GetDuration() >= 0)
  {
    container.MakePermanent();
  }
  // Find and remove the colliding expressions
  if (permanent)
  {
    MC::StringList DeviceTransitions = GetActiveTransitionsByDevice(device);

    for (auto& transition : DeviceTransitions)
    {
      StopTransition(transition);
    }
  }
  // Insert the new generator container
  device_generators.insert(MA::DeviceGeneratorPair(&device, &container));
}


void MALedsController::ClearFace()
{
  if (IsAnyActiveTransition())
  {
    MC_WARNING("The face LEDs can not be cleared when any expression is active.");
    MC_WARNING("The intention of the function is to clear the LEDs on start-up.");
    return;
  }
  // oled3_MODE_A -> 0 and we want to be a bit portable/testable at this level on x86/x64
  *FaceMode = 0;
  for (int i = 0; i < 14; i++)
    Face[i]->SetNextValue(0.0);
  if (MAController::IsVerbose())
    MC_LOG("Clear face");
}


MA::DeviceGeneratorsMap MALedsController::GetSkitTransitionGenerators(MA::SkitBaseSPtr skit)
{
  MALedSkit* LedSkit = dynamic_cast<MALedSkit*>(skit.get());

  if (!LedSkit)
    return MA::DeviceGeneratorsMap();

  MA::DeviceGeneratorsMap DeviceGenerators;
  MAGeneratorContainer* Container = nullptr;

  Container = LedSkit->GetGeneratorContainer(MA::BackFBlue);
  if (Container)
  {
    BackFBlue->ClearGenerators();
    BackFBlue->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackFBlue.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::BackFWhite);
  if (Container)
  {
    BackFWhite->ClearGenerators();
    BackFWhite->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackFWhite.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::BackMOrange);
  if (Container)
  {
    BackMOrange->ClearGenerators();
    BackMOrange->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackMOrange.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::BackMWhite);
  if (Container)
  {
    BackMWhite->ClearGenerators();
    BackMWhite->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackMWhite.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::BackRRed);
  if (Container)
  {
    BackRRed->ClearGenerators();
    BackRRed->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackRRed.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::BackRWhite);
  if (Container)
  {
    BackRWhite->ClearGenerators();
    BackRWhite->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, BackRWhite.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::HeadWiFi);
  if (Container)
  {
    HeadWifi->ClearGenerators();
    HeadWifi->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, HeadWifi.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::HeadYellow);
  if (Container)
  {
    HeadYellow->ClearGenerators();
    HeadYellow->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, HeadYellow.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::HeadWhite);
  if (Container)
  {
    HeadWhite->ClearGenerators();
    HeadWhite->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, HeadWhite.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::EarsRed);
  if (Container)
  {
    EarsRed->ClearGenerators();
    EarsRed->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, EarsRed.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::EarsGreen);
  if (Container)
  {
    EarsGreen->ClearGenerators();
    EarsGreen->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, EarsGreen.get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::EarsBlue);
  if (Container)
  {
    EarsBlue->ClearGenerators();
    EarsBlue->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, EarsBlue.get(), Container);
  }
  // Face LEDs
  bool LockMode0 = false;
  bool LockMode1 = false;

  Container = LedSkit->GetGeneratorContainer(MA::Face1White);
  if (Container && !LockMode1) // -V560 (PVS Studio suppression)
  {
    Face[0]->ClearGenerators();
    Face[0]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[0].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face1Color);
  if (Container && !LockMode0)
  {
    Face[0]->ClearGenerators();
    Face[0]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[0].get(), Container);
    LockMode1 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face2White);
  if (Container && !LockMode1)
  {
    Face[1]->ClearGenerators();
    Face[1]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[1].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face2Color);
  if (Container && !LockMode0)
  {
    Face[1]->ClearGenerators();
    Face[1]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[1].get(), Container);
    LockMode1 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face3White);
  if (Container && !LockMode1)
  {
    Face[2]->ClearGenerators();
    Face[2]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[2].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face3Color);
  if (Container && !LockMode0)
  {
    Face[2]->ClearGenerators();
    Face[2]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[2].get(), Container);
    LockMode1 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face4White);
  if (Container && !LockMode1)
  {
    Face[3]->ClearGenerators();
    Face[3]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[3].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face4Color);
  if (Container && !LockMode0)
  {
    Face[3]->ClearGenerators();
    Face[3]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[3].get(), Container);
    LockMode1 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face5White);
  if (Container)
  {
    Face[4]->ClearGenerators();
    Face[4]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[4].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face6White);
  if (Container)
  {
    Face[5]->ClearGenerators();
    Face[5]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[5].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face7White);
  if (Container)
  {
    Face[6]->ClearGenerators();
    Face[6]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[6].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face8White);
  if (Container)
  {
    Face[7]->ClearGenerators();
    Face[7]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[7].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face9White);
  if (Container)
  {
    Face[8]->ClearGenerators();
    Face[8]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[8].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face10White);
  if (Container)
  {
    Face[9]->ClearGenerators();
    Face[9]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[9].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face11White);
  if (Container)
  {
    Face[10]->ClearGenerators();
    Face[10]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[10].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face12White);
  if (Container)
  {
    Face[11]->ClearGenerators();
    Face[11]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[11].get(), Container);
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face13Color0);
  if (Container && !LockMode1)
  {
    Face[12]->ClearGenerators();
    Face[12]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[12].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face13Color1);
  if (Container && !LockMode0)
  {
    Face[12]->ClearGenerators();
    Face[12]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[12].get(), Container);
    LockMode1 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face14Color0);
  if (Container && !LockMode1)
  {
    Face[13]->ClearGenerators();
    Face[13]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[13].get(), Container);
    LockMode0 = true;
  }
  Container = LedSkit->GetGeneratorContainer(MA::Face14Color1);
  if (Container && !LockMode0)
  {
    Face[13]->ClearGenerators();
    Face[13]->AddGeneratorContainer(*Container);
    MA_INSERT_DEVICEGENERATOR(DeviceGenerators, Face[13].get(), Container);
  }
  LedModeForSkitter = -1;

  if (LockMode0)
    LedModeForSkitter = 0;
  if (LockMode1)
    LedModeForSkitter = 1;

  return DeviceGenerators;
}