Peter M. Groen / dali_slave

Commit 4eb18d499dfcb7bdc0a50fa9ff8378a19e0d0a11

Authored by Arkadiusz Materek
1 parent f2151106

Optimize, Clean up, Refactor

Inline Side-by-side
Showing 23 changed files with 241 additions and 403 deletions
src/dali/controller/bus.cpp
  View file @4eb18d4
... ... @@ -16,17 +16,17 @@ namespace dali {
16 16 namespace controller {
17 17 namespace {
18 18  
19   -const uint64_t kCommandRepeatTimeout = 100;
  19 +const Time kCommandRepeatTimeout = 100;
20 20  
21 21 }
22 22  
23   -Bus::Bus(IBus* bus) :
  23 +Bus::Bus(IBusDriver* bus, Client* client) :
24 24 mBus(bus),
25   - mState(IBus::IBusState::UNKNOWN),
26   - mListener(nullptr),
  25 + mClient(client),
  26 + mState(IBusDriver::IBusState::UNKNOWN),
27 27 mLastCommand(Command::INVALID),
28 28 mCommandRepeatCount(0),
29   - mLastCommandTimeMs(0) {
  29 + mLastCommandTime(0) {
30 30 mBus->registerClient(this);
31 31 }
32 32  
... ... @@ -34,138 +34,128 @@ Bus::~Bus() {
34 34 mBus->unregisterClient(this);
35 35 }
36 36  
37   -void Bus::setListener(Listener* listener) {
38   - mListener = listener;
39   -}
  37 +void Bus::onDataReceived(Time time, uint16_t data) {
40 38  
41   -void Bus::onDataReceived(uint64_t timeMs, uint16_t data) {
42   - Command command;
43 39 uint8_t param;
44   - if (filterAddress(data, &command, &param) != Status::OK) {
45   - return; // Status::INVALID;
  40 + Command command = extractCommand(data, &param);
  41 + if (command == Command::INVALID) {
  42 + return;
46 43 }
47   - if (command != Command::INVALID) { // should be always true
48   - if (mLastCommand == Command::INVALID) {
  44 + if (mLastCommand == Command::INVALID) {
  45 + mCommandRepeatCount = 0;
  46 + mLastCommandTime = time;
  47 + Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
  48 + if (status == Status::REPEAT_REQUIRED) {
  49 + mLastCommand = command;
  50 + return;
  51 + } else {
  52 + mLastCommand = Command::INVALID;
  53 + return;
  54 + }
  55 + } else if (mLastCommand == command) {
  56 + if (time - mLastCommandTime < kCommandRepeatTimeout) {
  57 + mCommandRepeatCount++;
  58 + } else {
  59 + mLastCommand = Command::INVALID;
49 60 mCommandRepeatCount = 0;
50   - mLastCommandTimeMs = timeMs;
51   - Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
52   - if (status == Status::REPEAT_REQUIRED) {
53   - mLastCommand = command;
54   - return; // Status::OK;
55   - } else {
56   - mLastCommand = Command::INVALID;
57   - return; // status;
58   - }
59   - } else if (mLastCommand == command) {
60   - if (timeMs - mLastCommandTimeMs < kCommandRepeatTimeout) {
61   - mCommandRepeatCount++;
62   - } else {
63   - mLastCommand = Command::INVALID;
64   - mCommandRepeatCount = 0;
65   - }
66   - mLastCommandTimeMs = timeMs;
67   - Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
  61 + }
  62 + mLastCommandTime = time;
  63 + Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
  64 + if (status == Status::REPEAT_REQUIRED) {
  65 + mLastCommand = command;
  66 + return;
  67 + } else {
  68 + mLastCommand = Command::INVALID;
  69 + return;
  70 + }
  71 + } else { // (mLastCommand != Command::INVALID) || (mLastCommand != cmd)
  72 + mLastCommand = Command::INVALID;
  73 + mCommandRepeatCount = 0;
  74 + mLastCommandTime = time;
  75 + if (time - mLastCommandTime < kCommandRepeatTimeout) {
  76 + mClient->handleIgnoredCommand(command, param);
  77 + } else {
  78 + Status status = mClient->handleCommand(mCommandRepeatCount, command, param);
68 79 if (status == Status::REPEAT_REQUIRED) {
69 80 mLastCommand = command;
70   - return; // Status::OK;
71   - } else {
72   - mLastCommand = Command::INVALID;
73   - return; // status;
74   - }
75   - } else { // (mLastCommand != Command::INVALID) || (mLastCommand != cmd)
76   - mLastCommand = Command::INVALID;
77   - mCommandRepeatCount = 0;
78   - if (timeMs - mLastCommandTimeMs < kCommandRepeatTimeout) {
79   - mLastCommandTimeMs = timeMs;
80   - mListener->handleIgnoredCommand(command, param);
  81 + return;
81 82 } else {
82   - mLastCommandTimeMs = timeMs;
83   - Status status = mListener->handleCommand(mCommandRepeatCount, command, param);
84   - if (status == Status::REPEAT_REQUIRED) {
85   - mLastCommand = command;
86   - return; // Status::OK;
87   - } else {
88   - return; // status;
89   - }
  83 + return;
90 84 }
91 85 }
92 86 }
93   - return; // Status::INVALID;
94 87 }
95 88  
96   -void Bus::onBusStateChanged(IBus::IBusState state) {
  89 +void Bus::onBusStateChanged(IBusDriver::IBusState state) {
97 90 if (mState != state) {
98 91 mState = state;
99   - if (state == IBus::IBusState::DISCONNECTED) {
100   - mListener->onBusDisconnected();
  92 + if (state == IBusDriver::IBusState::DISCONNECTED) {
  93 + mClient->onBusDisconnected();
101 94 }
102 95 }
103 96 }
104 97  
105   -Status Bus::sendAck(uint8_t ack) {
106   - return mBus->sendAck(ack);
107   -}
108   -
109   -Status Bus::filterAddress(uint16_t data, Command* command, uint8_t* param) {
110   - *param = (uint8_t) (data & 0xff);
111   - *command = Command::INVALID;
  98 +Command Bus::extractCommand(uint16_t data, uint8_t* commandParam) {
  99 + Command command = Command::INVALID;
  100 + uint8_t param = (uint8_t) (data & 0xff);
112 101 uint8_t addr = (uint8_t) (data >> 8);
113 102 bool cmdBitSet = ((addr & 0x01) != 0);
114 103 if ((addr & 0xfe) == 0xfe) {
115 104 // Broadcast
116 105 if (cmdBitSet) {
117   - *command = (Command) *param;
118   - *param = 0xff;
  106 + command = (Command) param;
  107 + param = 0xff;
119 108 } else {
120   - *command = Command::DIRECT_POWER_CONTROL;
  109 + command = Command::DIRECT_POWER_CONTROL;
121 110 }
122 111 } else if ((addr & 0x80) == 0) {
123 112 // Short address
124 113 addr >>= 1;
125   - uint8_t myAddr = mListener->getShortAddr() >> 1;
  114 + uint8_t myAddr = mClient->getShortAddr() >> 1;
126 115 if (cmdBitSet) {
127   - *command = (Command) *param;
128   - *param = 0xff;
  116 + command = (Command) param;
  117 + param = 0xff;
129 118 } else {
130   - *command = Command::DIRECT_POWER_CONTROL;
  119 + command = Command::DIRECT_POWER_CONTROL;
131 120 }
132 121 if (addr != myAddr) {
133   - return Status::INVALID;
  122 + return Command::INVALID;
134 123 }
135 124 } else if ((addr & 0x60) == 0) {
136 125 // Group address
137 126 uint8_t group = (addr >> 1) & 0x0f;
138   - uint16_t groups = mListener->getGroups();
  127 + uint16_t groups = mClient->getGroups();
139 128 if (cmdBitSet) {
140   - *command = (Command) *param;
141   - *param = 0xff;
  129 + command = (Command) param;
  130 + param = 0xff;
142 131 } else {
143   - *command = Command::DIRECT_POWER_CONTROL;
  132 + command = Command::DIRECT_POWER_CONTROL;
144 133 }
145 134 if ((groups & (1 << group)) == 0) {
146   - return Status::INVALID;
  135 + return Command::INVALID;
147 136 }
148 137 } else {
149   - *command = (Command) ((uint16_t) Command::_SPECIAL_COMMAND + addr);
150   - if (*command == Command::INITIALISE) {
151   - uint8_t myAddr = mListener->getShortAddr() >> 1;
152   - switch (*param) {
  138 + command = (Command) ((uint16_t) Command::_SPECIAL_COMMAND + addr);
  139 + if (command == Command::INITIALISE) {
  140 + uint8_t myAddr = mClient->getShortAddr() >> 1;
  141 + switch (param) {
153 142 case 0x00: // All control gear shall react
154 143 break;
155 144 case 0xff: // Control gear without short address shall react
156 145 if (myAddr <= DALI_ADDR_MAX) {
157   - return Status::INVALID;
  146 + return Command::INVALID;
158 147 }
159 148 break;
160 149 default: // Control gear with the address AAAAAAb shall react
161   - if (myAddr != (*param >> 1)) {
162   - return Status::INVALID;
  150 + if (myAddr != (param >> 1)) {
  151 + return Command::INVALID;
163 152 }
164 153 break;
165 154 }
166 155 }
167 156 }
168   - return Status::OK;
  157 + *commandParam = param;
  158 + return command;
169 159 }
170 160  
171 161 } // namespace controller
... ...
src/dali/controller/bus.hpp
  View file @4eb18d4
... ... @@ -16,10 +16,10 @@
16 16 namespace dali {
17 17 namespace controller {
18 18  
19   -class Bus: public IBus::IBusClient {
  19 +class Bus: public IBusDriver::IBusClient {
20 20 public:
21 21  
22   - class Listener {
  22 + class Client {
23 23 public:
24 24 virtual uint8_t getShortAddr() = 0;
25 25 virtual uint16_t getGroups() = 0;
... ... @@ -28,31 +28,27 @@ public:
28 28 virtual void onBusDisconnected() = 0;
29 29 };
30 30  
31   - explicit Bus(IBus* bus);
  31 + explicit Bus(IBusDriver* bus, Client* client);
32 32 virtual ~Bus();
33 33  
34   - void setListener(Listener* listener);
  34 + Status sendAck(uint8_t ack) { return mBus->sendAck(ack); }
  35 + Time getLastCommandTime() { return mLastCommandTime; }
35 36  
36   - void onDataReceived(uint64_t timeMs, uint16_t data) override;
37   - void onBusStateChanged(IBus::IBusState state) override;
38   -
39   - Status sendAck(uint8_t ack);
40   - uint64_t getLastCommandTimeMs() {
41   - return mLastCommandTimeMs;
42   - }
  37 + void onDataReceived(Time time, uint16_t data) override;
  38 + void onBusStateChanged(IBusDriver::IBusState state) override;
43 39  
44 40 private:
45 41 Bus(const Bus& other) = delete;
46 42 Bus& operator=(const Bus&) = delete;
47 43  
48   - Status filterAddress(uint16_t data, Command* command, uint8_t* param);
  44 + Command extractCommand(uint16_t data, uint8_t* param);
49 45  
50   - IBus* const mBus;
51   - IBus::IBusState mState;
52   - Listener* mListener;
  46 + IBusDriver* const mBus;
  47 + Client* mClient;
  48 + IBusDriver::IBusState mState;
53 49 Command mLastCommand;
54 50 uint16_t mCommandRepeatCount;
55   - uint64_t mLastCommandTimeMs;
  51 + Time mLastCommandTime;
56 52 };
57 53  
58 54 } // namespace controller
... ...
src/dali/controller/initialization.hpp
  View file @4eb18d4
... ... @@ -56,7 +56,7 @@ private:
56 56  
57 57 ITimer* const mTimer;
58 58 Memory* const mMemoryController;
59   - uint64_t mInitializeTime;
  59 + Time mInitializeTime;
60 60 bool mInitialized;
61 61 bool mWithdraw;
62 62 Selection mSelected;
... ...
src/dali/controller/lamp.cpp
  View file @4eb18d4
... ... @@ -40,10 +40,6 @@ void Lamp::onReset() {
40 40 mIsPowerSet = true;
41 41 }
42 42  
43   -bool Lamp::isPowerOn() {
44   - return (mLamp->getLevel() > 0);
45   -}
46   -
47 43 bool Lamp::isFailure() {
48 44 switch (mLampState) {
49 45 case ILamp::ILampState::DISCONNECTED:
... ... @@ -54,18 +50,6 @@ bool Lamp::isFailure() {
54 50 }
55 51 }
56 52  
57   -bool Lamp::isFading() {
58   - return mLamp->isFading();
59   -}
60   -
61   -bool Lamp::isLimitError() {
62   - return mLimitError;
63   -}
64   -
65   -bool Lamp::isPowerSet() {
66   - return mIsPowerSet;
67   -}
68   -
69 53 uint8_t Lamp::getLevel() {
70 54 if ((mMode == Mode::NORMAL) && (mLampState == ILamp::ILampState::OK)) {
71 55 return driver2level(mLamp->getLevel(), mMemoryController->getMinLevel());
... ... @@ -115,15 +99,7 @@ Status Lamp::abortFading() {
115 99 return Status::OK;
116 100 }
117 101  
118   -void Lamp::setListener(Listener* listener) {
119   - mListener = listener;
120   -}
121   -
122   -void Lamp::notifyPowerDown() {
123   - mLamp->setLevel(0, 0);
124   -}
125   -
126   -Status Lamp::powerDirect(uint8_t level, uint64_t time) {
  102 +Status Lamp::powerDirect(uint8_t level, Time time) {
127 103 if (level == DALI_MASK) {
128 104 mLamp->abortFading();
129 105 return Status::OK;
... ... @@ -259,12 +235,12 @@ Status Lamp::powerRecallFaliureLevel() {
259 235 return setLevel(level, 0);
260 236 }
261 237  
262   -Status Lamp::enableDapcSequence(uint64_t time) {
  238 +Status Lamp::enableDapcSequence(Time time) {
263 239 mDapcTime = time;
264 240 return Status::OK;
265 241 }
266 242  
267   -Status Lamp::dapcSequence(uint8_t level, uint64_t time) {
  243 +Status Lamp::dapcSequence(uint8_t level, Time time) {
268 244 onPowerCommand();
269 245 mDapcTime = time;
270 246 uint8_t actualLevel = getLevel();
... ...
src/dali/controller/lamp.hpp
  View file @4eb18d4
... ... @@ -31,24 +31,26 @@ public:
31 31  
32 32 // >>> used only in controller namespace
33 33 void onReset();
34   - bool isPowerOn();
  34 + bool isPowerOn() { return (mLamp->getLevel() > 0); }
35 35 bool isFailure();
36   - bool isFading();
37   - bool isLimitError();
38   - bool isPowerSet();
  36 + bool isFading() { return mLamp->isFading(); }
  37 + bool isLimitError() { return mLimitError; }
  38 + bool isPowerSet() { return mIsPowerSet; }
39 39  
40 40 uint8_t getLevel();
41 41 Status setLevel(uint8_t level, uint32_t fadeTime);
  42 +
42 43 uint32_t getFadeTime();
43 44 uint32_t getFadeRate();
44 45  
45 46 Status abortFading();
46 47 // <<< used only in controller namespace
47 48  
48   - void setListener(Listener* listener);
49   - void notifyPowerDown();
  49 + void setListener(Listener* listener) { mListener = listener; }
  50 +
  51 + void notifyPowerDown() { mLamp->setLevel(0, 0); }
50 52  
51   - virtual Status powerDirect(uint8_t level, uint64_t time);
  53 + virtual Status powerDirect(uint8_t level, Time time);
52 54 virtual Status powerOff();
53 55 virtual Status powerScene(uint8_t scene);
54 56 virtual Status powerUp();
... ... @@ -61,16 +63,12 @@ public:
61 63 virtual Status powerRecallMaxLevel();
62 64 virtual Status powerRecallOnLevel();
63 65 virtual Status powerRecallFaliureLevel();
64   - Status enableDapcSequence(uint64_t time);
  66 + Status enableDapcSequence(Time time);
65 67  
66 68 protected:
67   - ILamp* const getLamp() {
68   - return mLamp;
69   - }
  69 + ILamp* const getLamp() { return mLamp; }
  70 + Memory* const getMemoryController() { return mMemoryController; }
70 71  
71   - Memory* const getMemoryController() {
72   - return mMemoryController;
73   - }
74 72 enum class Mode {
75 73 NORMAL,
76 74 CONSTANT_POWER,
... ... @@ -82,7 +80,7 @@ private:
82 80 Lamp(const Lamp& other) = delete;
83 81 Lamp& operator=(const Lamp&) = delete;
84 82  
85   - Status dapcSequence(uint8_t level, uint64_t time);
  83 + Status dapcSequence(uint8_t level, Time time);
86 84  
87 85 void onPowerCommand();
88 86  
... ... @@ -96,7 +94,7 @@ private:
96 94 Listener* mListener;
97 95 bool mIsPowerSet;
98 96 bool mLimitError;
99   - uint64_t mDapcTime;
  97 + Time mDapcTime;
100 98 uint8_t mConstPower;
101 99 };
102 100  
... ...
src/dali/controller/lamp_helper.cpp
  View file @4eb18d4
... ... @@ -295,7 +295,24 @@ const uint32_t kFadeTime[16] = { // fade times from 0 to 254 in milliseconds
295 295 90510, // 15
296 296 };
297 297  
298   -const uint8_t kStepsFor200FadeRate[16] = { 1, 72, 51, 36, 25, 18, 13, 9, 6, 4, 3, 2, 2, 1, 1, 1 };
  298 +const uint8_t kStepsFor200FadeRate[16] = {
  299 + 1, // 0
  300 + 72, // 1
  301 + 51, // 2
  302 + 36, // 3
  303 + 25, // 4
  304 + 18, // 5
  305 + 13, // 6
  306 + 9, // 7
  307 + 6, // 8
  308 + 4, // 9
  309 + 3, // 10
  310 + 2, // 11
  311 + 2, // 12
  312 + 1, // 13
  313 + 1, // 14
  314 + 1 // 15
  315 +};
299 316  
300 317 uint16_t level2driver(uint8_t level) {
301 318 return kLevel2driver[level];
... ...
src/dali/controller/memory.cpp
  View file @4eb18d4
... ... @@ -77,67 +77,35 @@ Status Memory::writeMemory(uint8_t data) {
77 77 return status;
78 78 }
79 79  
80   -uint8_t Memory::getPhisicalMinLevel() {
81   - return mData->phisicalMinLevel;
82   -}
83   -
84 80 Status Memory::setPhisicalMinLevel(uint8_t level) {
85 81 return writeData8(DATA_FIELD_OFFSET(Data, phisicalMinLevel), level);
86 82 }
87 83  
88   -uint8_t Memory::getShortAddr() {
89   - return mData->shortAddr;
90   -}
91   -
92 84 Status Memory::setShortAddr(uint8_t addr) {
93 85 addr |= 0x01; // normalize address
94 86 return writeData8(DATA_FIELD_OFFSET(Data, shortAddr), addr);
95 87 }
96 88  
97   -uint8_t Memory::getMinLevel() {
98   - return mData->minLevel;
99   -}
100   -
101 89 Status Memory::setMinLevel(uint8_t level) {
102 90 return writeData8(DATA_FIELD_OFFSET(Data, minLevel), level);
103 91 }
104 92  
105   -uint8_t Memory::getMaxLevel() {
106   - return mData->maxLevel;
107   -}
108   -
109 93 Status Memory::setMaxLevel(uint8_t level) {
110 94 return writeData8(DATA_FIELD_OFFSET(Data, maxLevel), level);
111 95 }
112 96  
113   -uint8_t Memory::getPowerOnLevel() {
114   - return mData->powerOnLevel;
115   -}
116   -
117 97 Status Memory::setPowerOnLevel(uint8_t level) {
118 98 return writeData8(DATA_FIELD_OFFSET(Data, powerOnLevel), level);
119 99 }
120 100  
121   -uint8_t Memory::getFaliureLevel() {
122   - return mData->failureLevel;
123   -}
124   -
125 101 Status Memory::setFaliureLevel(uint8_t level) {
126 102 return writeData8(DATA_FIELD_OFFSET(Data, failureLevel), level);
127 103 }
128 104  
129   -uint8_t Memory::getFadeTime() {
130   - return mData->fadeTime;
131   -}
132   -
133 105 Status Memory::setFadeTime(uint8_t fadeTime) {
134 106 return writeData8(DATA_FIELD_OFFSET(Data, fadeTime), fadeTime);
135 107 }
136 108  
137   -uint8_t Memory::getFadeRate() {
138   - return mData->fadeRate;
139   -}
140   -
141 109 Status Memory::setFadeRate(uint8_t fadeRate) {
142 110 return writeData8(DATA_FIELD_OFFSET(Data, fadeRate), fadeRate);
143 111 }
... ... @@ -156,45 +124,20 @@ Status Memory::setLevelForScene(uint8_t scene, uint8_t level) {
156 124 return writeData8(DATA_FIELD_OFFSET(Data, scene[scene]), level);
157 125 }
158 126  
159   -uint16_t Memory::getGroups() {
160   - return mData->groups;
161   -}
162   -
163   -uint8_t Memory::getGroupsL() {
164   - return mData->groups;
165   -}
166   -
167   -uint8_t Memory::getGroupsH() {
168   - return mData->groups >> 8;
169   -}
170   -
171 127 Status Memory::setGroups(uint16_t groups) {
172 128 return writeData16(DATA_FIELD_OFFSET(Data, groups), groups);
173 129 }
174 130  
175   -
176   -uint32_t Memory::getSearchAddr() {
177   - return mRam.searchAddr;
178   -}
179   -
180 131 Status Memory::setSearchAddr(uint32_t searchAddr) {
181 132 mRam.searchAddr = searchAddr & LONG_ADDR_MASK;
182 133 return Status::OK;
183 134 }
184 135  
185   -uint32_t Memory::getRandomAddr() {
186   - return mTemp->randomAddr;
187   -}
188   -
189 136 Status Memory::setRandomAddr(uint32_t randomAddr) {
190 137 randomAddr &= LONG_ADDR_MASK;
191 138 return writeTemp32(TEMP_FIELD_OFFSET(Temp, randomAddr), randomAddr);
192 139 }
193 140  
194   -uint8_t Memory::getActualLevel() {
195   - return mTemp->actualLevel;
196   -}
197   -
198 141 Status Memory::setActualLevel(uint8_t level) {
199 142 return writeTemp8(TEMP_FIELD_OFFSET(Temp, actualLevel), level);
200 143 }
... ...
src/dali/controller/memory.hpp
  View file @4eb18d4
... ... @@ -21,84 +21,61 @@ public:
21 21 explicit Memory(IMemory* memory);
22 22 virtual ~Memory() {};
23 23  
24   - uint8_t getDTR() {
25   - return mRam.dtr;
26   - }
27   -
28   - void setDTR(uint8_t value) {
29   - mRam.dtr = value;
30   - }
31   -
32   - uint8_t getDTR1() {
33   - return mRam.dtr1;
34   - }
35   -
36   - void setDTR1(uint8_t value) {
37   - mRam.dtr1 = value;
38   - }
39   -
40   - uint8_t getDTR2() {
41   - return mRam.dtr2;
42   - }
43   -
44   - void setDTR2(uint8_t value) {
45   - mRam.dtr2 = value;
46   - }
  24 + uint8_t getDTR() { return mRam.dtr; }
  25 + void setDTR(uint8_t value) { mRam.dtr = value; }
  26 + uint8_t getDTR1() { return mRam.dtr1; }
  27 + void setDTR1(uint8_t value) { mRam.dtr1 = value; }
  28 + uint8_t getDTR2() { return mRam.dtr2; }
  29 + void setDTR2(uint8_t value) { mRam.dtr2 = value; }
47 30  
48 31 Status readMemory(uint8_t* data);
49 32 Status writeMemory(uint8_t data);
50 33  
51   - uint8_t getPhisicalMinLevel();
  34 + uint8_t getPhisicalMinLevel() { return mData->phisicalMinLevel; }
52 35 Status setPhisicalMinLevel(uint8_t level);
53 36  
54   - uint8_t getShortAddr();
  37 + uint8_t getShortAddr() { return mData->shortAddr; }
55 38 Status setShortAddr(uint8_t addr);
56 39  
57   - uint8_t getMinLevel();
  40 + uint8_t getMinLevel() { return mData->minLevel; }
58 41 Status setMinLevel(uint8_t level);
59 42  
60   - uint8_t getMaxLevel();
  43 + uint8_t getMaxLevel() { return mData->maxLevel; }
61 44 Status setMaxLevel(uint8_t level);
62 45  
63   - uint8_t getPowerOnLevel();
  46 + uint8_t getPowerOnLevel() { return mData->powerOnLevel; }
64 47 Status setPowerOnLevel(uint8_t level);
65 48  
66   - uint8_t getFaliureLevel();
  49 + uint8_t getFaliureLevel() { return mData->failureLevel; }
67 50 Status setFaliureLevel(uint8_t level);
68 51  
69   - uint8_t getFadeTime();
  52 + uint8_t getFadeTime() { return mData->fadeTime; }
70 53 Status setFadeTime(uint8_t fadeTime);
71 54  
72   - uint8_t getFadeRate();
  55 + uint8_t getFadeRate() { return mData->fadeRate; }
73 56 Status setFadeRate(uint8_t fadeRate);
74 57  
75 58 uint8_t getLevelForScene(uint8_t scene);
76 59 Status setLevelForScene(uint8_t scene, uint8_t level);
77 60  
78   - uint16_t getGroups();
79   - uint8_t getGroupsL();
80   - uint8_t getGroupsH();
  61 + uint16_t getGroups() { return mData->groups; }
81 62 Status setGroups(uint16_t groups);
82 63  
83   - uint32_t getSearchAddr();
  64 + uint32_t getSearchAddr() { return mRam.searchAddr; }
84 65 Status setSearchAddr(uint32_t searchAddr);
85 66  
86   - uint32_t getRandomAddr();
  67 + uint32_t getRandomAddr() { return mTemp->randomAddr; }
87 68 Status setRandomAddr(uint32_t randomAddr);
88 69  
89   - uint8_t getActualLevel();
  70 + uint8_t getActualLevel() { return mTemp->actualLevel; }
90 71 Status setActualLevel(uint8_t level);
91 72  
92   - virtual bool isValid() {
93   - return isDataValid() && isTempValid();
94   - }
  73 + virtual bool isValid() { return isDataValid() && isTempValid(); }
95 74  
96 75 virtual bool isReset();
97 76 virtual Status reset();
98 77  
99   - uint16_t uint16FromDtrAndDtr1() {
100   - return ((uint16_t) mRam.dtr1 << 8) | mRam.dtr;
101   - }
  78 + uint16_t uint16FromDtrAndDtr1() { return ((uint16_t) mRam.dtr1 << 8) | mRam.dtr; }
102 79  
103 80 protected:
104 81  
... ...
src/dali/controller/query_store.cpp
  View file @4eb18d4
... ... @@ -159,46 +159,10 @@ uint8_t QueryStore::queryStatus() {
159 159 return status;
160 160 }
161 161  
162   -bool QueryStore::queryLampFailure() {
163   - return mLampController->isFailure();
164   -}
165   -
166   -bool QueryStore::queryLampPowerOn() {
167   - return mLampController->isPowerOn();
168   -}
169   -
170   -bool QueryStore::queryLampLimitError() {
171   - return mLampController->isLimitError();
172   -}
173   -
174 162 bool QueryStore::queryIsFading() {
175 163 return mLampController->isFading();
176 164 }
177 165  
178   -bool QueryStore::queryResetState() {
179   - return mMemoryController->isReset();
180   -}
181   -
182   -bool QueryStore::queryMissingShortAddr() {
183   - return mMemoryController->getShortAddr() == DALI_MASK;
184   -}
185   -
186   -bool QueryStore::queryLampPowerSet() {
187   - return mLampController->isPowerSet();
188   -}
189   -
190   -uint8_t QueryStore::queryActualLevel() {
191   - return mLampController->getLevel();
192   -}
193   -
194   -uint8_t QueryStore::queryMaxLevel() {
195   - return mMemoryController->getMaxLevel();
196   -}
197   -
198   -uint8_t QueryStore::queryMinLevel() {
199   - return mMemoryController->getMinLevel();
200   -}
201   -
202 166 uint8_t QueryStore::queryPowerOnLevel() {
203 167 return mMemoryController->getPowerOnLevel();
204 168 }
... ... @@ -218,11 +182,11 @@ uint8_t QueryStore::queryLevelForScene(uint8_t scene) {
218 182 }
219 183  
220 184 uint8_t QueryStore::queryGroupsL() {
221   - return mMemoryController->getGroupsL();
  185 + return mMemoryController->getGroups() & 0xff;
222 186 }
223 187  
224 188 uint8_t QueryStore::queryGroupsH() {
225   - return mMemoryController->getGroupsH();
  189 + return mMemoryController->getGroups() >> 8;
226 190 }
227 191  
228 192 uint8_t QueryStore::queryRandomAddrH() {
... ... @@ -237,9 +201,5 @@ uint8_t QueryStore::queryRandomAddrL() {
237 201 return (uint8_t) ((mMemoryController->getRandomAddr() >> 0) & 0xff);
238 202 }
239 203  
240   -bool QueryStore::isMemoryValid() {
241   - return mMemoryController->isValid();
242   -}
243   -
244 204 } // namespace controller
245 205 } // namespace dali
... ...
src/dali/controller/query_store.hpp
  View file @4eb18d4
... ... @@ -37,16 +37,16 @@ public:
37 37 Status removeFromGroup(uint8_t group);
38 38 Status storeDtrAsShortAddr();
39 39 uint8_t queryStatus();
40   - bool queryLampFailure();
41   - bool queryLampPowerOn();
42   - bool queryLampLimitError();
  40 + bool queryLampFailure() { return mLampController->isFailure(); }
  41 + bool queryLampPowerOn() { return mLampController->isPowerOn(); }
  42 + bool queryLampLimitError() { return mLampController->isLimitError(); }
43 43 virtual bool queryIsFading();
44   - bool queryResetState();
45   - bool queryMissingShortAddr();
46   - bool queryLampPowerSet();
47   - virtual uint8_t queryActualLevel();
48   - uint8_t queryMaxLevel();
49   - uint8_t queryMinLevel();
  44 + bool queryResetState() { return mMemoryController->isReset(); }
  45 + bool queryMissingShortAddr() { return mMemoryController->getShortAddr() == DALI_MASK; }
  46 + bool queryLampPowerSet() { return mLampController->isPowerSet(); }
  47 + virtual uint8_t queryActualLevel() { return mLampController->getLevel(); }
  48 + uint8_t queryMaxLevel() { return mMemoryController->getMaxLevel(); }
  49 + uint8_t queryMinLevel() { return mMemoryController->getMinLevel(); }
50 50 virtual uint8_t queryPowerOnLevel();
51 51 virtual uint8_t queryFaliureLevel();
52 52 uint8_t queryFadeRateOrTime();
... ... @@ -58,16 +58,11 @@ public:
58 58 uint8_t queryRandomAddrL();
59 59  
60 60 protected:
61   - Memory* const getMemoryController() {
62   - return mMemoryController;
63   - }
64   -
65   - Lamp* const getLampController() {
66   - return mLampController;
67   - }
  61 + Memory* const getMemoryController() { return mMemoryController; }
  62 + Lamp* const getLampController() { return mLampController; }
68 63  
69 64 private:
70   - bool isMemoryValid();
  65 + bool isMemoryValid() { return mMemoryController->isValid(); }
71 66  
72 67 QueryStore(const QueryStore& other) = delete;
73 68 QueryStore& operator=(const QueryStore&) = delete;
... ...
src/dali/dali.hpp
  View file @4eb18d4
... ... @@ -39,6 +39,9 @@
39 39  
40 40 namespace dali {
41 41  
  42 +typedef uint64_t Time;
  43 +const Time kTimeInvalid = 0xffffffffffffffffUL;
  44 +
42 45 enum class Status {
43 46 OK, ERROR, INVALID, INVALID_STATE, REPEAT_REQUIRED
44 47 };
... ... @@ -73,7 +76,7 @@ public:
73 76 virtual void abortFading() = 0;
74 77 };
75 78  
76   -class IBus {
  79 +class IBusDriver {
77 80 public:
78 81 enum class IBusState {
79 82 UNKNOWN, DISCONNECTED, CONNECTED
... ... @@ -81,7 +84,7 @@ public:
81 84  
82 85 class IBusClient {
83 86 public:
84   - virtual void onDataReceived(uint64_t timeMs, uint16_t data) = 0;
  87 + virtual void onDataReceived(Time time, uint16_t data) = 0;
85 88 virtual void onBusStateChanged(IBusState state);
86 89 };
87 90  
... ... @@ -97,7 +100,7 @@ public:
97 100 virtual void timerTaskRun() = 0;
98 101 };
99 102  
100   - virtual uint64_t getTime() = 0;
  103 + virtual Time getTime() = 0;
101 104 virtual Status schedule(ITimerTask* task, uint32_t delay, uint32_t period) = 0;
102 105 virtual void cancel(ITimerTask* task) = 0;
103 106 virtual uint32_t randomize() = 0;
... ...
src/dali/slave.cpp
  View file @4eb18d4
... ... @@ -13,30 +13,28 @@
13 13 namespace dali {
14 14  
15 15 // static
16   -Slave* Slave::create(IMemory* memoryDriver, ILamp* lampDriver, IBus* busDriver, ITimer* timer) {
  16 +Slave* Slave::create(IBusDriver* busDriver, ITimer* timer, IMemory* memoryDriver, ILamp* lampDriver) {
17 17 controller::Memory* memory = new controller::Memory(memoryDriver);
18 18 controller::Lamp* lamp = new controller::Lamp(lampDriver, memory);
19 19 controller::QueryStore* queryStore = new controller::QueryStore(memory, lamp);
20   - controller::Bus* bus = new controller::Bus(busDriver);
21   - controller::Initialization* initialization = new controller::Initialization(timer, memory);
22 20  
23   - return new Slave(memory, lamp, queryStore, bus, initialization);
  21 + return new Slave(busDriver, timer, memory, lamp, queryStore);
24 22 }
25 23  
26   -Slave::Slave(controller::Memory* memory, controller::Lamp* lamp, controller::QueryStore* queryStore,
27   - controller::Bus* bus, controller::Initialization* initialization) :
28   - mMemoryController(memory), mLampController(lamp), mQueryStoreController(queryStore),
29   - mBusController(bus), mInitializationController(initialization),
30   - mMemoryWriteEnabled(false), mDeviceType(0xff) {
  24 +Slave::Slave(IBusDriver* busDriver, ITimer* timer, controller::Memory* memory, controller::Lamp* lamp,
  25 + controller::QueryStore* queryStore) :
  26 + mBusController(busDriver, this),
  27 + mInitializationController(timer, memory),
  28 + mMemoryController(memory),
  29 + mLampController(lamp),
  30 + mQueryStoreController(queryStore),
  31 + mMemoryWriteEnabled(false),
  32 + mDeviceType(0xff) {
31 33 mLampController->setListener(this);
32   - mBusController->setListener(this);
33 34 }
34 35  
35 36 Slave::~Slave() {
36   - mBusController->setListener(nullptr);
37 37 mLampController->setListener(nullptr);
38   - delete mInitializationController;
39   - delete mBusController;
40 38 delete mQueryStoreController;
41 39 delete mLampController;
42 40 delete mMemoryController;
... ... @@ -51,7 +49,7 @@ void Slave::notifyPowerDown() {
51 49 }
52 50  
53 51 void Slave::onLampStateChnaged(ILamp::ILampState state) {
54   - mInitializationController->onLampStateChnaged(state);
  52 + mInitializationController.onLampStateChnaged(state);
55 53 }
56 54  
57 55 uint8_t Slave::getShortAddr() {
... ... @@ -130,7 +128,7 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
130 128 return mLampController->powerOnAndStepUp();
131 129  
132 130 case Command::ENABLE_DAPC_SEQUENCE:
133   - return mLampController->enableDapcSequence(mBusController->getLastCommandTimeMs());
  131 + return mLampController->enableDapcSequence(mBusController.getLastCommandTime());
134 132  
135 133 case Command::GO_TO_SCENE_0:
136 134 case Command::GO_TO_SCENE_1:
... ... @@ -154,7 +152,7 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
154 152 if (repeatCount == 0) {
155 153 return Status::REPEAT_REQUIRED;
156 154 }
157   - mInitializationController->reset();
  155 + mInitializationController.reset();
158 156 mQueryStoreController->reset();
159 157 return Status::OK;
160 158  
... ... @@ -420,10 +418,10 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
420 418 // extended commands
421 419  
422 420 case Command::DIRECT_POWER_CONTROL:
423   - return mLampController->powerDirect(param, mBusController->getLastCommandTimeMs());
  421 + return mLampController->powerDirect(param, mBusController.getLastCommandTime());
424 422  
425 423 case Command::TERMINATE:
426   - return mInitializationController->terminate();
  424 + return mInitializationController.terminate();
427 425  
428 426 case Command::DATA_TRANSFER_REGISTER:
429 427 mMemoryController->setDTR(param);
... ... @@ -433,53 +431,53 @@ Status Slave::internalHandleDaliDT8Command(uint16_t repeatCount, Command cmd, ui
433 431 if (repeatCount == 0) {
434 432 return Status::REPEAT_REQUIRED;
435 433 }
436   - return mInitializationController->initialize(param);
  434 + return mInitializationController.initialize(param);
437 435  
438 436 case Command::RANDOMISE:
439 437 if (repeatCount == 0) {
440 438 return Status::REPEAT_REQUIRED;
441 439 }
442   - return mInitializationController->randomize();
  440 + return mInitializationController.randomize();
443 441  
444 442 case Command::COMPARE: {
445   - Status status = mInitializationController->compare();
  443 + Status status = mInitializationController.compare();
446 444 if (status == Status::OK) {
447   - return mBusController->sendAck(DALI_ACK_YES);
  445 + return mBusController.sendAck(DALI_ACK_YES);
448 446 }
449 447 return status;
450 448 }
451 449 case Command::WITHDRAW:
452   - return mInitializationController->withdraw();
  450 + return mInitializationController.withdraw();
453 451  
454 452 case Command::SEARCHADDRH:
455   - return mInitializationController->searchAddrH(param);
  453 + return mInitializationController.searchAddrH(param);
456 454  
457 455 case Command::SEARCHADDRM:
458   - return mInitializationController->searchAddrM(param);
  456 + return mInitializationController.searchAddrM(param);
459 457  
460 458 case Command::SEARCHADDRL:
461   - return mInitializationController->searchAddrL(param);
  459 + return mInitializationController.searchAddrL(param);
462 460  
463 461 case Command::PROGRAM_SHORT_ADDRESS:
464   - return mInitializationController->programShortAddr(param);
  462 + return mInitializationController.programShortAddr(param);
465 463  
466 464 case Command::VERIFY_SHORT_ADDRESS: {
467   - Status status = mInitializationController->verifySortAddr(param);
  465 + Status status = mInitializationController.verifySortAddr(param);
468 466 if (status == Status::OK) {
469   - return mBusController->sendAck(DALI_ACK_YES);
  467 + return mBusController.sendAck(DALI_ACK_YES);
470 468 }
471 469 return status;
472 470 }
473 471 case Command::QUERY_SHORT_ADDRESS: {
474 472 uint8_t shortAddr;
475   - Status status = mInitializationController->queryShortAddr(&shortAddr);
  473 + Status status = mInitializationController.queryShortAddr(&shortAddr);
476 474 if (status == Status::OK) {
477   - return mBusController->sendAck(shortAddr);
  475 + return mBusController.sendAck(shortAddr);
478 476 }
479 477 return status;
480 478 }
481 479 case Command::PHYSICAL_SELECTION:
482   - return mInitializationController->physicalSelection();
  480 + return mInitializationController.physicalSelection();
483 481  
484 482 case Command::DATA_TRANSFER_REGISTER_1:
485 483 mMemoryController->setDTR1(param);
... ...
src/dali/slave.hpp
  View file @4eb18d4
... ... @@ -20,9 +20,10 @@
20 20  
21 21 namespace dali {
22 22  
23   -class Slave: public controller::Bus::Listener, controller::Lamp::Listener {
  23 +class Slave: public controller::Bus::Client, controller::Lamp::Listener
  24 +{
24 25 public:
25   - static Slave* create(IMemory* memoryDriver, ILamp* lampDriver, IBus* busDriver, ITimer* timer);
  26 + static Slave* create(IBusDriver* busDriver, ITimer* timer, IMemory* memoryDriver, ILamp* lampDriver);
26 27  
27 28 virtual ~Slave();
28 29  
... ... @@ -30,8 +31,8 @@ public:
30 31 void notifyPowerDown();
31 32  
32 33 protected:
33   - Slave(controller::Memory* memory, controller::Lamp* lamp, controller::QueryStore* queryStore,
34   - controller::Bus* busDriver, controller::Initialization* initializationController);
  34 + Slave(IBusDriver* busDriver, ITimer* timer, controller::Memory* memory, controller::Lamp* lamp,
  35 + controller::QueryStore* queryStore);
35 36  
36 37 controller::Memory* const getMemoryController() {
37 38 return mMemoryController;
... ... @@ -46,10 +47,10 @@ protected:
46 47 }
47 48  
48 49 Status sendAck(uint8_t ack) {
49   - return mBusController->sendAck(ack);
50   - }
  50 + return mBusController.sendAck(ack);
  51 + }
51 52  
52   - virtual Status handleHandleDaliDeviceTypeCommand(uint16_t repeat, Command cmd, uint8_t param, uint8_t device_type);
  53 + virtual Status handleHandleDaliDeviceTypeCommand(uint16_t repeat, Command cmd, uint8_t param, uint8_t device_type);
53 54  
54 55 private:
55 56 Slave(const Slave& other) = delete;
... ... @@ -66,11 +67,11 @@ private:
66 67 Status handleIgnoredCommand(Command cmd, uint8_t param) override;
67 68 Status internalHandleDaliDT8Command(uint16_t repeat, Command cmd, uint8_t param);
68 69  
  70 + controller::Bus mBusController;
  71 + controller::Initialization mInitializationController;
69 72 controller::Memory* const mMemoryController;
70 73 controller::Lamp* const mLampController;
71 74 controller::QueryStore* const mQueryStoreController;
72   - controller::Bus* const mBusController;
73   - controller::Initialization* const mInitializationController;
74 75 bool mMemoryWriteEnabled;
75 76 uint8_t mDeviceType;
76 77 };
... ...
src/xmc1200/bccu.cpp
  View file @4eb18d4
... ... @@ -213,16 +213,4 @@ void BccuLampRGB::setColor(uint16_t r, uint16_t g, uint16_t b, uint32_t changeTi
213 213 XMC_BCCU_ConcurrentStartLinearWalk(BCCU, mChannelsMask);
214 214 }
215 215  
216   -uint16_t BccuLampRGB::getColorR() {
217   - return XMC_BCCU_CH_ReadIntensity(BCCU_CH_R);
218   -}
219   -
220   -uint16_t BccuLampRGB::getColorG() {
221   - return XMC_BCCU_CH_ReadIntensity(BCCU_CH_G);
222   -}
223   -
224   -uint16_t BccuLampRGB::getColorB() {
225   - return XMC_BCCU_CH_ReadIntensity(BCCU_CH_B);
226   -}
227   -
228 216 } // namespace xmc
... ...
src/xmc1200/bccu.hpp
  View file @4eb18d4
... ... @@ -68,9 +68,19 @@ public:
68 68 }
69 69  
70 70 void setColor(uint16_t R, uint16_t G, uint16_t B, uint32_t changeTime);
71   - uint16_t getColorR();
72   - uint16_t getColorG();
73   - uint16_t getColorB();
  71 +
  72 + uint16_t getColorR() {
  73 + return XMC_BCCU_CH_ReadIntensity(BCCU_CH_R);
  74 + }
  75 +
  76 + uint16_t getColorG() {
  77 + return XMC_BCCU_CH_ReadIntensity(BCCU_CH_G);
  78 + }
  79 +
  80 + uint16_t getColorB() {
  81 + return XMC_BCCU_CH_ReadIntensity(BCCU_CH_B);
  82 + }
  83 +
74 84  
75 85 private:
76 86 BCCU_CH_Type* BCCU_CH_R;
... ...
src/xmc1200/clock.hpp
  View file @4eb18d4
... ... @@ -23,8 +23,6 @@ public:
23 23 FREQ_16MHZ = 0x02,
24 24 FREQ_10_67MHZ = 0x03,
25 25 FREQ_8MHZ = 0x04,
26   - FREQ_126KHZ = 0xFE,
27   - FREQ_125_5KHZ = 0xFF,
28 26 } Frequency;
29 27  
30 28 // Initializes SCU Clock registers based on user configuration
... ...
src/xmc1200/dali/bus.cpp
  View file @4eb18d4
... ... @@ -45,17 +45,15 @@ volatile RxState gRxState;
45 45 volatile uint32_t gRxData32 = INVALID32;
46 46 volatile uint32_t gRxDataTmp;
47 47 uint16_t gTxData = INVALID16;
48   -volatile uint64_t gBusLowTime = 0;
49   -
50   -#define BUS_TIME_CONNECTED 0xffffffffffffffffUL
  48 +volatile Time gBusLowTime = 0;
51 49  
52 50 #define MAX_CLIENTS 1
53 51  
54   -IBus::IBusState gBusState = IBus::IBusState::UNKNOWN;
55   -IBus::IBusClient* gClients[MAX_CLIENTS];
  52 +IBusDriver::IBusState gBusState = IBusDriver::IBusState::UNKNOWN;
  53 +IBusDriver::IBusClient* gClients[MAX_CLIENTS];
56 54  
57 55 void onRisingEdge(uint16_t timer) {
58   - gBusLowTime = BUS_TIME_CONNECTED;
  56 + gBusLowTime = kTimeInvalid;
59 57  
60 58 if (timer == 0) {
61 59 return;
... ... @@ -218,20 +216,20 @@ Status Bus::sendAck(uint8_t ack) {
218 216  
219 217 void Bus::runSlice() {
220 218 uint16_t data;
221   - uint64_t time = Timer::getTimeMs();
  219 + Time time = Timer::getTimeMs();
222 220  
223 221 __disable_irq();
224   - uint64_t busLowTime = gBusLowTime;
  222 + Time busLowTime = gBusLowTime;
225 223 __enable_irq();
226 224  
227   - if (busLowTime == BUS_TIME_CONNECTED) {
228   - if (gBusState != IBus::IBusState::CONNECTED) {
229   - onBusStateChanged(IBus::IBusState::CONNECTED);
  225 + if (busLowTime == kTimeInvalid) {
  226 + if (gBusState != IBusDriver::IBusState::CONNECTED) {
  227 + onBusStateChanged(IBusDriver::IBusState::CONNECTED);
230 228 }
231 229 } else {
232 230 if (time - busLowTime >= 500) {
233   - if (gBusState != IBus::IBusState::DISCONNECTED) {
234   - onBusStateChanged(IBus::IBusState::DISCONNECTED);
  231 + if (gBusState != IBusDriver::IBusState::DISCONNECTED) {
  232 + onBusStateChanged(IBusDriver::IBusState::DISCONNECTED);
235 233 }
236 234 }
237 235 }
... ... @@ -242,7 +240,7 @@ void Bus::runSlice() {
242 240 }
243 241  
244 242 // static
245   -void Bus::onDataReceived(uint64_t time, uint16_t data) {
  243 +void Bus::onDataReceived(Time time, uint16_t data) {
246 244 for (uint8_t i = 0; i < MAX_CLIENTS; ++i) {
247 245 if (gClients[i] != nullptr) {
248 246 gClients[i]->onDataReceived(time, data);
... ... @@ -298,8 +296,8 @@ void Bus::initRx() {
298 296 }
299 297  
300 298 //static
301   -bool Bus::checkRxTx(uint64_t time, uint16_t* data) {
302   - static uint64_t gLastDataTime = 0;
  299 +bool Bus::checkRxTx(Time time, uint16_t* data) {
  300 + static Time gLastDataTime = 0;
303 301 bool rxResult = false;
304 302 __disable_irq();
305 303 uint32_t rxData32 = gRxData32;
... ... @@ -313,7 +311,7 @@ bool Bus::checkRxTx(uint64_t time, uint16_t* data) {
313 311 }
314 312  
315 313 if (gTxData != INVALID16) {
316   - uint64_t dTime = time - gLastDataTime;
  314 + Time dTime = time - gLastDataTime;
317 315 if (dTime > 3) {
318 316 if (gRxState == RxState::IDLE) {
319 317 uint16_t tmpTxData = gTxData;
... ...
src/xmc1200/dali/bus.hpp
  View file @4eb18d4
... ... @@ -16,7 +16,7 @@
16 16 namespace dali {
17 17 namespace xmc {
18 18  
19   -class Bus: public dali::IBus {
  19 +class Bus: public dali::IBusDriver {
20 20 public:
21 21 static Bus* getInstance();
22 22  
... ... @@ -33,11 +33,11 @@ private:
33 33  
34 34 ~Bus();
35 35  
36   - static void onDataReceived(uint64_t timeMs, uint16_t data);
  36 + static void onDataReceived(Time timeMs, uint16_t data);
37 37 static void onBusStateChanged(IBusState state);
38 38  
39 39 static void initRx();
40   - static bool checkRxTx(uint64_t time, uint16_t* data);
  40 + static bool checkRxTx(Time time, uint16_t* data);
41 41  
42 42 static void initTx();
43 43 static void tx(uint8_t data);
... ...
src/xmc1200/dali/lamp.cpp
  View file @4eb18d4
... ... @@ -112,12 +112,6 @@ void LampRGB::abortFading() {
112 112 }
113 113 }
114 114  
115   -void LampRGB::waitForFade() {
116   - while (mLamp.isFading()) {
117   - }
118   -}
119   -
120   -
121 115 void LampRGB::setPrimary(const uint16_t primary[], uint8_t size, uint32_t changeTime) {
122 116 for (uint8_t i = 0; i < 3; ++i) {
123 117 mPrimary[i] = primary[i];
... ... @@ -150,10 +144,6 @@ void LampRGB::abortColorChanging() {
150 144 }
151 145 }
152 146  
153   -void LampRGB::waitForColorChange() {
154   - while (mLamp.isColorChanging()) {
155   - }
156   -}
157 147  
158 148 void LampRGB::onLampStateChnaged(ILampState state) {
159 149 for (uint16_t i = 0; i < kMaxClients; ++i) {
... ...
src/xmc1200/dali/lamp.hpp
  View file @4eb18d4
... ... @@ -28,13 +28,13 @@ public:
28 28 uint16_t getLevel() override;
29 29 bool isFading() override;
30 30 void abortFading() override;
31   - void waitForFade();
  31 + void waitForFade() { while (mLamp.isFading()); }
32 32  
33 33 void setPrimary(const uint16_t primary[], uint8_t size, uint32_t changeTime) override;
34 34 void getPrimary(uint16_t primary[], uint8_t size) override;
35 35 bool isColorChanging() override;
36 36 void abortColorChanging() override;
37   - void waitForColorChange();
  37 + void waitForColorChange() { while (mLamp.isColorChanging()); };
38 38  
39 39 bool isOff() {
40 40 return getLevel() == 0;
... ...
src/xmc1200/dali/timer.cpp
  View file @4eb18d4
... ... @@ -24,12 +24,12 @@ const uint16_t* kUniqeChipId = (uint16_t*) 0x10000FF0; // 8 elements
24 24  
25 25 typedef struct {
26 26 dali::ITimer::ITimerTask* task;
27   - uint64_t time;
  27 + Time time;
28 28 uint32_t period;
29 29 } TaskInfo;
30 30  
31 31 TaskInfo gTasks[MAX_TASKS];
32   -volatile uint64_t gSystemTimeMs;
  32 +volatile Time gSystemTimeMs;
33 33  
34 34 }
35 35  
... ... @@ -85,7 +85,7 @@ uint32_t Timer::randomize() {
85 85 }
86 86  
87 87 // static
88   -uint64_t Timer::getTimeMs() {
  88 +Time Timer::getTimeMs() {
89 89 return gSystemTimeMs;
90 90 }
91 91  
... ... @@ -110,7 +110,7 @@ void Timer::runSlice() {
110 110 extern "C" {
111 111  
112 112 void SysTick_Handler(void) {
113   - gSystemTimeMs += 1000 / TICKS_PER_SECOND;
  113 + gSystemTimeMs += (uint32_t)1000 / TICKS_PER_SECOND;
114 114 }
115 115  
116 116 } // extern "C"
... ...
src/xmc1200/dali/timer.hpp
  View file @4eb18d4
... ... @@ -20,14 +20,14 @@ class Timer: public dali::ITimer {
20 20 public:
21 21 static Timer* getInstance();
22 22  
23   - uint64_t getTime() override {
  23 + Time getTime() override {
24 24 return getTimeMs();
25 25 }
26 26 dali::Status schedule(ITimerTask* task, uint32_t delay, uint32_t period) override;
27 27 void cancel(ITimerTask* task) override;
28 28 uint32_t randomize() override;
29 29  
30   - static uint64_t getTimeMs();
  30 + static Time getTimeMs();
31 31 static void runSlice();
32 32  
33 33 private:
... ...
src/xmc1200/main.cpp
  View file @4eb18d4
... ... @@ -76,7 +76,7 @@ int main(void) {
76 76  
77 77 dali::xmc::Memory* daliMemory1 = dali::xmc::Memory::getInstance();
78 78 dali::xmc::LampRGB* daliLamp1 = dali::xmc::LampRGB::getInstance();
79   - gSlave = dali::SlaveDT8::create(daliMemory1, daliLamp1, daliBus, daliTimer);
  79 + gSlave = dali::SlaveDT8::create(daliBus, daliTimer, daliMemory1, daliLamp1);
80 80  
81 81 daliTimer->schedule(&gPowerOnTimerTask, 600, 0);
82 82  
... ...