Subversion Repositories HomeAutomation

Rev

Rev 897 | Rev 900 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 897 Rev 899
Line 4... Line 4...
4
//#define USEDEMO
4
//#define USEDEMO
-
 
5
 
-
 
6
int8_t fadeSpeedCh1 = 0;
-
 
7
uint8_t fadeSpeedFracCh1 = 0;
-
 
8
uint8_t fadeTargetCh1 = 0;
-
 
9
uint8_t fadeSpeedCntCh1 = 0;
5
 
10
 
6
#ifdef USEDEMO
11
#ifdef USEDEMO
7
uint8_t demo = 0;
12
uint8_t demo = 0;
8
//uint8_t demo = 2; //demo one way
13
//uint8_t demo = 2; //demo one way
9
//uint8_t demo = 3; //disable demo 
14
//uint8_t demo = 3; //disable demo 
10
uint8_t democnt = 0;
15
uint8_t democnt = 0;
11
#define DEMOSTEPS 2
16
#define DEMOSTEPS 2
12
#define DEMOSTEPS2 1
17
#define DEMOSTEPS2 1
13
#endif
18
#endif
14
 
19
 
-
 
20
//#define MEASURE_PERIOD
-
 
21
#ifdef MEASURE_PERIOD
15
//uint16_t periodTime = 0;
22
uint16_t periodTime = 0;
16
            //measured during init (by taking the time difference between two zero cross)
23
            //measured during init (by taking the time difference between two zero cross)
17
            //not used, bad idea, the powerStepTable below asumes 10000
24
            //not used, bad idea, the powerStepTable below asumes 10000
-
 
25
#endif
18
uint16_t xcTimeDiff=0;
26
uint16_t xcTimeDiff=0;
19
            //zero cross sync (difference between pos and neg flank of zero cross, divided by 2)
27
            //zero cross sync (time between pos flank of xc-detection and real zero cross)
20
uint8_t dimmerValueCh1 = 0;
28
uint8_t dimmerValueCh1 = 0;
21
            //store in eeprom later
29
            //store in eeprom later
22
            //value of 0 is zero output, value of 255 is max output
30
            //value of 0 is zero output, value of 255 is max output (ACT_DIMMMER230_MIN_DIM, ACT_DIMMMER230_MAX_DIM)
23
uint8_t state = ACT_DIMMMER230_STATE_IDLE;
31
uint8_t state = ACT_DIMMMER230_STATE_IDLE;
24
const uint16_t powerStepTable[] PROGMEM = {845, 1068, 1225, 1352, 1459, 1553, 1638, 1716, 1788, 1855, 1917, 1976, 2032, 2086, 2138, 2188, 2236, 2282, 2327, 2370, 2412, 2453, 2493, 2532, 2570, 2607, 2643, 2679, 2714, 2748, 2782, 2815, 2848, 2880, 2911, 2942, 2972, 3002, 3032, 3061, 3090, 3119, 3147, 3175, 3203, 3230, 3257, 3284, 3311, 3337, 3363, 3389, 3415, 3440, 3465, 3490, 3515, 3539, 3563, 3587, 3611, 3635, 3659, 3682, 3705, 3728, 3751, 3774, 3797, 3820, 3843, 3865, 3887, 3909, 3931, 3953, 3975, 3997, 4019, 4041, 4062, 4083, 4104, 4125, 4146, 4167, 4188, 4209, 4230, 4251, 4272, 4292, 4313, 4333, 4354, 4374, 4395, 4415, 4435, 4455, 4476, 4496, 4516, 4536, 4556, 4576, 4596, 4615, 4635, 4655, 4675, 4694, 4714, 4734, 4754, 4773, 4793, 4813, 4832, 4852, 4872, 4891, 4911, 4931, 4951, 4970, 4990};
32
const uint16_t powerStepTable[] PROGMEM = {845, 1068, 1225, 1352, 1459, 1553, 1638, 1716, 1788, 1855, 1917, 1976, 2032, 2086, 2138, 2188, 2236, 2282, 2327, 2370, 2412, 2453, 2493, 2532, 2570, 2607, 2643, 2679, 2714, 2748, 2782, 2815, 2848, 2880, 2911, 2942, 2972, 3002, 3032, 3061, 3090, 3119, 3147, 3175, 3203, 3230, 3257, 3284, 3311, 3337, 3363, 3389, 3415, 3440, 3465, 3490, 3515, 3539, 3563, 3587, 3611, 3635, 3659, 3682, 3705, 3728, 3751, 3774, 3797, 3820, 3843, 3865, 3887, 3909, 3931, 3953, 3975, 3997, 4019, 4041, 4062, 4083, 4104, 4125, 4146, 4167, 4188, 4209, 4230, 4251, 4272, 4292, 4313, 4333, 4354, 4374, 4395, 4415, 4435, 4455, 4476, 4496, 4516, 4536, 4556, 4576, 4596, 4615, 4635, 4655, 4675, 4694, 4714, 4734, 4754, 4773, 4793, 4813, 4832, 4852, 4872, 4891, 4911, 4931, 4951, 4970, 4990};
25
 
33
 
26
#if act_dimmer230_SYNC>0
34
#if act_dimmer230_SYNC>0
27
uint8_t zeroCrossCnt = 0;
35
uint8_t zeroCrossCnt = 0;
Line 29... Line 37...
29
 
37
 
30
ISR (TIMER1_COMPA_vect)
38
ISR (TIMER1_COMPA_vect)
31
{
39
{
32
    //testa hur lång denna loop behöver vara
40
    //testa hur lång denna loop behöver vara
33
    //verkar fungera upp till 249-250 sen blir det för korta pulser
41
    //verkar fungera upp till 249-250 sen blir det för korta pulser
34
    PORTC |= _BV(PC4);
42
    act_dimmer230_CHAN1_PORT |= _BV(act_dimmer230_CHAN1_BIT);
35
    uint8_t dummycnt = 240;
43
    uint8_t dummycnt = 240;
36
    while (dummycnt > 0)
44
    while (dummycnt > 0)
37
    {
45
    {
38
        dummycnt++;
46
        dummycnt++;
39
        asm("nop");
47
        asm("nop");
40
    }
48
    }
41
    PORTC &= ~_BV(PC4);        
49
    act_dimmer230_CHAN1_PORT &= ~_BV(act_dimmer230_CHAN1_BIT);         
42
   
50
   
43
    TIMSK1=0;                           //disable timer interrupt
51
    TIMSK1=0;                           //disable timer interrupt
44
    state = ACT_DIMMMER230_STATE_IDLE;
52
    state = ACT_DIMMMER230_STATE_IDLE;
45
}
53
}
46
 
54
 
Line 70... Line 78...
70
        {
78
        {
71
            newTimerVal -= ACT_DIMMMER230_PERIOD_TIME;
79
            newTimerVal -= ACT_DIMMMER230_PERIOD_TIME;
72
        }
80
        }
73
 
81
 
74
        if (dimmerValueCh1 > 0)
82
        if (dimmerValueCh1 > 0)
75
        {
83
        {
76
            TCNT1 = 0;              //reset timer1 count register
84
            TCNT1 = 0;              //reset timer1 count register
77
            OCR1A = newTimerVal;
85
            OCR1A = newTimerVal;
78
 
86
 
79
            //enable timer and timer interrupt
87
            //enable timer and timer interrupt
80
            TIFR1=(1<<OCF1A);       //clear interrupt flag before enabling interrupt
88
            TIFR1=(1<<OCF1A);       //clear interrupt flag before enabling interrupt
81
            TIMSK1|=(1<<OCIE1A);
89
            TIMSK1|=(1<<OCIE1A);
82
 
90
 
83
            state = ACT_DIMMMER230_STATE_TIMER_ON;
91
            state = ACT_DIMMMER230_STATE_TIMER_ON;
84
        }
92
        }
-
 
93
       
-
 
94
        fadeSpeedCntCh1++;
-
 
95
        if (fadeSpeedCntCh1 == fadeSpeedFracCh1)
-
 
96
        {
-
 
97
            fadeSpeedCntCh1 = 0;
-
 
98
            uint8_t tempDimVal = dimmerValueCh1;
-
 
99
            dimmerValueCh1 += fadeSpeedCh1;
-
 
100
            if ((fadeSpeedCh1 > 0 && (dimmerValueCh1 < tempDimVal || dimmerValueCh1 >= fadeTargetCh1)) ||
-
 
101
                (fadeSpeedCh1 < 0 && (dimmerValueCh1 > tempDimVal || dimmerValueCh1 <= fadeTargetCh1)))
-
 
102
            {
-
 
103
                dimmerValueCh1 = fadeTargetCh1;
-
 
104
                fadeSpeedCh1 = 0;
-
 
105
            }
-
 
106
        }
-
 
107
       
85
 
108
       
86
#if act_dimmer230_SYNC>0
109
#if act_dimmer230_SYNC>0
87
        zeroCrossCnt++;
110
        zeroCrossCnt++;
88
        if (zeroCrossCnt >= act_dimmer230_SYNC)
111
        if (zeroCrossCnt >= act_dimmer230_SYNC)
89
        {
112
        {
90
            zeroCrossCnt = 0;
113
            zeroCrossCnt = 0;
91
            //TODO: send on can
114
            //TODO: send sync-message on can
92
 
115
 
93
            StdCan_Msg_t txMsg;
116
            StdCan_Msg_t txMsg;
94
            txMsg.Length = 6;
117
            txMsg.Length = 6;
95
            txMsg.Data[0] = (newTimerVal>>8)&0xff;
118
            txMsg.Data[0] = (newTimerVal>>8)&0xff;
96
            txMsg.Data[1] = newTimerVal&0xff;
119
            txMsg.Data[1] = newTimerVal&0xff;
Line 107... Line 130...
107
                {
130
                {
108
                    democnt = 0;
131
                    democnt = 0;
109
                    uint8_t tempDim=dimmerValueCh1;
132
                    uint8_t tempDim=dimmerValueCh1;
110
                    dimmerValueCh1+=DEMOSTEPS2;
133
                    dimmerValueCh1+=DEMOSTEPS2;
111
                    if (dimmerValueCh1<tempDim && demo == 0) {
134
                    if (dimmerValueCh1<tempDim && demo == 0) {
112
                        dimmerValueCh1=255;
135
                        dimmerValueCh1=ACT_DIMMMER230_MAX_DIM;
113
                    }
136
                    }
114
                }
137
                }
115
                if (dimmerValueCh1 == 255 && demo == 0) {
138
                if (dimmerValueCh1 == ACT_DIMMMER230_MAX_DIM && demo == 0) {
116
                    demo = 1;
139
                    demo = 1;
117
                }
140
                }
118
            } else if (demo == 1) {
141
            } else if (demo == 1) {
119
                democnt++;
142
                democnt++;
120
                if (democnt==DEMOSTEPS)
143
                if (democnt==DEMOSTEPS)
121
                {
144
                {
122
                    democnt = 0;
145
                    democnt = 0;
123
                    uint8_t tempDim=dimmerValueCh1;
146
                    uint8_t tempDim=dimmerValueCh1;
124
                    dimmerValueCh1-=DEMOSTEPS2;
147
                    dimmerValueCh1-=DEMOSTEPS2;
125
                    if (dimmerValueCh1>tempDim) {
148
                    if (dimmerValueCh1>tempDim) {
126
                        dimmerValueCh1=0;
149
                        dimmerValueCh1=ACT_DIMMMER230_MIN_DIM;
127
                    }
150
                    }
128
                }
151
                }
129
                if (dimmerValueCh1 == 0) {
152
                if (dimmerValueCh1 == ACT_DIMMMER230_MIN_DIM) {
130
                    demo = 0;
153
                    demo = 0;
131
                }
154
                }
132
            }
155
            }
133
#endif //USEDEMO
156
#endif //USEDEMO
134
        }
157
        }
Line 156... Line 179...
156
    uint16_t timeAtFall = TCNT1;    //Timer_GetTicks();
179
    uint16_t timeAtFall = TCNT1;    //Timer_GetTicks();
157
    //wait for high (ac leaving zero cross)
180
    //wait for high (ac leaving zero cross)
158
    while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
181
    while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
159
    uint16_t timeAtRise = TCNT1;    //Timer_GetTicks();
182
    uint16_t timeAtRise = TCNT1;    //Timer_GetTicks();
160
 
183
 
-
 
184
#ifdef MEASURE_PERIOD
161
    //wait for low (ac approaching zero cross)
185
    //wait for low (ac approaching zero cross)
162
    //while (act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)) { }
186
    while (act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)) { }
163
    //wait for high (ac leaving zero cross)
187
    //wait for high (ac leaving zero cross)
164
    //while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
188
    while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
165
    //uint16_t timeAtRise2 = TCNT1; //Timer_GetTicks();
189
    uint16_t timeAtRise2 = TCNT1;   //Timer_GetTicks();
166
    //if (timeAtRise < timeAtRise2) {
190
    if (timeAtRise < timeAtRise2) {
167
    //  periodTime = timeAtRise2 - timeAtRise;
191
        periodTime = timeAtRise2 - timeAtRise;
168
    //}
192
    }
-
 
193
#endif
169
 
194
 
170
    // warning, watch out for wrap around on timestamps (something is broken if wrapped)
195
    // warning, watch out for wrap around on timestamps (something is broken if wrapped)
171
    if (timeAtFall < timeAtRise) {
196
    if (timeAtFall < timeAtRise) {
172
        //calculate time from falling edge to ac zero cross value
197
        //calculate time from falling edge to ac zero cross value
173
        xcTimeDiff = timeAtRise-timeAtFall;
198
        xcTimeDiff = timeAtRise-timeAtFall;
Line 185... Line 210...
185
    ///TODO: Stuff that needs doing is done here
210
    ///TODO: Stuff that needs doing is done here
186
}
211
}
187
 
212
 
188
void act_dimmer230_HandleMessage(StdCan_Msg_t *rxMsg)
213
void act_dimmer230_HandleMessage(StdCan_Msg_t *rxMsg)
189
{
214
{
190
    if (    StdCan_Ret_class(rxMsg->Header) == CAN_CLASS_MODULE_DEF && ///TODO: Change this to the actual class type
215
    if (    StdCan_Ret_class(rxMsg->Header) == CAN_CLASS_MODULE_ACT &&
191
        StdCan_Ret_direction(rxMsg->Header) == DIR_TO_OWNER &&
216
        StdCan_Ret_direction(rxMsg->Header) == DIR_TO_OWNER &&
192
        rxMsg->Header.ModuleType == CAN_TYPE_MODULE_def_default && ///TODO: Change this to the actual module type
217
        rxMsg->Header.ModuleType == CAN_TYPE_MODULE_act_Dimmer230 &&
193
        rxMsg->Header.ModuleId == act_dimmer230_ID)
218
        rxMsg->Header.ModuleId == act_dimmer230_ID)
194
    {
219
    {
195
        switch (rxMsg->Header.Command)
220
        switch (rxMsg->Header.Command)
196
        {
221
        {
-
 
222
        case CAN_CMD_MODULE_DIMMER_DEMO:        // Demo(channel, speed, steps)
-
 
223
            if (rxMsg->Length == 3) {
-
 
224
               
-
 
225
            }
197
        case 0:
226
        break;
-
 
227
       
-
 
228
        case CAN_CMD_MODULE_DIMMER_START_FADE:  // StartFade(channel, speed, direction), just an alias of ABS_FADE
-
 
229
            if (rxMsg->Length == 3) {
-
 
230
                uint8_t channel = rxMsg->Data[0];
-
 
231
                uint8_t speed = rxMsg->Data[1];
-
 
232
                uint8_t direction = rxMsg->Data[2];
-
 
233
               
-
 
234
                uint8_t endValue = 0;
-
 
235
                if (direction == 1) {
-
 
236
                    endValue = ACT_DIMMMER230_MAX_DIM;
198
        ///TODO: Do something dummy
237
                } else if (direction == 0) {
-
 
238
                    endValue = ACT_DIMMMER230_MIN_DIM;
-
 
239
                }
-
 
240
                   
-
 
241
                if (speed == 0) {
-
 
242
                    dimmerValueCh1 = endValue;  //set dimmer value immediately
-
 
243
                } else {
-
 
244
                    fadeTargetCh1 = endValue;
-
 
245
                    if (fadeTargetCh1 != dimmerValueCh1) {
-
 
246
                        if ((speed&0x80) == 0) {
-
 
247
                            fadeSpeedCh1 = speed&0x7f;
-
 
248
                            fadeSpeedFracCh1 = 1;
-
 
249
                        } else {
-
 
250
                            fadeSpeedCh1 = 1;
-
 
251
                            fadeSpeedFracCh1 = speed&0x7f;
-
 
252
                        }
-
 
253
                        if (fadeTargetCh1 < dimmerValueCh1) {
-
 
254
                            fadeSpeedCh1 = -fadeSpeedCh1;
-
 
255
                        }
-
 
256
                    }
-
 
257
                }
-
 
258
            }
-
 
259
        break;
-
 
260
 
-
 
261
        case CAN_CMD_MODULE_DIMMER_STOP_FADE:   // StopFade(channel)
-
 
262
            if (rxMsg->Length == 1) {
-
 
263
                fadeSpeedCh1 = 0;
-
 
264
            }
-
 
265
        break;
-
 
266
 
-
 
267
        case CAN_CMD_MODULE_DIMMER_ABS_FADE:    // AbsFade(channel, speed, endValue)
-
 
268
            if (rxMsg->Length == 3) {
-
 
269
                uint8_t channel = rxMsg->Data[0];
-
 
270
                uint8_t speed = rxMsg->Data[1];
-
 
271
                uint8_t endValue = rxMsg->Data[2];
-
 
272
                if (speed == 0) {
-
 
273
                    dimmerValueCh1 = endValue;  //set dimmer value immediately
-
 
274
                } else {
-
 
275
                    fadeTargetCh1 = endValue;
-
 
276
                    if (fadeTargetCh1 != dimmerValueCh1) {
-
 
277
                        if ((speed&0x80) == 0) {
-
 
278
                            fadeSpeedCh1 = speed&0x7f;
-
 
279
                            fadeSpeedFracCh1 = 1;
-
 
280
                        } else {
-
 
281
                            fadeSpeedCh1 = 1;
-
 
282
                            fadeSpeedFracCh1 = speed&0x7f;
-
 
283
                        }
-
 
284
                        if (fadeTargetCh1 < dimmerValueCh1) {
-
 
285
                            fadeSpeedCh1 = -fadeSpeedCh1;
-
 
286
                        }
-
 
287
                    }
-
 
288
                }
-
 
289
            }
-
 
290
        break;
-
 
291
 
-
 
292
        case CAN_CMD_MODULE_DIMMER_REL_FADE:    // RelFade(channel, speed, direction, steps)
-
 
293
            if (rxMsg->Length == 4) {
-
 
294
                uint8_t channel = rxMsg->Data[0];
-
 
295
                uint8_t speed = rxMsg->Data[1];
-
 
296
                uint8_t direction = rxMsg->Data[2];
-
 
297
                uint8_t steps = rxMsg->Data[3];
-
 
298
               
-
 
299
                uint8_t tempDimVal = dimmerValueCh1;
-
 
300
                uint8_t tempDimVal2 = dimmerValueCh1;
-
 
301
                if (direction == 1) {                   //if increase
-
 
302
                    tempDimVal2 += steps;               //calculate new value
-
 
303
                    if (tempDimVal2 < tempDimVal) {     //make overflow test
-
 
304
                        tempDimVal2 = ACT_DIMMMER230_MAX_DIM;
-
 
305
                    }
-
 
306
                } else if (direction == 0) {            //if decrease
-
 
307
                    tempDimVal2 -= steps;
-
 
308
                    if (tempDimVal2 > tempDimVal) {
-
 
309
                        tempDimVal2 = ACT_DIMMMER230_MIN_DIM;
-
 
310
                    }
-
 
311
                }
-
 
312
                if (speed == 0) {
-
 
313
                    dimmerValueCh1 = tempDimVal2;       //set dimmer value immediately
-
 
314
                } else {
-
 
315
                    fadeTargetCh1 = tempDimVal2;        //set the fade target
-
 
316
                   
-
 
317
                    if (fadeTargetCh1 != dimmerValueCh1) {
-
 
318
                        if ((speed&0x80) == 0) {
-
 
319
                            fadeSpeedCh1 = speed&0x7f;
-
 
320
                            fadeSpeedFracCh1 = 1;
-
 
321
                        } else {
-
 
322
                            fadeSpeedCh1 = 1;
-
 
323
                            fadeSpeedFracCh1 = speed&0x7f;
-
 
324
                        }
-
 
325
                        if (fadeTargetCh1 < dimmerValueCh1) {
-
 
326
                            fadeSpeedCh1 = -fadeSpeedCh1;
-
 
327
                        }
-
 
328
                    }
-
 
329
                }
-
 
330
               
-
 
331
            }
199
        break;
332
        break;
200
        }
333
}
201
    }
334
    }
202
}
335
}
203
 
336