Peter M. Groen / DALI-Lighting-Interface

Commit 7241451596ad427642eee4383443a263fa8919fb

Authored by qqqlab
Committed by GitHub
1 parent 1e6536ea

Delete qqqDali.cpp

Inline Side-by-side
Showing 1 changed file with 0 additions and 436 deletions
qqqDali.cpp deleted
View file @1e6536e
1   -/*###########################################################################
2   - qqqDali.cpp - copyright qqqlab.com / github.com/qqqlab
3   -
4   - This program is free software: you can redistribute it and/or modify
5   - it under the terms of the GNU General Public License as published by
6   - the Free Software Foundation, either version 3 of the License, or
7   - (at your option) any later version.
8   -
9   - This program is distributed in the hope that it will be useful,
10   - but WITHOUT ANY WARRANTY; without even the implied warranty of
11   - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12   - GNU General Public License for more details.
13   -
14   - You should have received a copy of the GNU General Public License
15   - along with this program. If not, see <http://www.gnu.org/licenses/>.
16   -
17   -----------------------------------------------------------------------------
18   -Changelog:
19   -2020-11-10 Split off hardware specific code into separate class
20   -2020-11-08 Created & tested on ATMega328 @ 8Mhz
21   -###########################################################################*/
22   -#include "qqqDali.h"
23   -
24   -//###########################################################################
25   -// Helpers
26   -//###########################################################################
27   -#define DALI_TOL 25 //percentage tolerance on timing. DALI specs call for 10%, but use higher value to allow for implementation micros() jitter. NOTE: Max value is 50% to differentiate between TE and 2TE.
28   -#define DALI_TE ((1000000+(DALI_BAUD))/(2*(DALI_BAUD))) //417us
29   -#define DALI_TE_MIN ((100-DALI_TOL)*DALI_TE)/100
30   -#define DALI_TE_MAX ((100+DALI_TOL)*DALI_TE)/100
31   -#define DALI_IS_TE(x) ((DALI_TE_MIN)<=(x) && (x)<=(DALI_TE_MAX))
32   -#define DALI_IS_2TE(x) ((2*(DALI_TE_MIN))<=(x) && (x)<=(2*(DALI_TE_MAX)))
33   -
34   -//###########################################################################
35   -// Transmitter ISR
36   -//###########################################################################
37   -//called by derived class every Te period (417us)
38   -void Dali::ISR_timer() {
39   - if(this->bus_idle_te_cnt<0xff) this->bus_idle_te_cnt++;
40   -
41   - //send starbit, message bytes, 2 stop bits.
42   - switch(this->tx_state) {
43   - case TX_IDLE:
44   - break;
45   - case TX_START:
46   - //wait for timeslot, then send start bit
47   - if(this->bus_idle_te_cnt >= 22) {
48   - this->HAL_set_bus_low();
49   - this->tx_bus_low=1;
50   - this->tx_state = TX_START_X;
51   - }
52   - break;
53   - case TX_START_X:
54   - this->HAL_set_bus_high();
55   - this->tx_bus_low=0;
56   - this->tx_pos=0;
57   - this->tx_state = TX_BIT;
58   - break;
59   - case TX_BIT:
60   - if(this->tx_msg[this->tx_pos>>3] & 1<<(7-(this->tx_pos&0x7))) {this->HAL_set_bus_low();this->tx_bus_low=1;} else {this->HAL_set_bus_high();this->tx_bus_low=0;}
61   - this->tx_state = TX_BIT_X;
62   - break;
63   - case TX_BIT_X:
64   - if(this->tx_msg[this->tx_pos>>3] & 1<<(7-(this->tx_pos&0x7))) {this->HAL_set_bus_high();this->tx_bus_low=0;} else {this->HAL_set_bus_low();this->tx_bus_low=1;}
65   - this->tx_pos++;
66   - if(this->tx_pos < this->tx_len) {this->tx_state = TX_BIT;} else {this->tx_state = TX_STOP1;}
67   - break;
68   - case TX_STOP1:
69   - this->HAL_set_bus_high();
70   - this->tx_bus_low=0;
71   - this->tx_state = TX_STOP1_X;
72   - break;
73   - case TX_STOP1_X:
74   - this->tx_state = TX_STOP2;
75   - break;
76   - case TX_STOP2:
77   - this->tx_state = TX_STOP2_X;
78   - break;
79   - case TX_STOP2_X:
80   - this->tx_state = TX_STOP3;
81   - break;
82   - case TX_STOP3:
83   - this->bus_idle_te_cnt=0;
84   - this->tx_state = TX_IDLE;
85   - this->rx_state = RX_IDLE;
86   - this->rx_len = 0;
87   - break;
88   - }
89   -
90   - //handle receiver stop bits
91   - if(this->rx_state == RX_BIT && this->bus_idle_te_cnt>4) {
92   - this->rx_state = RX_IDLE;
93   - //received two stop bits, got message in rx_msg + rx_halfbitlen
94   - uint8_t bitlen = (this->rx_halfbitlen+1)>>1;
95   - if((bitlen & 0x7) == 0) {
96   - this->rx_len = bitlen>>3;
97   - if(this->EventHandlerReceivedData) this->EventHandlerReceivedData(this, (uint8_t*)this->rx_msg, this->rx_len);
98   - }else{
99   - //invalid bitlen
100   - //TODO handle this
101   - }
102   - }
103   -}
104   -
105   -//###########################################################################
106   -// Receiver ISR
107   -//###########################################################################
108   -//called by derived class on bus state change
109   -void Dali::ISR_pinchange() {
110   - uint32_t ts = this->HAL_micros(); //get timestamp of change
111   - this->bus_idle_te_cnt=0; //reset idle counter
112   - uint8_t bus_low = this->HAL_is_bus_low();
113   -
114   - //exit if transmitting
115   - if(this->tx_state != TX_IDLE) {
116   - //check tx collision
117   - if(bus_low && !this->tx_bus_low) {
118   - this->tx_state = TX_IDLE; //stop transmitter
119   - this->tx_collision = 1; //mark collision
120   - }
121   - return;
122   - }
123   -
124   - //no bus change, ignore
125   - if(bus_low == this->rx_last_bus_low) return;
126   -
127   - //store values for next loop
128   - uint32_t dt = ts - this->rx_last_change_ts;
129   - this->rx_last_change_ts = ts;
130   - this->rx_last_bus_low = bus_low;
131   -
132   - switch(this->rx_state) {
133   - case RX_IDLE:
134   - if(bus_low) {
135   - this->rx_state = RX_START;
136   - }
137   - break;
138   - case RX_START:
139   - if(bus_low || !DALI_IS_TE(dt)) {
140   - this->rx_state = RX_IDLE;
141   - }else{
142   - this->rx_halfbitlen=-1;
143   - for(uint8_t i=0;i<7;i++) this->rx_msg[0]=0;
144   - this->rx_state = RX_BIT;
145   - }
146   - break;
147   - case RX_BIT:
148   - if(DALI_IS_TE(dt)) {
149   - //got a single Te pulse
150   - this->push_halfbit(bus_low);
151   - } else if(DALI_IS_2TE(dt)) {
152   - //got a double Te pulse
153   - this->push_halfbit(bus_low);
154   - this->push_halfbit(bus_low);
155   - } else {
156   - //got something else -> no good
157   - this->rx_state = RX_IDLE;
158   - //TODO rx error
159   - return;
160   - }
161   - break;
162   - }
163   -}
164   -
165   -void Dali::push_halfbit(uint8_t bit) {
166   - bit = (~bit)&1;
167   - if((this->rx_halfbitlen & 1)==0) {
168   - uint8_t i = this->rx_halfbitlen>>4;
169   - if(i<3) {
170   - this->rx_msg[i] = (this->rx_msg[i]<<1) | bit;
171   - }
172   - }
173   - this->rx_halfbitlen++;
174   -}
175   -
176   -
177   -//###########################################################################
178   -// Dali Class
179   -//###########################################################################
180   -
181   -//non blocking send - check tx_state for completion, check tx_collision for collision errors
182   -uint8_t Dali::send(uint8_t* tx_msg, uint8_t tx_len_bytes) {
183   - if(tx_len_bytes>3) return -(DALI_RESULT_DATA_TOO_LONG);
184   - if(this->tx_state != TX_IDLE) return -(DALI_RESULT_TIMEOUT);
185   - for(uint8_t i=0;i<tx_len_bytes;i++) this->tx_msg[i]=tx_msg[i];
186   - this->tx_len = tx_len_bytes<<3;
187   - this->tx_collision=0;
188   - this->tx_state = TX_START; //start transmission
189   - return 0;
190   -}
191   -
192   -//blocking send - wait until successful send or timeout
193   -uint8_t Dali::sendwait(uint8_t* tx_msg, uint8_t tx_len_bytes, uint32_t timeout_us) {
194   - if(tx_len_bytes>3) return -(DALI_RESULT_DATA_TOO_LONG);
195   - uint32_t ts = HAL_micros();
196   -
197   - while(1) {
198   - //wait for idle
199   - while(this->tx_state != TX_IDLE) {
200   - if(HAL_micros() - ts > timeout_us) return -(DALI_RESULT_TIMEOUT);
201   - }
202   - //start transmit
203   - uint8_t rv = this->send(tx_msg,tx_len_bytes);
204   - if(rv) return rv;
205   - //wait for completion
206   - while(this->tx_state != TX_IDLE) {
207   - if(HAL_micros() - ts > timeout_us) return -(DALI_RESULT_TX_TIMEOUT);
208   - }
209   - //check for collisions
210   - if(this->tx_collision==0) return 0;
211   - }
212   - return -(DALI_RESULT_TIMEOUT);
213   -}
214   -
215   -//blocking transmit 2 byte command, receive 1 byte reply (if reply was sent)
216   -int16_t Dali::tx(uint8_t cmd0, uint8_t cmd1, uint32_t timeout_us) {
217   - uint8_t tx[2];
218   - tx[0] = cmd0;
219   - tx[1] = cmd1;
220   - int16_t rv = this->sendwait(tx, 2, timeout_us);
221   - this->rx_halfbitlen = 0;
222   - if(rv) return -rv;;
223   -
224   - //wait up to 10 ms for start of reply
225   - uint32_t ts = HAL_micros();
226   - while(this->rx_state == RX_IDLE) {
227   - if(HAL_micros() - ts > 10000) return DALI_RESULT_NO_REPLY;
228   - }
229   - //wait up to 15 ms for completion of reply
230   - ts = HAL_micros();
231   - while(this->rx_len == 0) {
232   - if(HAL_micros() - ts > 15000) return DALI_RESULT_NO_REPLY;
233   - }
234   - if(this->rx_len > 1) return DALI_RESULT_INVALID_REPLY;
235   - return this->rx_msg[0];
236   -}
237   -
238   -//=================================================================
239   -// High level
240   -//=================================================================
241   -//check YAAAAAA: 0000 0000 to 0011 1111 adr, 0100 0000 to 0100 1111 group, x111 1111 broadcast
242   -uint8_t Dali::check_yaaaaaa(uint8_t yaaaaaa) {
243   - return (yaaaaaa<=0b01001111 || yaaaaaa==0b01111111 || yaaaaaa==0b11111111);
244   -}
245   -
246   -void Dali::set_level(uint8_t level, uint8_t adr) {
247   - if(this->check_yaaaaaa(adr)) this->tx(adr<<1,level);
248   -}
249   -
250   -int16_t Dali::cmd(uint16_t cmd, uint8_t arg) {
251   - //Serial.print("dali_cmd[");Serial.print(cmd,HEX);Serial.print(",");Serial.print(arg,HEX);Serial.print(")");
252   - uint8_t cmd0,cmd1;
253   - if(cmd&0x0100) {
254   - //special commands: MUST NOT have YAAAAAAX pattern for cmd
255   - //Serial.print(" SPC");
256   - if(!this->check_yaaaaaa(cmd>>1)) {
257   - cmd0 = cmd;
258   - cmd1 = arg;
259   - }else{
260   - return DALI_RESULT_INVALID_CMD;
261   - }
262   - }else{
263   - //regular commands: MUST have YAAAAAA pattern for arg
264   -
265   - //Serial.print(" REG");
266   - if(this->check_yaaaaaa(arg)) {
267   - cmd0 = arg<<1|1;
268   - cmd1 = cmd;
269   - }else{
270   - return DALI_RESULT_INVALID_CMD;
271   - }
272   - }
273   - if(cmd&0x0200) {
274   - //Serial.print(" REPEAT");
275   - this->tx(cmd0, cmd1);
276   - }
277   - int16_t rv = this->tx(cmd0, cmd1);
278   - //Serial.print(" rv=");Serial.println(rv);
279   - return rv;
280   -}
281   -
282   -
283   -uint8_t Dali::set_operating_mode(uint8_t v, uint8_t adr) {
284   - return set_value(DALI_SET_OPERATING_MODE, DALI_QUERY_OPERATING_MODE, v, adr);
285   -}
286   -
287   -uint8_t Dali::set_max_level(uint8_t v, uint8_t adr) {
288   - return set_value(DALI_SET_MAX_LEVEL, DALI_QUERY_MAX_LEVEL, v, adr);
289   -}
290   -
291   -uint8_t Dali::set_min_level(uint8_t v, uint8_t adr) {
292   - return set_value(DALI_SET_MIN_LEVEL, DALI_QUERY_MIN_LEVEL, v, adr);
293   -}
294   -
295   -
296   -uint8_t Dali::set_system_failure_level(uint8_t v, uint8_t adr) {
297   - return set_value(DALI_SET_SYSTEM_FAILURE_LEVEL, DALI_QUERY_SYSTEM_FAILURE_LEVEL, v, adr);
298   -}
299   -
300   -uint8_t Dali::set_power_on_level(uint8_t v, uint8_t adr) {
301   - return set_value(DALI_SET_POWER_ON_LEVEL, DALI_QUERY_POWER_ON_LEVEL, v, adr);
302   -}
303   -
304   -//set a parameter value, returns 0 on success
305   -uint8_t Dali::set_value(uint16_t setcmd, uint16_t getcmd, uint8_t v, uint8_t adr) {
306   - int16_t current_v = this->cmd(getcmd,adr); //get current parameter value
307   - if(current_v == v) return 0;
308   - this->cmd(DALI_DATA_TRANSFER_REGISTER0,v); //store value in DTR
309   - int16_t dtr = this->cmd(DALI_QUERY_CONTENT_DTR0,adr); //get DTR value
310   - if(dtr != v) return 1;
311   - this->cmd(setcmd,adr); //set parameter value = DTR
312   - current_v = this->cmd(getcmd,adr); //get current parameter value
313   - if(current_v != v) return 2;
314   - return 0;
315   -}
316   -
317   -
318   -//======================================================================
319   -// Commissioning short addresses
320   -//======================================================================
321   -
322   -//Sets the slave Note 1 to the INITIALISE status for15 minutes.
323   -//Commands 259 to 270 are enabled only for a slave in this
324   -//status.
325   -
326   -//set search address
327   -void Dali::set_searchaddr(uint32_t adr) {
328   - this->cmd(DALI_SEARCHADDRH,adr>>16);
329   - this->cmd(DALI_SEARCHADDRM,adr>>8);
330   - this->cmd(DALI_SEARCHADDRL,adr);
331   -}
332   -
333   -//set search address, but set only changed bytes (takes less time)
334   -void Dali::set_searchaddr_diff(uint32_t adr_new,uint32_t adr_current) {
335   - if( (uint8_t)(adr_new>>16) != (uint8_t)(adr_current>>16) ) this->cmd(DALI_SEARCHADDRH,adr_new>>16);
336   - if( (uint8_t)(adr_new>>8) != (uint8_t)(adr_current>>8) ) this->cmd(DALI_SEARCHADDRM,adr_new>>8);
337   - if( (uint8_t)(adr_new) != (uint8_t)(adr_current) ) this->cmd(DALI_SEARCHADDRL,adr_new);
338   -}
339   -
340   -//Is the random address smaller or equal to the search address?
341   -uint8_t Dali::compare() {
342   - return (0xff == this->cmd(DALI_COMPARE,0x00));
343   -}
344   -
345   -//The slave shall store the received 6-bit address (AAAAAA) as a short address if it is selected.
346   -void Dali::program_short_address(uint8_t shortadr) {
347   - this->cmd(DALI_PROGRAM_SHORT_ADDRESS, (shortadr << 1) | 0x01);
348   -}
349   -
350   -//What is the short address of the slave being selected?
351   -uint8_t Dali::query_short_address() {
352   - return this->cmd(DALI_QUERY_SHORT_ADDRESS, 0x00) >> 1;
353   -}
354   -
355   -//find addr with binary search
356   -uint32_t Dali::find_addr() {
357   - uint32_t adr = 0x800000;
358   - uint32_t addsub = 0x400000;
359   - uint32_t adr_last = adr;
360   - this->set_searchaddr(adr);
361   -
362   - while(addsub) {
363   - this->set_searchaddr_diff(adr,adr_last);
364   - adr_last = adr;
365   - uint8_t cmp = this->compare();
366   - //Serial.print("cmp ");
367   - //Serial.print(adr,HEX);
368   - //Serial.print(" = ");
369   - //Serial.println(cmp);
370   - if(cmp) adr-=addsub; else adr+=addsub;
371   - addsub >>= 1;
372   - }
373   - this->set_searchaddr_diff(adr,adr_last);
374   - adr_last = adr;
375   - if(!this->compare()) {
376   - adr++;
377   - this->set_searchaddr_diff(adr,adr_last);
378   - }
379   - return adr;
380   -}
381   -
382   -//init_arg=11111111 : all without short address
383   -//init_arg=00000000 : all
384   -//init_arg=0AAAAAA1 : only for this shortadr
385   -//returns number of new short addresses assigned
386   -uint8_t Dali::commission(uint8_t init_arg) {
387   - uint8_t cnt = 0;
388   - uint8_t arr[64];
389   - uint8_t sa;
390   - for(sa=0; sa<64; sa++) arr[sa]=0;
391   -
392   - //start commissioning
393   - this->cmd(DALI_RESET,0x00);
394   - this->cmd(DALI_INITIALISE,init_arg);
395   - this->cmd(DALI_RANDOMISE,0x00);
396   -
397   - //find used short addresses (run always, seems to work better than without...)
398   - for(sa = 0; sa<64; sa++) {
399   - int16_t rv = this->cmd(DALI_QUERY_STATUS,sa);
400   - if(rv!=DALI_RESULT_NO_REPLY) {
401   - if(init_arg!=0b00000000) arr[sa]=1; //remove address from list if not in "all" mode
402   - }
403   - }
404   -
405   - //find random addresses and assign unused short addresses
406   - while(1) {
407   - uint32_t adr = this->find_addr();
408   - if(adr>0xffffff) break; //no more random addresses found -> exit
409   -
410   - //find first unused short address
411   - for(sa=0; sa<64; sa++) {
412   - if(arr[sa]==0) break;
413   - }
414   - if(sa>=64) break; //all 64 short addresses assigned -> exit
415   -
416   - //mark short address as used
417   - arr[sa] = 1;
418   - cnt++;
419   -
420   - //assign short address
421   - this->program_short_address(sa);
422   -
423   - //Serial.println(this->query_short_address()); //TODO check read adr, handle if not the same...
424   -
425   - //remove the device from the search
426   - this->cmd(DALI_WITHDRAW,0x00);
427   - }
428   -
429   - //terminate the DALI_INITIALISE command
430   - this->cmd(DALI_TERMINATE,0x00);
431   - return cnt;
432   -}
433   -
434   -
435   -
436   -//======================================================================