diff --git a/src/dali/controller/bus.cpp b/src/dali/controller/bus.cpp
index b2a00c1..65a55c1 100644
--- a/src/dali/controller/bus.cpp
+++ b/src/dali/controller/bus.cpp
@@ -16,17 +16,17 @@ namespace dali {
 namespace controller {
 namespace {
 
-const uint64_t kCommandRepeatTimeout = 100;
+const Time kCommandRepeatTimeout = 100;
 
 }
 
-Bus::Bus(IBus* bus) :
+Bus::Bus(IBusDriver* bus, Client* client) :
     mBus(bus),
-    mState(IBus::IBusState::UNKNOWN),
-    mListener(nullptr),
+    mClient(client),
+    mState(IBusDriver::IBusState::UNKNOWN),
     mLastCommand(Command::INVALID),
     mCommandRepeatCount(0),
-    mLastCommandTimeMs(0) {
+    mLastCommandTime(0) {
   mBus->registerClient(this);
 }
 
@@ -34,138 +34,128 @@ Bus::~Bus() {
   mBus->unregisterClient(this);
 }
 
-void Bus::setListener(Listener* listener) {
-  mListener = listener;
-}
+void Bus::onDataReceived(Time time, uint16_t data) {
 
-void Bus::onDataReceived(uint64_t timeMs, uint16_t data) {
-  Command command;
   uint8_t param;
-  if (filterAddress(data, &command, &param) != Status::OK) {
-    return; // Status::INVALID;
+  Command command = extractCommand(data, &param);
+  if (command == Command::INVALID) {
+    return;
   }
-  if (command != Command::INVALID) { // should be always true
-    if (mLastCommand == Command::INVALID) {
+  if (mLastCommand == Command::INVALID) {
+    mCommandRepeatCount = 0;
+    mLastCommandTime = time;
+    Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
+    if (status == Status::REPEAT_REQUIRED) {
+      mLastCommand = command;
+      return;
+    } else {
+      mLastCommand = Command::INVALID;
+      return;
+    }
+  } else if (mLastCommand == command) {
+    if (time - mLastCommandTime < kCommandRepeatTimeout) {
+      mCommandRepeatCount++;
+    } else {
+      mLastCommand = Command::INVALID;
       mCommandRepeatCount = 0;
-      mLastCommandTimeMs = timeMs;
-      Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
-      if (status == Status::REPEAT_REQUIRED) {
-        mLastCommand = command;
-        return; // Status::OK;
-      } else {
-        mLastCommand = Command::INVALID;
-        return; // status;
-      }
-    } else if (mLastCommand == command) {
-      if (timeMs - mLastCommandTimeMs < kCommandRepeatTimeout) {
-        mCommandRepeatCount++;
-      } else {
-        mLastCommand = Command::INVALID;
-        mCommandRepeatCount = 0;
-      }
-      mLastCommandTimeMs = timeMs;
-      Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
+    }
+    mLastCommandTime = time;
+    Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
+    if (status == Status::REPEAT_REQUIRED) {
+      mLastCommand = command;
+      return;
+    } else {
+      mLastCommand = Command::INVALID;
+      return;
+    }
+  } else { // (mLastCommand != Command::INVALID) || (mLastCommand != cmd)
+    mLastCommand = Command::INVALID;
+    mCommandRepeatCount = 0;
+    mLastCommandTime = time;
+    if (time - mLastCommandTime < kCommandRepeatTimeout) {
+      mClient->handleIgnoredCommand(command, param);
+    } else {
+      Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
       if (status == Status::REPEAT_REQUIRED) {
         mLastCommand = command;
-        return; // Status::OK;
-      } else {
-        mLastCommand = Command::INVALID;
-        return; // status;
-      }
-    } else { // (mLastCommand != Command::INVALID) || (mLastCommand != cmd)
-      mLastCommand = Command::INVALID;
-      mCommandRepeatCount = 0;
-      if (timeMs - mLastCommandTimeMs < kCommandRepeatTimeout) {
-        mLastCommandTimeMs = timeMs;
-        mListener->handleIgnoredCommand(command, param);
+        return;
       } else {
-        mLastCommandTimeMs = timeMs;
-        Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
-        if (status == Status::REPEAT_REQUIRED) {
-          mLastCommand = command;
-          return; // Status::OK;
-        } else {
-          return; // status;
-        }
+        return;
       }
     }
   }
-  return; // Status::INVALID;
 }
 
-void Bus::onBusStateChanged(IBus::IBusState state) {
+void Bus::onBusStateChanged(IBusDriver::IBusState state) {
   if (mState != state) {
     mState = state;
-    if (state == IBus::IBusState::DISCONNECTED) {
-      mListener->onBusDisconnected();
+    if (state == IBusDriver::IBusState::DISCONNECTED) {
+      mClient->onBusDisconnected();
     }
   }
 }
 
-Status Bus::sendAck(uint8_t ack) {
-  return mBus->sendAck(ack);
-}
-
-Status Bus::filterAddress(uint16_t data, Command* command, uint8_t* param) {
-  *param = (uint8_t) (data & 0xff);
-  *command = Command::INVALID;
+Command Bus::extractCommand(uint16_t data, uint8_t* commandParam) {
+  Command command = Command::INVALID;
+  uint8_t param = (uint8_t) (data & 0xff);
   uint8_t addr = (uint8_t) (data >> 8);
   bool cmdBitSet = ((addr & 0x01) != 0);
   if ((addr & 0xfe) == 0xfe) {
     // Broadcast
     if (cmdBitSet) {
-      *command = (Command) *param;
-      *param = 0xff;
+      command = (Command) param;
+      param = 0xff;
     } else {
-      *command = Command::DIRECT_POWER_CONTROL;
+      command = Command::DIRECT_POWER_CONTROL;
     }
   } else if ((addr & 0x80) == 0) {
     // Short address
     addr >>= 1;
-    uint8_t myAddr = mListener->getShortAddr() >> 1;
+    uint8_t myAddr = mClient->getShortAddr() >> 1;
     if (cmdBitSet) {
-      *command = (Command) *param;
-      *param = 0xff;
+      command = (Command) param;
+      param = 0xff;
     } else {
-      *command = Command::DIRECT_POWER_CONTROL;
+      command = Command::DIRECT_POWER_CONTROL;
     }
     if (addr != myAddr) {
-      return Status::INVALID;
+      return Command::INVALID;
     }
   } else if ((addr & 0x60) == 0) {
     // Group address
     uint8_t group = (addr >> 1) & 0x0f;
-    uint16_t groups = mListener->getGroups();
+    uint16_t groups = mClient->getGroups();
     if (cmdBitSet) {
-      *command = (Command) *param;
-      *param = 0xff;
+      command = (Command) param;
+      param = 0xff;
     } else {
-      *command = Command::DIRECT_POWER_CONTROL;
+      command = Command::DIRECT_POWER_CONTROL;
     }
     if ((groups & (1 << group)) == 0) {
-      return Status::INVALID;
+      return Command::INVALID;
     }
   } else {
-    *command = (Command) ((uint16_t) Command::_SPECIAL_COMMAND + addr);
-    if (*command == Command::INITIALISE) {
-      uint8_t myAddr = mListener->getShortAddr() >> 1;
-      switch (*param) {
+    command = (Command) ((uint16_t) Command::_SPECIAL_COMMAND + addr);
+    if (command == Command::INITIALISE) {
+      uint8_t myAddr = mClient->getShortAddr() >> 1;
+      switch (param) {
       case 0x00: // All control gear shall react
         break;
       case 0xff: // Control gear without short address shall react
         if (myAddr <= DALI_ADDR_MAX) {
-          return Status::INVALID;
+          return Command::INVALID;
         }
         break;
       default: // Control gear with the address AAAAAAb shall react
-        if (myAddr != (*param >> 1)) {
-          return Status::INVALID;
+        if (myAddr != (param >> 1)) {
+          return Command::INVALID;
         }
         break;
       }
     }
   }
-  return Status::OK;
+  *commandParam = param;
+  return command;
 }
 
 } // namespace controller
diff --git a/src/dali/controller/bus.hpp b/src/dali/controller/bus.hpp
index 0827cf6..19071ca 100644
--- a/src/dali/controller/bus.hpp
+++ b/src/dali/controller/bus.hpp
@@ -16,10 +16,10 @@
 namespace dali {
 namespace controller {
 
-class Bus: public IBus::IBusClient {
+class Bus: public IBusDriver::IBusClient {
 public:
 
-  class Listener {
+  class Client {
   public:
     virtual uint8_t getShortAddr() = 0;
     virtual uint16_t getGroups() = 0;
@@ -28,31 +28,27 @@ public:
     virtual void onBusDisconnected() = 0;
   };
 
-  explicit Bus(IBus* bus);
+  explicit Bus(IBusDriver* bus, Client* client);
   virtual ~Bus();
 
-  void setListener(Listener* listener);
+  Status sendAck(uint8_t ack) { return mBus->sendAck(ack); }
+  Time getLastCommandTime() { return mLastCommandTime; }
 
-  void onDataReceived(uint64_t timeMs, uint16_t data) override;
-  void onBusStateChanged(IBus::IBusState state) override;
-
-  Status sendAck(uint8_t ack);
-  uint64_t getLastCommandTimeMs() {
-    return mLastCommandTimeMs;
-  }
+  void onDataReceived(Time time, uint16_t data) override;
+  void onBusStateChanged(IBusDriver::IBusState state) override;
 
 private:
   Bus(const Bus& other) = delete;
   Bus& operator=(const Bus&) = delete;
 
-  Status filterAddress(uint16_t data, Command* command, uint8_t* param);
+  Command extractCommand(uint16_t data, uint8_t* param);
 
-  IBus* const mBus;
-  IBus::IBusState mState;
-  Listener* mListener;
+  IBusDriver* const mBus;
+  Client* mClient;
+  IBusDriver::IBusState mState;
   Command mLastCommand;
   uint16_t mCommandRepeatCount;
-  uint64_t mLastCommandTimeMs;
+  Time mLastCommandTime;
 };
 
 } // namespace controller
diff --git a/src/dali/controller/initialization.hpp b/src/dali/controller/initialization.hpp
index 747fa6c..21fa4e6 100644
--- a/src/dali/controller/initialization.hpp
+++ b/src/dali/controller/initialization.hpp
@@ -56,7 +56,7 @@ private:
 
   ITimer* const mTimer;
   Memory* const mMemoryController;
-  uint64_t mInitializeTime;
+  Time mInitializeTime;
   bool mInitialized;
   bool mWithdraw;
   Selection mSelected;
diff --git a/src/dali/controller/lamp.cpp b/src/dali/controller/lamp.cpp
index 2524b89..b8771fb 100644
--- a/src/dali/controller/lamp.cpp
+++ b/src/dali/controller/lamp.cpp
@@ -40,10 +40,6 @@ void Lamp::onReset() {
   mIsPowerSet = true;
 }
 
-bool Lamp::isPowerOn() {
-  return (mLamp->getLevel() > 0);
-}
-
 bool Lamp::isFailure() {
   switch (mLampState) {
   case ILamp::ILampState::DISCONNECTED:
@@ -54,18 +50,6 @@ bool Lamp::isFailure() {
   }
 }
 
-bool Lamp::isFading() {
-  return mLamp->isFading();
-}
-
-bool Lamp::isLimitError() {
-  return mLimitError;
-}
-
-bool Lamp::isPowerSet() {
-  return mIsPowerSet;
-}
-
 uint8_t Lamp::getLevel() {
   if ((mMode == Mode::NORMAL) && (mLampState == ILamp::ILampState::OK)) {
     return driver2level(mLamp->getLevel(), mMemoryController->getMinLevel());
@@ -115,15 +99,7 @@ Status Lamp::abortFading() {
   return Status::OK;
 }
 
-void Lamp::setListener(Listener* listener) {
-  mListener = listener;
-}
-
-void Lamp::notifyPowerDown() {
-  mLamp->setLevel(0, 0);
-}
-
-Status Lamp::powerDirect(uint8_t level, uint64_t time) {
+Status Lamp::powerDirect(uint8_t level, Time time) {
   if (level == DALI_MASK) {
     mLamp->abortFading();
     return Status::OK;
@@ -259,12 +235,12 @@ Status Lamp::powerRecallFaliureLevel() {
   return setLevel(level, 0);
 }
 
-Status Lamp::enableDapcSequence(uint64_t time) {
+Status Lamp::enableDapcSequence(Time time) {
   mDapcTime = time;
   return Status::OK;
 }
 
-Status Lamp::dapcSequence(uint8_t level, uint64_t time) {
+Status Lamp::dapcSequence(uint8_t level, Time time) {
   onPowerCommand();
   mDapcTime = time;
   uint8_t actualLevel = getLevel();
diff --git a/src/dali/controller/lamp.hpp b/src/dali/controller/lamp.hpp
index 2a0a3ef..aae5067 100644
--- a/src/dali/controller/lamp.hpp
+++ b/src/dali/controller/lamp.hpp
@@ -31,24 +31,26 @@ public:
 
 // >>> used only in controller namespace
   void onReset();
-  bool isPowerOn();
+  bool isPowerOn() { return (mLamp->getLevel() > 0); }
   bool isFailure();
-  bool isFading();
-  bool isLimitError();
-  bool isPowerSet();
+  bool isFading() { return mLamp->isFading(); }
+  bool isLimitError() { return mLimitError; }
+  bool isPowerSet() { return mIsPowerSet; }
 
   uint8_t getLevel();
   Status setLevel(uint8_t level, uint32_t fadeTime);
+
   uint32_t getFadeTime();
   uint32_t getFadeRate();
 
   Status abortFading();
 // <<< used only in controller namespace
 
-  void setListener(Listener* listener);
-  void notifyPowerDown();
+  void setListener(Listener* listener) { mListener = listener; }
+
+  void notifyPowerDown() { mLamp->setLevel(0, 0); }
 
-  virtual Status powerDirect(uint8_t level, uint64_t time);
+  virtual Status powerDirect(uint8_t level, Time time);
   virtual Status powerOff();
   virtual Status powerScene(uint8_t scene);
   virtual Status powerUp();
@@ -61,16 +63,12 @@ public:
   virtual Status powerRecallMaxLevel();
   virtual Status powerRecallOnLevel();
   virtual Status powerRecallFaliureLevel();
-  Status enableDapcSequence(uint64_t time);
+  Status enableDapcSequence(Time time);
 
 protected:
-  ILamp* const getLamp() {
-    return mLamp;
-  }
+  ILamp* const getLamp() { return mLamp; }
+  Memory* const getMemoryController() { return mMemoryController; }
 
-  Memory* const getMemoryController() {
-    return mMemoryController;
-  }
   enum class Mode {
     NORMAL,
     CONSTANT_POWER,
@@ -82,7 +80,7 @@ private:
   Lamp(const Lamp& other) = delete;
   Lamp& operator=(const Lamp&) = delete;
 
-  Status dapcSequence(uint8_t level, uint64_t time);
+  Status dapcSequence(uint8_t level, Time time);
 
   void onPowerCommand();
 
@@ -96,7 +94,7 @@ private:
   Listener* mListener;
   bool mIsPowerSet;
   bool mLimitError;
-  uint64_t mDapcTime;
+  Time mDapcTime;
   uint8_t mConstPower;
 };
 
diff --git a/src/dali/controller/lamp_helper.cpp b/src/dali/controller/lamp_helper.cpp
index c7e5e3b..4b86c97 100644
--- a/src/dali/controller/lamp_helper.cpp
+++ b/src/dali/controller/lamp_helper.cpp
@@ -295,7 +295,24 @@ const uint32_t kFadeTime[16] = { // fade times from 0 to 254 in milliseconds
     90510, // 15
 };
 
-const uint8_t kStepsFor200FadeRate[16] = { 1, 72, 51, 36, 25, 18, 13, 9, 6, 4, 3, 2, 2, 1, 1, 1 };
+const uint8_t kStepsFor200FadeRate[16] = {
+    1,  // 0
+    72, // 1
+    51, // 2
+    36, // 3
+    25, // 4
+    18, // 5
+    13, // 6
+    9,  // 7
+    6,  // 8
+    4,  // 9
+    3,  // 10
+    2,  // 11
+    2,  // 12
+    1,  // 13
+    1,  // 14
+    1   // 15
+};
 
 uint16_t level2driver(uint8_t level) {
   return kLevel2driver[level];
diff --git a/src/dali/controller/memory.cpp b/src/dali/controller/memory.cpp
index 74af7f5..8f2f682 100644
--- a/src/dali/controller/memory.cpp
+++ b/src/dali/controller/memory.cpp
@@ -77,67 +77,35 @@ Status Memory::writeMemory(uint8_t data) {
   return status;
 }
 
-uint8_t Memory::getPhisicalMinLevel() {
-  return mData->phisicalMinLevel;
-}
-
 Status Memory::setPhisicalMinLevel(uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, phisicalMinLevel), level);
 }
 
-uint8_t Memory::getShortAddr() {
-  return mData->shortAddr;
-}
-
 Status Memory::setShortAddr(uint8_t addr) {
   addr |= 0x01; // normalize address
   return writeData8(DATA_FIELD_OFFSET(Data, shortAddr), addr);
 }
 
-uint8_t Memory::getMinLevel() {
-  return mData->minLevel;
-}
-
 Status Memory::setMinLevel(uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, minLevel), level);
 }
 
-uint8_t Memory::getMaxLevel() {
-  return mData->maxLevel;
-}
-
 Status Memory::setMaxLevel(uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, maxLevel), level);
 }
 
-uint8_t Memory::getPowerOnLevel() {
-  return mData->powerOnLevel;
-}
-
 Status Memory::setPowerOnLevel(uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, powerOnLevel), level);
 }
 
-uint8_t Memory::getFaliureLevel() {
-  return mData->failureLevel;
-}
-
 Status Memory::setFaliureLevel(uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, failureLevel), level);
 }
 
-uint8_t Memory::getFadeTime() {
-  return mData->fadeTime;
-}
-
 Status Memory::setFadeTime(uint8_t fadeTime) {
   return writeData8(DATA_FIELD_OFFSET(Data, fadeTime), fadeTime);
 }
 
-uint8_t Memory::getFadeRate() {
-  return mData->fadeRate;
-}
-
 Status Memory::setFadeRate(uint8_t fadeRate) {
   return writeData8(DATA_FIELD_OFFSET(Data, fadeRate), fadeRate);
 }
@@ -156,45 +124,20 @@ Status Memory::setLevelForScene(uint8_t scene, uint8_t level) {
   return writeData8(DATA_FIELD_OFFSET(Data, scene[scene]), level);
 }
 
-uint16_t Memory::getGroups() {
-  return mData->groups;
-}
-
-uint8_t Memory::getGroupsL() {
-  return mData->groups;
-}
-
-uint8_t Memory::getGroupsH() {
-  return mData->groups >> 8;
-}
-
 Status Memory::setGroups(uint16_t groups) {
   return writeData16(DATA_FIELD_OFFSET(Data, groups), groups);
 }
 
-
-uint32_t Memory::getSearchAddr() {
-  return mRam.searchAddr;
-}
-
 Status Memory::setSearchAddr(uint32_t searchAddr) {
   mRam.searchAddr = searchAddr & LONG_ADDR_MASK;
   return Status::OK;
 }
 
-uint32_t Memory::getRandomAddr() {
-  return mTemp->randomAddr;
-}
-
 Status Memory::setRandomAddr(uint32_t randomAddr) {
   randomAddr &= LONG_ADDR_MASK;
   return writeTemp32(TEMP_FIELD_OFFSET(Temp, randomAddr), randomAddr);
 }
 
-uint8_t Memory::getActualLevel() {
-  return mTemp->actualLevel;
-}
-
 Status Memory::setActualLevel(uint8_t level) {
   return writeTemp8(TEMP_FIELD_OFFSET(Temp, actualLevel), level);
 }
diff --git a/src/dali/controller/memory.hpp b/src/dali/controller/memory.hpp
index 1bcff1c..94829ce 100644
--- a/src/dali/controller/memory.hpp
+++ b/src/dali/controller/memory.hpp
@@ -21,84 +21,61 @@ public:
   explicit Memory(IMemory* memory);
   virtual ~Memory() {};
 
-  uint8_t getDTR() {
-    return mRam.dtr;
-  }
-
-  void setDTR(uint8_t value) {
-    mRam.dtr = value;
-  }
-
-  uint8_t getDTR1() {
-    return mRam.dtr1;
-  }
-
-  void setDTR1(uint8_t value) {
-    mRam.dtr1 = value;
-  }
-
-  uint8_t getDTR2() {
-    return mRam.dtr2;
-  }
-
-  void setDTR2(uint8_t value) {
-    mRam.dtr2 = value;
-  }
+  uint8_t getDTR() { return mRam.dtr; }
+  void setDTR(uint8_t value) { mRam.dtr = value; }
+  uint8_t getDTR1() { return mRam.dtr1; }
+  void setDTR1(uint8_t value) {  mRam.dtr1 = value; }
+  uint8_t getDTR2() { return mRam.dtr2; }
+  void setDTR2(uint8_t value) {  mRam.dtr2 = value; }
 
   Status readMemory(uint8_t* data);
   Status writeMemory(uint8_t data);
 
-  uint8_t getPhisicalMinLevel();
+  uint8_t getPhisicalMinLevel() { return mData->phisicalMinLevel; }
   Status setPhisicalMinLevel(uint8_t level);
 
-  uint8_t getShortAddr();
+  uint8_t getShortAddr() { return mData->shortAddr; }
   Status setShortAddr(uint8_t addr);
 
-  uint8_t getMinLevel();
+  uint8_t getMinLevel() { return mData->minLevel; }
   Status setMinLevel(uint8_t level);
 
-  uint8_t getMaxLevel();
+  uint8_t getMaxLevel() { return mData->maxLevel; }
   Status setMaxLevel(uint8_t level);
 
-  uint8_t getPowerOnLevel();
+  uint8_t getPowerOnLevel() { return mData->powerOnLevel; }
   Status setPowerOnLevel(uint8_t level);
 
-  uint8_t getFaliureLevel();
+  uint8_t getFaliureLevel() { return mData->failureLevel; }
   Status setFaliureLevel(uint8_t level);
 
-  uint8_t getFadeTime();
+  uint8_t getFadeTime() { return mData->fadeTime; }
   Status setFadeTime(uint8_t fadeTime);
 
-  uint8_t getFadeRate();
+  uint8_t getFadeRate() { return mData->fadeRate; }
   Status setFadeRate(uint8_t fadeRate);
 
   uint8_t getLevelForScene(uint8_t scene);
   Status setLevelForScene(uint8_t scene, uint8_t level);
 
-  uint16_t getGroups();
-  uint8_t getGroupsL();
-  uint8_t getGroupsH();
+  uint16_t getGroups() { return mData->groups; }
   Status setGroups(uint16_t groups);
 
-  uint32_t getSearchAddr();
+  uint32_t getSearchAddr() { return mRam.searchAddr; }
   Status setSearchAddr(uint32_t searchAddr);
 
-  uint32_t getRandomAddr();
+  uint32_t getRandomAddr() { return mTemp->randomAddr; }
   Status setRandomAddr(uint32_t randomAddr);
 
-  uint8_t getActualLevel();
+  uint8_t getActualLevel() { return mTemp->actualLevel; }
   Status setActualLevel(uint8_t level);
 
-  virtual bool isValid() {
-    return isDataValid() && isTempValid();
-  }
+  virtual bool isValid() {  return isDataValid() && isTempValid(); }
 
   virtual bool isReset();
   virtual Status reset();
 
-  uint16_t uint16FromDtrAndDtr1() {
-    return ((uint16_t) mRam.dtr1 << 8) | mRam.dtr;
-  }
+  uint16_t uint16FromDtrAndDtr1() { return ((uint16_t) mRam.dtr1 << 8) | mRam.dtr; }
 
 protected:
 
diff --git a/src/dali/controller/query_store.cpp b/src/dali/controller/query_store.cpp
index f5c1552..9699924 100644
--- a/src/dali/controller/query_store.cpp
+++ b/src/dali/controller/query_store.cpp
@@ -159,46 +159,10 @@ uint8_t QueryStore::queryStatus() {
   return status;
 }
 
-bool QueryStore::queryLampFailure() {
-  return mLampController->isFailure();
-}
-
-bool QueryStore::queryLampPowerOn() {
-  return mLampController->isPowerOn();
-}
-
-bool QueryStore::queryLampLimitError() {
-  return mLampController->isLimitError();
-}
-
 bool QueryStore::queryIsFading() {
   return mLampController->isFading();
 }
 
-bool QueryStore::queryResetState() {
-  return mMemoryController->isReset();
-}
-
-bool QueryStore::queryMissingShortAddr() {
-  return mMemoryController->getShortAddr() == DALI_MASK;
-}
-
-bool QueryStore::queryLampPowerSet() {
-  return mLampController->isPowerSet();
-}
-
-uint8_t QueryStore::queryActualLevel() {
-  return mLampController->getLevel();
-}
-
-uint8_t QueryStore::queryMaxLevel() {
-  return mMemoryController->getMaxLevel();
-}
-
-uint8_t QueryStore::queryMinLevel() {
-  return mMemoryController->getMinLevel();
-}
-
 uint8_t QueryStore::queryPowerOnLevel() {
   return mMemoryController->getPowerOnLevel();
 }
@@ -218,11 +182,11 @@ uint8_t QueryStore::queryLevelForScene(uint8_t scene) {
 }
 
 uint8_t QueryStore::queryGroupsL() {
-  return mMemoryController->getGroupsL();
+  return mMemoryController->getGroups() & 0xff;
 }
 
 uint8_t QueryStore::queryGroupsH() {
-  return mMemoryController->getGroupsH();
+  return mMemoryController->getGroups() >> 8;
 }
 
 uint8_t QueryStore::queryRandomAddrH() {
@@ -237,9 +201,5 @@ uint8_t QueryStore::queryRandomAddrL() {
   return (uint8_t) ((mMemoryController->getRandomAddr() >> 0) & 0xff);
 }
 
-bool QueryStore::isMemoryValid() {
-  return mMemoryController->isValid();
-}
-
 } // namespace controller
 } // namespace dali
diff --git a/src/dali/controller/query_store.hpp b/src/dali/controller/query_store.hpp
index 444020c..f7557e7 100644
--- a/src/dali/controller/query_store.hpp
+++ b/src/dali/controller/query_store.hpp
@@ -37,16 +37,16 @@ public:
   Status removeFromGroup(uint8_t group);
   Status storeDtrAsShortAddr();
   uint8_t queryStatus();
-  bool queryLampFailure();
-  bool queryLampPowerOn();
-  bool queryLampLimitError();
+  bool queryLampFailure() { return mLampController->isFailure(); }
+  bool queryLampPowerOn() { return mLampController->isPowerOn(); }
+  bool queryLampLimitError() { return mLampController->isLimitError(); }
   virtual bool queryIsFading();
-  bool queryResetState();
-  bool queryMissingShortAddr();
-  bool queryLampPowerSet();
-  virtual uint8_t queryActualLevel();
-  uint8_t queryMaxLevel();
-  uint8_t queryMinLevel();
+  bool queryResetState() { return mMemoryController->isReset(); }
+  bool queryMissingShortAddr() { return mMemoryController->getShortAddr() == DALI_MASK; }
+  bool queryLampPowerSet() { return mLampController->isPowerSet(); }
+  virtual uint8_t queryActualLevel() { return mLampController->getLevel(); }
+  uint8_t queryMaxLevel() { return mMemoryController->getMaxLevel(); }
+  uint8_t queryMinLevel() { return mMemoryController->getMinLevel(); }
   virtual uint8_t queryPowerOnLevel();
   virtual uint8_t queryFaliureLevel();
   uint8_t queryFadeRateOrTime();
@@ -58,16 +58,11 @@ public:
   uint8_t queryRandomAddrL();
 
 protected:
-  Memory* const getMemoryController() {
-    return mMemoryController;
-  }
-
-  Lamp* const getLampController() {
-    return mLampController;
-  }
+  Memory* const getMemoryController() { return mMemoryController; }
+  Lamp* const getLampController() { return mLampController; }
 
 private:
-  bool isMemoryValid();
+  bool isMemoryValid() { return mMemoryController->isValid(); }
 
   QueryStore(const QueryStore& other) = delete;
   QueryStore& operator=(const QueryStore&) = delete;
diff --git a/src/dali/dali.hpp b/src/dali/dali.hpp
index 0882ebb..e2aa514 100644
--- a/src/dali/dali.hpp
+++ b/src/dali/dali.hpp
@@ -39,6 +39,9 @@
 
 namespace dali {
 
+typedef uint64_t Time;
+const Time kTimeInvalid = 0xffffffffffffffffUL;
+
 enum class Status {
   OK, ERROR, INVALID, INVALID_STATE, REPEAT_REQUIRED
 };
@@ -73,7 +76,7 @@ public:
   virtual void abortFading() = 0;
 };
 
-class IBus {
+class IBusDriver {
 public:
   enum class IBusState {
     UNKNOWN, DISCONNECTED, CONNECTED
@@ -81,7 +84,7 @@ public:
 
   class IBusClient {
   public:
-    virtual void onDataReceived(uint64_t timeMs, uint16_t data) = 0;
+    virtual void onDataReceived(Time time, uint16_t data) = 0;
     virtual void onBusStateChanged(IBusState state);
   };
 
@@ -97,7 +100,7 @@ public:
     virtual void timerTaskRun() = 0;
   };
 
-  virtual uint64_t getTime() = 0;
+  virtual Time getTime() = 0;
   virtual Status schedule(ITimerTask* task, uint32_t delay, uint32_t period) = 0;
   virtual void cancel(ITimerTask* task) = 0;
   virtual uint32_t randomize() = 0;
diff --git a/src/dali/slave.cpp b/src/dali/slave.cpp
index 655d9ed..0c5c3e1 100644
--- a/src/dali/slave.cpp
+++ b/src/dali/slave.cpp
@@ -13,30 +13,28 @@
 namespace dali {
 
 // static
-Slave* Slave::create(IMemory* memoryDriver, ILamp* lampDriver, IBus* busDriver, ITimer* timer) {
+Slave* Slave::create(IBusDriver* busDriver, ITimer* timer, IMemory* memoryDriver, ILamp* lampDriver) {
   controller::Memory* memory = new controller::Memory(memoryDriver);
   controller::Lamp* lamp = new controller::Lamp(lampDriver, memory);
   controller::QueryStore* queryStore = new controller::QueryStore(memory, lamp);
-  controller::Bus* bus = new controller::Bus(busDriver);
-  controller::Initialization* initialization = new controller::Initialization(timer, memory);
 
-  return new Slave(memory, lamp, queryStore, bus, initialization);
+  return new Slave(busDriver, timer, memory, lamp, queryStore);
 }
 
-Slave::Slave(controller::Memory* memory, controller::Lamp* lamp, controller::QueryStore* queryStore,
-    controller::Bus* bus, controller::Initialization* initialization) :
-    mMemoryController(memory), mLampController(lamp), mQueryStoreController(queryStore),
-    mBusController(bus), mInitializationController(initialization),
-    mMemoryWriteEnabled(false), mDeviceType(0xff) {
+Slave::Slave(IBusDriver* busDriver, ITimer* timer, controller::Memory* memory, controller::Lamp* lamp,
+    controller::QueryStore* queryStore) :
+    mBusController(busDriver, this),
+    mInitializationController(timer, memory),
+    mMemoryController(memory),
+    mLampController(lamp),
+    mQueryStoreController(queryStore),
+    mMemoryWriteEnabled(false),
+    mDeviceType(0xff) {
   mLampController->setListener(this);
-  mBusController->setListener(this);
 }
 
 Slave::~Slave() {
-  mBusController->setListener(nullptr);
   mLampController->setListener(nullptr);
-  delete mInitializationController;
-  delete mBusController;
   delete mQueryStoreController;
   delete mLampController;
   delete mMemoryController;
@@ -51,7 +49,7 @@ void Slave::notifyPowerDown() {
 }
 
 void Slave::onLampStateChnaged(ILamp::ILampState state) {
-  mInitializationController->onLampStateChnaged(state);
+  mInitializationController.onLampStateChnaged(state);
 }
 
 uint8_t Slave::getShortAddr() {
@@ -130,7 +128,7 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
     return mLampController->powerOnAndStepUp();
 
   case Command::ENABLE_DAPC_SEQUENCE:
-    return mLampController->enableDapcSequence(mBusController->getLastCommandTimeMs());
+    return mLampController->enableDapcSequence(mBusController.getLastCommandTime());
 
   case Command::GO_TO_SCENE_0:
   case Command::GO_TO_SCENE_1:
@@ -154,7 +152,7 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
     if (repeatCount == 0) {
       return Status::REPEAT_REQUIRED;
     }
-    mInitializationController->reset();
+    mInitializationController.reset();
     mQueryStoreController->reset();
     return Status::OK;
 
@@ -420,10 +418,10 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
     // extended commands
 
   case Command::DIRECT_POWER_CONTROL:
-    return mLampController->powerDirect(param, mBusController->getLastCommandTimeMs());
+    return mLampController->powerDirect(param, mBusController.getLastCommandTime());
 
   case Command::TERMINATE:
-    return mInitializationController->terminate();
+    return mInitializationController.terminate();
 
   case Command::DATA_TRANSFER_REGISTER:
     mMemoryController->setDTR(param);
@@ -433,53 +431,53 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
     if (repeatCount == 0) {
       return Status::REPEAT_REQUIRED;
     }
-    return mInitializationController->initialize(param);
+    return mInitializationController.initialize(param);
 
   case Command::RANDOMISE:
     if (repeatCount == 0) {
       return Status::REPEAT_REQUIRED;
     }
-    return mInitializationController->randomize();
+    return mInitializationController.randomize();
 
   case Command::COMPARE: {
-    Status status = mInitializationController->compare();
+    Status status = mInitializationController.compare();
     if (status == Status::OK) {
-      return mBusController->sendAck(DALI_ACK_YES);
+      return mBusController.sendAck(DALI_ACK_YES);
     }
     return status;
   }
   case Command::WITHDRAW:
-    return mInitializationController->withdraw();
+    return mInitializationController.withdraw();
 
   case Command::SEARCHADDRH:
-    return mInitializationController->searchAddrH(param);
+    return mInitializationController.searchAddrH(param);
 
   case Command::SEARCHADDRM:
-    return mInitializationController->searchAddrM(param);
+    return mInitializationController.searchAddrM(param);
 
   case Command::SEARCHADDRL:
-    return mInitializationController->searchAddrL(param);
+    return mInitializationController.searchAddrL(param);
 
   case Command::PROGRAM_SHORT_ADDRESS:
-    return mInitializationController->programShortAddr(param);
+    return mInitializationController.programShortAddr(param);
 
   case Command::VERIFY_SHORT_ADDRESS: {
-    Status status = mInitializationController->verifySortAddr(param);
+    Status status = mInitializationController.verifySortAddr(param);
     if (status == Status::OK) {
-      return mBusController->sendAck(DALI_ACK_YES);
+      return mBusController.sendAck(DALI_ACK_YES);
     }
     return status;
   }
   case Command::QUERY_SHORT_ADDRESS: {
     uint8_t shortAddr;
-    Status status = mInitializationController->queryShortAddr(&shortAddr);
+    Status status = mInitializationController.queryShortAddr(&shortAddr);
     if (status == Status::OK) {
-      return mBusController->sendAck(shortAddr);
+      return mBusController.sendAck(shortAddr);
     }
     return status;
   }
   case Command::PHYSICAL_SELECTION:
-    return mInitializationController->physicalSelection();
+    return mInitializationController.physicalSelection();
 
   case Command::DATA_TRANSFER_REGISTER_1:
     mMemoryController->setDTR1(param);
diff --git a/src/dali/slave.hpp b/src/dali/slave.hpp
index fe75090..a4c7c88 100644
--- a/src/dali/slave.hpp
+++ b/src/dali/slave.hpp
@@ -20,9 +20,10 @@
 
 namespace dali {
 
-class Slave: public controller::Bus::Listener, controller::Lamp::Listener {
+class Slave: public controller::Bus::Client, controller::Lamp::Listener
+{
 public:
-  static Slave* create(IMemory* memoryDriver, ILamp* lampDriver, IBus* busDriver, ITimer* timer);
+  static Slave* create(IBusDriver* busDriver, ITimer* timer, IMemory* memoryDriver, ILamp* lampDriver);
 
   virtual ~Slave();
 
@@ -30,8 +31,8 @@ public:
   void notifyPowerDown();
 
 protected:
-  Slave(controller::Memory* memory, controller::Lamp* lamp, controller::QueryStore* queryStore,
-        controller::Bus* busDriver, controller::Initialization* initializationController);
+  Slave(IBusDriver* busDriver, ITimer* timer, controller::Memory* memory, controller::Lamp* lamp,
+      controller::QueryStore* queryStore);
 
   controller::Memory* const getMemoryController() {
     return mMemoryController;
@@ -46,10 +47,10 @@ protected:
   }
 
   Status sendAck(uint8_t ack) {
-     return mBusController->sendAck(ack);
-   }
+    return mBusController.sendAck(ack);
+  }
 
-   virtual Status handleHandleDaliDeviceTypeCommand(uint16_t repeat, Command cmd, uint8_t param, uint8_t device_type);
+  virtual Status handleHandleDaliDeviceTypeCommand(uint16_t repeat, Command cmd, uint8_t param, uint8_t device_type);
 
 private:
   Slave(const Slave& other) = delete;
@@ -66,11 +67,11 @@ private:
   Status handleIgnoredCommand(Command cmd, uint8_t param) override;
   Status internalHandleDaliDT8Command(uint16_t repeat, Command cmd, uint8_t param);
 
+  controller::Bus mBusController;
+  controller::Initialization mInitializationController;
   controller::Memory* const mMemoryController;
   controller::Lamp* const mLampController;
   controller::QueryStore* const mQueryStoreController;
-  controller::Bus* const mBusController;
-  controller::Initialization* const mInitializationController;
   bool mMemoryWriteEnabled;
   uint8_t mDeviceType;
 };
diff --git a/src/xmc1200/bccu.cpp b/src/xmc1200/bccu.cpp
index 5e97acb..385f928 100644
--- a/src/xmc1200/bccu.cpp
+++ b/src/xmc1200/bccu.cpp
@@ -213,16 +213,4 @@ void BccuLampRGB::setColor(uint16_t r, uint16_t g, uint16_t b, uint32_t changeTi
   XMC_BCCU_ConcurrentStartLinearWalk(BCCU, mChannelsMask);
 }
 
-uint16_t BccuLampRGB::getColorR() {
-  return XMC_BCCU_CH_ReadIntensity(BCCU_CH_R);
-}
-
-uint16_t BccuLampRGB::getColorG() {
-  return XMC_BCCU_CH_ReadIntensity(BCCU_CH_G);
-}
-
-uint16_t BccuLampRGB::getColorB() {
-  return XMC_BCCU_CH_ReadIntensity(BCCU_CH_B);
-}
-
 } // namespace xmc
diff --git a/src/xmc1200/bccu.hpp b/src/xmc1200/bccu.hpp
index 7f917e6..e1939c3 100644
--- a/src/xmc1200/bccu.hpp
+++ b/src/xmc1200/bccu.hpp
@@ -68,9 +68,19 @@ public:
   }
 
   void setColor(uint16_t R, uint16_t G, uint16_t B, uint32_t changeTime);
-  uint16_t getColorR();
-  uint16_t getColorG();
-  uint16_t getColorB();
+
+  uint16_t getColorR() {
+    return XMC_BCCU_CH_ReadIntensity(BCCU_CH_R);
+  }
+
+  uint16_t getColorG() {
+    return XMC_BCCU_CH_ReadIntensity(BCCU_CH_G);
+  }
+
+  uint16_t getColorB() {
+    return XMC_BCCU_CH_ReadIntensity(BCCU_CH_B);
+  }
+
 
 private:
   BCCU_CH_Type* BCCU_CH_R;
diff --git a/src/xmc1200/clock.hpp b/src/xmc1200/clock.hpp
index 51b48a9..c75ebba 100644
--- a/src/xmc1200/clock.hpp
+++ b/src/xmc1200/clock.hpp
@@ -23,8 +23,6 @@ public:
     FREQ_16MHZ = 0x02,
     FREQ_10_67MHZ = 0x03,
     FREQ_8MHZ = 0x04,
-    FREQ_126KHZ = 0xFE,
-    FREQ_125_5KHZ = 0xFF,
   } Frequency;
 
   // Initializes SCU Clock registers based on user configuration
diff --git a/src/xmc1200/dali/bus.cpp b/src/xmc1200/dali/bus.cpp
index d51e6fb..787dd8b 100644
--- a/src/xmc1200/dali/bus.cpp
+++ b/src/xmc1200/dali/bus.cpp
@@ -45,17 +45,15 @@ volatile RxState gRxState;
 volatile uint32_t gRxData32 = INVALID32;
 volatile uint32_t gRxDataTmp;
 uint16_t gTxData = INVALID16;
-volatile uint64_t gBusLowTime = 0;
-
-#define BUS_TIME_CONNECTED 0xffffffffffffffffUL
+volatile Time gBusLowTime = 0;
 
 #define MAX_CLIENTS 1
 
-IBus::IBusState gBusState = IBus::IBusState::UNKNOWN;
-IBus::IBusClient* gClients[MAX_CLIENTS];
+IBusDriver::IBusState gBusState = IBusDriver::IBusState::UNKNOWN;
+IBusDriver::IBusClient* gClients[MAX_CLIENTS];
 
 void onRisingEdge(uint16_t timer) {
-  gBusLowTime = BUS_TIME_CONNECTED;
+  gBusLowTime = kTimeInvalid;
 
   if (timer == 0) {
     return;
@@ -218,20 +216,20 @@ Status Bus::sendAck(uint8_t ack) {
 
 void Bus::runSlice() {
   uint16_t data;
-  uint64_t time = Timer::getTimeMs();
+  Time time = Timer::getTimeMs();
 
   __disable_irq();
-  uint64_t busLowTime = gBusLowTime;
+  Time busLowTime = gBusLowTime;
   __enable_irq();
 
-  if (busLowTime == BUS_TIME_CONNECTED) {
-    if (gBusState != IBus::IBusState::CONNECTED) {
-      onBusStateChanged(IBus::IBusState::CONNECTED);
+  if (busLowTime == kTimeInvalid) {
+    if (gBusState != IBusDriver::IBusState::CONNECTED) {
+      onBusStateChanged(IBusDriver::IBusState::CONNECTED);
     }
   } else {
     if (time - busLowTime >= 500) {
-      if (gBusState != IBus::IBusState::DISCONNECTED) {
-        onBusStateChanged(IBus::IBusState::DISCONNECTED);
+      if (gBusState != IBusDriver::IBusState::DISCONNECTED) {
+        onBusStateChanged(IBusDriver::IBusState::DISCONNECTED);
       }
     }
   }
@@ -242,7 +240,7 @@ void Bus::runSlice() {
 }
 
 // static
-void Bus::onDataReceived(uint64_t time, uint16_t data) {
+void Bus::onDataReceived(Time time, uint16_t data) {
   for (uint8_t i = 0; i < MAX_CLIENTS; ++i) {
     if (gClients[i] != nullptr) {
       gClients[i]->onDataReceived(time, data);
@@ -298,8 +296,8 @@ void Bus::initRx() {
 }
 
 //static
-bool Bus::checkRxTx(uint64_t time, uint16_t* data) {
-  static uint64_t gLastDataTime = 0;
+bool Bus::checkRxTx(Time time, uint16_t* data) {
+  static Time gLastDataTime = 0;
   bool rxResult = false;
   __disable_irq();
   uint32_t rxData32 = gRxData32;
@@ -313,7 +311,7 @@ bool Bus::checkRxTx(uint64_t time, uint16_t* data) {
   }
 
   if (gTxData != INVALID16) {
-    uint64_t dTime = time - gLastDataTime;
+    Time dTime = time - gLastDataTime;
     if (dTime > 3) {
       if (gRxState == RxState::IDLE) {
         uint16_t tmpTxData = gTxData;
diff --git a/src/xmc1200/dali/bus.hpp b/src/xmc1200/dali/bus.hpp
index e19a15e..85322af 100644
--- a/src/xmc1200/dali/bus.hpp
+++ b/src/xmc1200/dali/bus.hpp
@@ -16,7 +16,7 @@
 namespace dali {
 namespace xmc {
 
-class Bus: public dali::IBus {
+class Bus: public dali::IBusDriver {
 public:
   static Bus* getInstance();
 
@@ -33,11 +33,11 @@ private:
 
   ~Bus();
 
-  static void onDataReceived(uint64_t timeMs, uint16_t data);
+  static void onDataReceived(Time timeMs, uint16_t data);
   static void onBusStateChanged(IBusState state);
 
   static void initRx();
-  static bool checkRxTx(uint64_t time, uint16_t* data);
+  static bool checkRxTx(Time time, uint16_t* data);
 
   static void initTx();
   static void tx(uint8_t data);
diff --git a/src/xmc1200/dali/lamp.cpp b/src/xmc1200/dali/lamp.cpp
index 04feb93..bc01bd5 100644
--- a/src/xmc1200/dali/lamp.cpp
+++ b/src/xmc1200/dali/lamp.cpp
@@ -112,12 +112,6 @@ void LampRGB::abortFading() {
   }
 }
 
-void LampRGB::waitForFade() {
-  while (mLamp.isFading()) {
-  }
-}
-
-
 void LampRGB::setPrimary(const uint16_t primary[], uint8_t size, uint32_t changeTime) {
   for (uint8_t i = 0; i < 3; ++i) {
     mPrimary[i] = primary[i];
@@ -150,10 +144,6 @@ void LampRGB::abortColorChanging() {
   }
 }
 
-void LampRGB::waitForColorChange() {
-  while (mLamp.isColorChanging()) {
-  }
-}
 
 void LampRGB::onLampStateChnaged(ILampState state) {
   for (uint16_t i = 0; i < kMaxClients; ++i) {
diff --git a/src/xmc1200/dali/lamp.hpp b/src/xmc1200/dali/lamp.hpp
index 67eea2c..5a421f3 100644
--- a/src/xmc1200/dali/lamp.hpp
+++ b/src/xmc1200/dali/lamp.hpp
@@ -28,13 +28,13 @@ public:
   uint16_t getLevel() override;
   bool isFading() override;
   void abortFading() override;
-  void waitForFade();
+  void waitForFade() { while (mLamp.isFading()); }
 
   void setPrimary(const uint16_t primary[], uint8_t size, uint32_t changeTime) override;
   void getPrimary(uint16_t primary[], uint8_t size) override;
   bool isColorChanging() override;
   void abortColorChanging() override;
-  void waitForColorChange();
+  void waitForColorChange() { while (mLamp.isColorChanging()); };
 
   bool isOff() {
     return getLevel() == 0;
diff --git a/src/xmc1200/dali/timer.cpp b/src/xmc1200/dali/timer.cpp
index 1f9466f..61b101a 100644
--- a/src/xmc1200/dali/timer.cpp
+++ b/src/xmc1200/dali/timer.cpp
@@ -24,12 +24,12 @@ const uint16_t* kUniqeChipId = (uint16_t*) 0x10000FF0; // 8 elements
 
 typedef struct {
   dali::ITimer::ITimerTask* task;
-  uint64_t time;
+  Time time;
   uint32_t period;
 } TaskInfo;
 
 TaskInfo gTasks[MAX_TASKS];
-volatile uint64_t gSystemTimeMs;
+volatile Time gSystemTimeMs;
 
 }
 
@@ -85,7 +85,7 @@ uint32_t Timer::randomize() {
 }
 
 // static
-uint64_t Timer::getTimeMs() {
+Time Timer::getTimeMs() {
   return gSystemTimeMs;
 }
 
@@ -110,7 +110,7 @@ void Timer::runSlice() {
 extern "C" {
 
 void SysTick_Handler(void) {
-  gSystemTimeMs += 1000 / TICKS_PER_SECOND;
+  gSystemTimeMs += (uint32_t)1000 / TICKS_PER_SECOND;
 }
 
 } // extern "C"
diff --git a/src/xmc1200/dali/timer.hpp b/src/xmc1200/dali/timer.hpp
index 0963b5f..4d3801a 100644
--- a/src/xmc1200/dali/timer.hpp
+++ b/src/xmc1200/dali/timer.hpp
@@ -20,14 +20,14 @@ class Timer: public dali::ITimer {
 public:
   static Timer* getInstance();
 
-  uint64_t getTime() override {
+  Time getTime() override {
     return getTimeMs();
   }
   dali::Status schedule(ITimerTask* task, uint32_t delay, uint32_t period) override;
   void cancel(ITimerTask* task) override;
   uint32_t randomize() override;
 
-  static uint64_t getTimeMs();
+  static Time getTimeMs();
   static void runSlice();
 
 private:
diff --git a/src/xmc1200/main.cpp b/src/xmc1200/main.cpp
index 7c3f82b..81c64cc 100644
--- a/src/xmc1200/main.cpp
+++ b/src/xmc1200/main.cpp
@@ -76,7 +76,7 @@ int main(void) {
 
   dali::xmc::Memory* daliMemory1 = dali::xmc::Memory::getInstance();
   dali::xmc::LampRGB* daliLamp1 = dali::xmc::LampRGB::getInstance();
-  gSlave = dali::SlaveDT8::create(daliMemory1, daliLamp1, daliBus, daliTimer);
+  gSlave = dali::SlaveDT8::create(daliBus, daliTimer, daliMemory1, daliLamp1);
 
   daliTimer->schedule(&gPowerOnTimerTask, 600, 0);