Subversion Repositories HomeAutomation

Rev

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

Rev 1069 Rev 1075
Line 2... Line 2...
2
#include "act_dimmer230.h"
2
#include "act_dimmer230.h"
3
 
3
 
4
//#define USEDEMO
-
 
5
 
4
 
6
int8_t fadeSpeedCh1 = 0;
5
int8_t fadeSpeed = 0;
7
uint8_t fadeSpeedFracCh1 = 0;
6
uint8_t fadeSpeedFrac = 0;
8
uint8_t fadeTargetCh1 = 0;
7
uint8_t fadeTarget = 0;
9
uint8_t fadeSpeedCntCh1 = 0;
8
uint8_t fadeSpeedCnt = 0;
10
 
9
 
11
#ifdef USEDEMO
-
 
12
uint8_t demo = 0;
10
uint8_t demoEndValue = 0;
13
//uint8_t demo = 2; //demo one way
11
uint8_t demoHighValue = 0;
14
//uint8_t demo = 3; //disable demo 
12
uint8_t demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
15
uint8_t democnt = 0;
-
 
16
#define DEMOSTEPS 2
-
 
17
#define DEMOSTEPS2 1
-
 
18
#endif
-
 
19
 
13
 
20
//#define MEASURE_PERIOD
14
uint8_t netConnected = CAN_MODULE_ENUM_DIMMER230_NETINFO_CONNECTION_DISCONNECTED;
-
 
15
 
21
#ifdef MEASURE_PERIOD
16
uint8_t frequency = CAN_MODULE_ENUM_DIMMER230_NETINFO_FREQUENCY_ERROR_UNKNOWN; 
22
uint16_t periodTime = 0;
-
 
23
            //measured during init (by taking the time difference between two zero cross)
17
            //don't calculate net frequency since the internal oscillator is not to be trusted, instead check if 50Hz or 60Hz system
24
            //not used, bad idea, the powerStepTable below asumes 10000
18
            //should be used for switching powerStepTable depending on frequency
25
#endif
-
 
26
uint16_t xcTimeDiff=0;
19
uint16_t xcTimeDiff=0;
27
            //zero cross sync (time between pos flank of xc-detection and real zero cross)
20
            //zero cross sync (time between pos flank of xc-detection and real zero cross)
28
uint8_t dimmerValueCh1 = 0;
21
uint8_t dimmerValue = ACT_DIMMMER230_MIN_DIM;
29
            //store in eeprom later
22
            //store in eeprom later
30
            //value of 0 is zero output, value of 255 is max output (ACT_DIMMMER230_MIN_DIM, ACT_DIMMMER230_MAX_DIM)
23
            //value of 0 is zero output, value of 255 is max output (ACT_DIMMMER230_MIN_DIM, ACT_DIMMMER230_MAX_DIM)
31
uint8_t state = ACT_DIMMMER230_STATE_IDLE;
24
uint8_t state = ACT_DIMMMER230_STATE_IDLE;
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
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};
33
 
26
 
34
#if act_dimmer230_SYNC>0
27
#if act_dimmer230_SYNC>0
35
uint8_t zeroCrossCnt = 0;
28
uint8_t zeroCrossCnt = 0;
36
#endif
29
#endif
-
 
30
 
-
 
31
void Net_Connection_callback(uint8_t timer)
-
 
32
{
-
 
33
    netConnected = CAN_MODULE_ENUM_DIMMER230_NETINFO_CONNECTION_DISCONNECTED;
-
 
34
}
-
 
35
 
-
 
36
void Send_Status_callback(uint8_t timer)
-
 
37
{
-
 
38
    StdCan_Msg_t txMsg;
-
 
39
    StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
-
 
40
    StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
-
 
41
    txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_DIMMER230;
-
 
42
    txMsg.Header.ModuleId = act_dimmer230_ID;
-
 
43
    txMsg.Header.Command = CAN_MODULE_CMD_DIMMER230_NETINFO;
-
 
44
    txMsg.Length = 1;
-
 
45
    txMsg.Data[0] = ((netConnected&0x1)<<7 | (frequency&0x3)<<6);
-
 
46
    StdCan_Put(&txMsg);
-
 
47
}
37
 
48
 
38
ISR (TIMER1_COMPA_vect)
49
ISR (TIMER1_COMPA_vect)
39
{
50
{
40
    //testa hur lång denna loop behöver vara
51
    //testa hur lång denna loop behöver vara
41
    //verkar fungera upp till 249-250 sen blir det för korta pulser
52
    //verkar fungera upp till 249-250 sen blir det för korta pulser
Line 43... Line 54...
43
    uint8_t dummycnt = 40;
54
    uint8_t dummycnt = 40;
44
    while (dummycnt > 0)
55
    while (dummycnt > 0)
45
    {
56
    {
46
        dummycnt++;
57
        dummycnt++;
47
        asm("nop");
58
        asm("nop");
48
        asm("nop");
59
        asm("nop");
49
    }
60
    }
50
    act_dimmer230_CHAN1_PORT &= ~_BV(act_dimmer230_CHAN1_BIT);         
61
    act_dimmer230_CHAN1_PORT &= ~_BV(act_dimmer230_CHAN1_BIT);         
51
   
62
   
52
    TIMSK1=0;                           //disable timer interrupt
63
    TIMSK1=0;                           //disable timer interrupt
53
    state = ACT_DIMMMER230_STATE_IDLE;
64
    state = ACT_DIMMMER230_STATE_IDLE;
54
}
65
}
55
 
66
 
56
ISR (act_dimmer230_ZC_PCINT_vect)
67
ISR (act_dimmer230_ZC_PCINT_vect)
57
{
68
{
58
    //only execute if zerocross pin is high
69
    //only execute if zerocross pin is low (after real zerocross)
59
    if ((act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)))
70
    if (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)))
60
    {
71
    {
61
PORTD ^= (1<<PD2);
72
        xcTimeDiff = TCNT1;
-
 
73
        xcTimeDiff = xcTimeDiff >> 1; //divide by two
-
 
74
        if (xcTimeDiff > 600) {
-
 
75
            xcTimeDiff = 600;
-
 
76
        }
-
 
77
    }  
-
 
78
    //only execute if zerocross pin is high (before real zerocross)
-
 
79
    else if ((act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)))
-
 
80
    {
-
 
81
 
-
 
82
        Timer_SetTimeout(act_dimmer230_NET_CONNECT_TIMEOUT, 500, TimerTypeOneShot, &Net_Connection_callback);
-
 
83
        netConnected = CAN_MODULE_ENUM_DIMMER230_NETINFO_CONNECTION_CONNECTED;
-
 
84
       
-
 
85
        /* check frequency */
62
        uint16_t newTimerVal = xcTimeDiff;
86
        uint16_t periodTime = TCNT1;
-
 
87
        if (periodTime > ACT_DIMMMER230_50HZ_PERIOD_TIME-ACT_DIMMMER230_50HZ_PERIOD_TIME/10 && periodTime < ACT_DIMMMER230_50HZ_PERIOD_TIME+ACT_DIMMMER230_50HZ_PERIOD_TIME/10)
-
 
88
        {
-
 
89
            frequency = CAN_MODULE_ENUM_DIMMER230_NETINFO_FREQUENCY_50HZ;
-
 
90
        }
-
 
91
        else if (periodTime > ACT_DIMMMER230_60HZ_PERIOD_TIME-ACT_DIMMMER230_60HZ_PERIOD_TIME/10 && periodTime < ACT_DIMMMER230_60HZ_PERIOD_TIME+ACT_DIMMMER230_60HZ_PERIOD_TIME/10)
-
 
92
        {
-
 
93
            frequency = CAN_MODULE_ENUM_DIMMER230_NETINFO_FREQUENCY_60HZ;
-
 
94
        }
-
 
95
        else
-
 
96
        {
-
 
97
            frequency = CAN_MODULE_ENUM_DIMMER230_NETINFO_FREQUENCY_ERROR_UNKNOWN;
-
 
98
        }
-
 
99
       
-
 
100
        /* check demo states */
-
 
101
        if (dimmerValue == fadeTarget) {
-
 
102
            switch (demoState)
-
 
103
            {
-
 
104
            case ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING:
-
 
105
            break;
-
 
106
            case ACT_DIMMMER230_DEMO_STATE_DECREASE:
-
 
107
                demoState = ACT_DIMMMER230_DEMO_STATE_INCREASE;
-
 
108
                fadeTarget = demoHighValue;
-
 
109
                fadeSpeed = -fadeSpeed;
-
 
110
            break;
-
 
111
            case ACT_DIMMMER230_DEMO_STATE_INCREASE:
-
 
112
                demoState = ACT_DIMMMER230_DEMO_STATE_GOBACK;
-
 
113
                fadeTarget = demoEndValue;
-
 
114
                fadeSpeed = -fadeSpeed;
-
 
115
            break;
-
 
116
            case ACT_DIMMMER230_DEMO_STATE_GOBACK:
-
 
117
                demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
-
 
118
            break;
-
 
119
            }
-
 
120
        }
63
 
121
       
-
 
122
        /* calculate new time to triac triggering */
64
        //here new timer value is calculated 
123
        uint16_t newTimerVal = xcTimeDiff;
65
 
124
 
66
        if (dimmerValueCh1 > 0 && dimmerValueCh1 <= 127)
125
        if (dimmerValue > 0 && dimmerValue <= 127)
67
        {
126
        {
68
            newTimerVal += ACT_DIMMMER230_PERIOD_TIME - pgm_read_word(&powerStepTable[dimmerValueCh1-1]);
127
            newTimerVal += ACT_DIMMMER230_50HZ_PERIOD_TIME - pgm_read_word(&powerStepTable[dimmerValue-1]);
69
        }
128
        }
70
        else if (dimmerValueCh1 < 255)
129
        else if (dimmerValue < 255)
71
        {
130
        {
72
            newTimerVal += pgm_read_word(&powerStepTable[254-dimmerValueCh1]);
131
            newTimerVal += pgm_read_word(&powerStepTable[254-dimmerValue]);
73
        }
132
        }
74
        else if (dimmerValueCh1 == 255)
133
        else if (dimmerValue == 255)
75
        {
134
        {
76
            newTimerVal += 100; //almost max, to make sure we don't fire before zerocross
135
            newTimerVal += 100; //almost max, to make sure we don't fire before zerocross
-
 
136
        }
-
 
137
       
-
 
138
        if (newTimerVal > ACT_DIMMMER230_50HZ_PERIOD_TIME)
-
 
139
        {
-
 
140
            newTimerVal -= ACT_DIMMMER230_50HZ_PERIOD_TIME;
77
        }
141
        }
78
       
142
 
79
        if (newTimerVal > ACT_DIMMMER230_PERIOD_TIME)
-
 
80
        {
-
 
81
            newTimerVal -= ACT_DIMMMER230_PERIOD_TIME;
-
 
82
        }
-
 
83
 
-
 
84
        if (dimmerValueCh1 > 0)
-
 
85
        {
-
 
86
            TCNT1 = 0;              //reset timer1 count register
143
        TCNT1 = 0;              //reset timer1 count register
-
 
144
        if (dimmerValue > 0)
-
 
145
        {
87
            OCR1A = newTimerVal;
146
            OCR1A = newTimerVal;
88
 
147
 
89
            //enable timer and timer interrupt
148
            //enable timer and timer interrupt
90
            TIFR1=(1<<OCF1A);       //clear interrupt flag before enabling interrupt
149
            TIFR1=(1<<OCF1A);       //clear interrupt flag before enabling interrupt
91
            TIMSK1|=(1<<OCIE1A);
150
            TIMSK1|=(1<<OCIE1A);
92
 
151
 
93
            state = ACT_DIMMMER230_STATE_TIMER_ON;
152
            state = ACT_DIMMMER230_STATE_TIMER_ON;
94
        }
153
        }
95
       
154
       
96
        fadeSpeedCntCh1++;
155
        fadeSpeedCnt++;
97
        if (fadeSpeedCntCh1 == fadeSpeedFracCh1)
156
        if (fadeSpeedCnt == fadeSpeedFrac && dimmerValue != fadeTarget)
98
        {
157
        {
99
            fadeSpeedCntCh1 = 0;
158
            fadeSpeedCnt = 0;
100
            uint8_t tempDimVal = dimmerValueCh1;
159
            uint8_t tempDimVal = dimmerValue;
101
            dimmerValueCh1 += fadeSpeedCh1;
160
            dimmerValue += fadeSpeed;
102
            if ((fadeSpeedCh1 > 0 && (dimmerValueCh1 < tempDimVal || dimmerValueCh1 >= fadeTargetCh1)) ||
161
            if ((fadeSpeed > 0 && (dimmerValue < tempDimVal || dimmerValue >= fadeTarget)) ||
103
                (fadeSpeedCh1 < 0 && (dimmerValueCh1 > tempDimVal || dimmerValueCh1 <= fadeTargetCh1)))
162
                (fadeSpeed < 0 && (dimmerValue > tempDimVal || dimmerValue <= fadeTarget)))
104
            {
163
            {
105
                dimmerValueCh1 = fadeTargetCh1;
164
                dimmerValue = fadeTarget;
106
                fadeSpeedCh1 = 0;
-
 
107
            }
165
            }
108
        }
166
        }
109
       
-
 
110
       
167
       
111
#if act_dimmer230_SYNC>0
168
#if act_dimmer230_SYNC>0
112
        zeroCrossCnt++;
169
        zeroCrossCnt++;
113
        if (zeroCrossCnt >= act_dimmer230_SYNC)
170
        if (zeroCrossCnt >= act_dimmer230_SYNC)
114
        {
171
        {
115
            zeroCrossCnt = 0;
172
            zeroCrossCnt = 0;
116
            //TODO: send sync-message on can
173
            //TODO: send sync-message on can
117
 
174
 
118
            StdCan_Msg_t txMsg;
175
            /*StdCan_Msg_t txMsg;
119
            txMsg.Length = 6;
176
            txMsg.Length = 6;
120
            txMsg.Data[0] = (newTimerVal>>8)&0xff;
177
            txMsg.Data[0] = (newTimerVal>>8)&0xff;
121
            txMsg.Data[1] = newTimerVal&0xff;
178
            txMsg.Data[1] = newTimerVal&0xff;
122
            //txMsg.Data[2] = (periodTime>>8)&0xff;
179
            txMsg.Data[2] = frequency;  //(periodTime>>8)&0xff;
123
            //txMsg.Data[3] = periodTime&0xff;
180
            //txMsg.Data[3] = periodTime&0xff;
124
            txMsg.Data[4] = (xcTimeDiff>>8)&0xff;
181
            txMsg.Data[4] = (xcTimeDiff>>8)&0xff;
125
            txMsg.Data[5] = xcTimeDiff&0xff;
182
            txMsg.Data[5] = xcTimeDiff&0xff;
126
            StdCan_Put(&txMsg);
183
            StdCan_Put(&txMsg); */
127
 
-
 
128
#ifdef USEDEMO
-
 
129
            if (demo == 0 || demo == 2) {
-
 
130
                democnt++;
-
 
131
                if (democnt==DEMOSTEPS)
-
 
132
                {
-
 
133
                    democnt = 0;
-
 
134
                    uint8_t tempDim=dimmerValueCh1;
-
 
135
                    dimmerValueCh1+=DEMOSTEPS2;
-
 
136
                    if (dimmerValueCh1<tempDim && demo == 0) {
-
 
137
                        dimmerValueCh1=ACT_DIMMMER230_MAX_DIM;
-
 
138
                    }
-
 
139
                }
-
 
140
                if (dimmerValueCh1 == ACT_DIMMMER230_MAX_DIM && demo == 0) {
-
 
141
                    demo = 1;
-
 
142
                }
-
 
143
            } else if (demo == 1) {
-
 
144
                democnt++;
-
 
145
                if (democnt==DEMOSTEPS)
-
 
146
                {
-
 
147
                    democnt = 0;
-
 
148
                    uint8_t tempDim=dimmerValueCh1;
-
 
149
                    dimmerValueCh1-=DEMOSTEPS2;
-
 
150
                    if (dimmerValueCh1>tempDim) {
-
 
151
                        dimmerValueCh1=ACT_DIMMMER230_MIN_DIM;
-
 
152
                    }
-
 
153
                }
-
 
154
                if (dimmerValueCh1 == ACT_DIMMMER230_MIN_DIM) {
-
 
155
                    demo = 0;
-
 
156
                }
-
 
157
            }
-
 
158
#endif //USEDEMO
-
 
159
        }
184
        }
160
#endif      
185
#endif      
161
    }
186
    }
-
 
187
 
-
 
188
//lastDimmerValue = dimmerValue;
-
 
189
//timerValue = TCNT1;
162
}
190
}
163
 
191
 
164
void act_dimmer230_Init(void)
192
void act_dimmer230_Init(void)
165
{
193
{
166
DDRD |= (1<<PD2);
-
 
167
PORTD &= ~(1<<PD2);
-
 
168
 
-
 
169
    // set dimmer channel1 port to output 0
194
    // set dimmer channel1 port to output 0
170
    act_dimmer230_CHAN1_PORT &= ~_BV(act_dimmer230_CHAN1_BIT);
195
    act_dimmer230_CHAN1_PORT &= ~_BV(act_dimmer230_CHAN1_BIT);
171
    act_dimmer230_CHAN1_DDR |= _BV(act_dimmer230_CHAN1_BIT);
196
    act_dimmer230_CHAN1_DDR |= _BV(act_dimmer230_CHAN1_BIT);
172
    // set zero cross detection port to input, no pullup
197
    // set zero cross detection port to input, no pullup
173
    act_dimmer230_ZC_PORT &= ~_BV(act_dimmer230_ZC_BIT);
198
    act_dimmer230_ZC_PORT &= ~_BV(act_dimmer230_ZC_BIT);
174
    act_dimmer230_ZC_DDR &= ~_BV(act_dimmer230_ZC_BIT);
199
    act_dimmer230_ZC_DDR &= ~_BV(act_dimmer230_ZC_BIT);
175
   
200
   
176
    TIMSK1=0;                           //disable timer interrupt
201
    TIMSK1=0;                           //disable timer interrupt
177
    TCCR1A=0;
202
    TCCR1A=0;
178
   
203
   
179
    //wait for low (ac leaving zero cross)
-
 
180
    while (act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)) { }
-
 
181
    TCCR1B=(1<<CS11);                   //enable timer, set to prescaler 8, must be changed if cpu freq is changed
204
    TCCR1B=(1<<CS11);                   //enable timer, set to prescaler 8, must be changed if cpu freq is changed
182
    //wait for high (ac approaching zero cross)
-
 
183
    while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
-
 
184
    uint16_t timeAtFall = TCNT1;    //Timer_GetTicks();
-
 
185
    //wait for low (ac leaving zero cross)
-
 
186
    while (act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)) { }
-
 
187
    uint16_t timeAtRise = TCNT1;    //Timer_GetTicks();
-
 
188
 
-
 
189
#ifdef MEASURE_PERIOD
-
 
190
    //wait for high (ac approaching zero cross)
-
 
191
    while (!(act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT))) { }
-
 
192
    //wait for low (ac leaving zero cross)
-
 
193
    while (act_dimmer230_ZC_PIN&(1<<act_dimmer230_ZC_BIT)) { }
-
 
194
    uint16_t timeAtRise2 = TCNT1;   //Timer_GetTicks();
-
 
195
    if (timeAtRise < timeAtRise2) {
-
 
196
        periodTime = timeAtRise2 - timeAtRise;
-
 
197
    }
-
 
198
#endif
-
 
199
 
-
 
200
    // warning, watch out for wrap around on timestamps (something is broken if wrapped)
-
 
201
    if (timeAtFall < timeAtRise) {
-
 
202
        //calculate time from falling edge to ac zero cross value
-
 
203
        xcTimeDiff = timeAtRise-timeAtFall;
-
 
204
        xcTimeDiff = xcTimeDiff >> 1; //divide by two
-
 
205
    }
-
 
206
 
205
 
207
    //setup interrupt on zerocross, pcint
206
    //setup interrupt on zerocross, pcint
208
    act_dimmer230_ZC_PCMSK=(1<<act_dimmer230_ZC_PCINT_BIT);
207
    act_dimmer230_ZC_PCMSK=(1<<(act_dimmer230_ZC_PCINT_BIT));
209
    PCIFR=(1<<act_dimmer230_ZC_PCIF);   //clear any pending interrupt before enabling interrupts
208
    PCIFR=(1<<act_dimmer230_ZC_PCIF);   //clear any pending interrupt before enabling interrupts
210
    PCICR=(1<<act_dimmer230_ZC_PCIE);   //enable interrupt for PCINT
209
    PCICR=(1<<act_dimmer230_ZC_PCIE);   //enable interrupt for PCINT
211
 
210
 
212
//PORTD ^= (1<<PD2);
-
 
213
 
-
 
214
 
-
 
215
    //printf("Hello world!\n");
211
    Timer_SetTimeout(act_dimmer230_SEND_STATUS_TIMEOUT, act_dimmer230_SEND_STATUS_INTERVAL*1000, TimerTypeFreeRunning, &Send_Status_callback);
216
}
212
}
217
 
213
 
218
void act_dimmer230_Process(void)
214
void act_dimmer230_Process(void)
219
{
215
{
220
    ///TODO: Stuff that needs doing is done here
216
    ///TODO: Stuff that needs doing is done here
221
/*if (PIND & (1<<PD7)) {
-
 
222
    PORTD |= (1<<PD2);
-
 
223
} else {
-
 
224
    PORTD &= ~(1<<PD2);
-
 
225
}*/
-
 
226
 
217
 
227
}
218
}
228
 
219
 
229
void act_dimmer230_HandleMessage(StdCan_Msg_t *rxMsg)
220
void act_dimmer230_HandleMessage(StdCan_Msg_t *rxMsg)
230
{
221
{
Line 235... Line 226...
235
    {
226
    {
236
        switch (rxMsg->Header.Command)
227
        switch (rxMsg->Header.Command)
237
        {
228
        {
238
        case CAN_MODULE_CMD_DIMMER230_DEMO:     // Demo(channel, speed, steps)
229
        case CAN_MODULE_CMD_DIMMER230_DEMO:     // Demo(channel, speed, steps)
239
            if (rxMsg->Length == 3) {
230
            if (rxMsg->Length == 3) {
-
 
231
                uint8_t channel = rxMsg->Data[0];
-
 
232
                uint8_t speed = rxMsg->Data[1];
-
 
233
                uint8_t steps = rxMsg->Data[2];
-
 
234
               
-
 
235
                if (speed == 0) {
-
 
236
                    //do nothing
-
 
237
                } else {
-
 
238
                    uint8_t diffToMin = dimmerValue - ACT_DIMMMER230_MIN_DIM;
-
 
239
                    uint8_t diffToMax = ACT_DIMMMER230_MAX_DIM - dimmerValue;
-
 
240
               
-
 
241
                    demoEndValue = dimmerValue;
-
 
242
                    if (diffToMin >= steps && diffToMax >= steps)
-
 
243
                    {
-
 
244
                        //not close to min or max
-
 
245
                        fadeTarget = dimmerValue - steps;
-
 
246
                        demoHighValue = dimmerValue + steps;
-
 
247
                    }
-
 
248
                    else if (diffToMin >= steps)
-
 
249
                    {
-
 
250
                        //close to max
-
 
251
                        fadeTarget = dimmerValue - steps - diffToMax;
-
 
252
                        demoHighValue = ACT_DIMMMER230_MAX_DIM;
-
 
253
                    }
-
 
254
                    else if (diffToMax >= steps)
-
 
255
                    {
-
 
256
                        //close to min
-
 
257
                        fadeTarget = ACT_DIMMMER230_MIN_DIM;
-
 
258
                        demoHighValue = dimmerValue + steps + diffToMin;
-
 
259
                    }
-
 
260
                    demoState = ACT_DIMMMER230_DEMO_STATE_DECREASE;
240
               
261
               
-
 
262
                    if (fadeTarget != dimmerValue) {
-
 
263
                        if ((speed&0x80) == 0) {
-
 
264
                            fadeSpeed = speed&0x7f;
-
 
265
                            fadeSpeedFrac = 1;
-
 
266
                        } else {
-
 
267
                            fadeSpeed = 1;
-
 
268
                            fadeSpeedFrac = speed&0x7f;
-
 
269
                        }
-
 
270
                        if (fadeTarget < dimmerValue) {
-
 
271
                            fadeSpeed = -fadeSpeed;
-
 
272
                        }
-
 
273
                    }
-
 
274
                }
241
            }
275
            }
242
        break;
276
        break;
243
       
277
       
244
        case CAN_MODULE_CMD_DIMMER230_START_FADE:   // StartFade(channel, speed, direction), just an alias of ABS_FADE
278
        case CAN_MODULE_CMD_DIMMER230_START_FADE:   // StartFade(channel, speed, direction), just an alias of AbsFade
245
            if (rxMsg->Length == 3) {
279
            if (rxMsg->Length == 3) {
-
 
280
                demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
246
                uint8_t channel = rxMsg->Data[0];
281
                uint8_t channel = rxMsg->Data[0];
247
                uint8_t speed = rxMsg->Data[1];
282
                uint8_t speed = rxMsg->Data[1];
248
                uint8_t direction = rxMsg->Data[2];
283
                uint8_t direction = rxMsg->Data[2];
249
               
284
               
250
                fadeSpeedCntCh1 = 0;
285
                fadeSpeedCnt = 0;
251
                fadeSpeedCh1 = 0;
286
                fadeSpeed = 0;
252
                uint8_t endValue = 0;
287
                uint8_t endValue = 0;
253
                if (direction == 1) {
288
                if (direction == 1) {
254
                    endValue = ACT_DIMMMER230_MAX_DIM;
289
                    endValue = ACT_DIMMMER230_MAX_DIM;
255
                } else if (direction == 0) {
290
                } else if (direction == 0) {
256
                    endValue = ACT_DIMMMER230_MIN_DIM;
291
                    endValue = ACT_DIMMMER230_MIN_DIM;
257
                }
292
                }
258
                   
293
                   
259
                if (speed == 0) {
294
                if (speed == 0) {
260
                    dimmerValueCh1 = endValue;  //set dimmer value immediately
295
                    dimmerValue = endValue; //set dimmer value immediately
261
                } else {
296
                } else {
262
                    fadeTargetCh1 = endValue;
297
                    fadeTarget = endValue;
263
                    if (fadeTargetCh1 != dimmerValueCh1) {
298
                    if (fadeTarget != dimmerValue) {
264
                        if ((speed&0x80) == 0) {
299
                        if ((speed&0x80) == 0) {
265
                            fadeSpeedCh1 = speed&0x7f;
300
                            fadeSpeed = speed&0x7f;
266
                            fadeSpeedFracCh1 = 1;
301
                            fadeSpeedFrac = 1;
267
                        } else {
302
                        } else {
268
                            fadeSpeedCh1 = 1;
303
                            fadeSpeed = 1;
269
                            fadeSpeedFracCh1 = speed&0x7f;
304
                            fadeSpeedFrac = speed&0x7f;
270
                        }
305
                        }
271
                        if (fadeTargetCh1 < dimmerValueCh1) {
306
                        if (fadeTarget < dimmerValue) {
272
                            fadeSpeedCh1 = -fadeSpeedCh1;
307
                            fadeSpeed = -fadeSpeed;
273
                        }
308
                        }
274
                    }
309
                    }
275
                }
310
                }
276
            }
311
            }
277
        break;
312
        break;
278
 
313
 
279
        case CAN_MODULE_CMD_DIMMER230_STOP_FADE:    // StopFade(channel)
314
        case CAN_MODULE_CMD_DIMMER230_STOP_FADE:    // StopFade(channel)
280
            if (rxMsg->Length == 1) {
315
            if (rxMsg->Length == 1) {
-
 
316
                demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
281
                fadeSpeedCh1 = 0;
317
                fadeSpeed = 0;
282
            }
318
            }
283
        break;
319
        break;
284
 
320
 
285
        case CAN_MODULE_CMD_DIMMER230_ABS_FADE: // AbsFade(channel, speed, endValue)
321
        case CAN_MODULE_CMD_DIMMER230_ABS_FADE: // AbsFade(channel, speed, endValue)
286
            if (rxMsg->Length == 3) {
322
            if (rxMsg->Length == 3) {
-
 
323
                demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
287
                uint8_t channel = rxMsg->Data[0];
324
                uint8_t channel = rxMsg->Data[0];
288
                uint8_t speed = rxMsg->Data[1];
325
                uint8_t speed = rxMsg->Data[1];
289
                uint8_t endValue = rxMsg->Data[2];
326
                uint8_t endValue = rxMsg->Data[2];
290
 
327
 
291
                fadeSpeedCntCh1 = 0;
328
                fadeSpeedCnt = 0;
292
                fadeSpeedCh1 = 0;
329
                fadeSpeed = 0;
293
                if (speed == 0) {
330
                if (speed == 0) {
294
                    dimmerValueCh1 = endValue;  //set dimmer value immediately
331
                    dimmerValue = endValue; //set dimmer value immediately
295
                } else {
332
                } else {
296
                    fadeTargetCh1 = endValue;
333
                    fadeTarget = endValue;
297
                    if (fadeTargetCh1 != dimmerValueCh1) {
334
                    if (fadeTarget != dimmerValue) {
298
                        if ((speed&0x80) == 0) {
335
                        if ((speed&0x80) == 0) {
299
                            fadeSpeedCh1 = speed&0x7f;
336
                            fadeSpeed = speed&0x7f;
300
                            fadeSpeedFracCh1 = 1;
337
                            fadeSpeedFrac = 1;
301
                        } else {
338
                        } else {
302
                            fadeSpeedCh1 = 1;
339
                            fadeSpeed = 1;
303
                            fadeSpeedFracCh1 = speed&0x7f;
340
                            fadeSpeedFrac = speed&0x7f;
304
                        }
341
                        }
305
                        if (fadeTargetCh1 < dimmerValueCh1) {
342
                        if (fadeTarget < dimmerValue) {
306
                            fadeSpeedCh1 = -fadeSpeedCh1;
343
                            fadeSpeed = -fadeSpeed;
307
                        }
344
                        }
308
                    }
345
                    }
309
                }
346
                }
310
            }
347
            }
311
        break;
348
        break;
312
 
349
 
313
        case CAN_MODULE_CMD_DIMMER230_REL_FADE: // RelFade(channel, speed, direction, steps)
350
        case CAN_MODULE_CMD_DIMMER230_REL_FADE: // RelFade(channel, speed, direction, steps)
314
            if (rxMsg->Length == 4) {
351
            if (rxMsg->Length == 4) {
-
 
352
                demoState = ACT_DIMMMER230_DEMO_STATE_NOT_RUNNING;
315
                uint8_t channel = rxMsg->Data[0];
353
                uint8_t channel = rxMsg->Data[0];
316
                uint8_t speed = rxMsg->Data[1];
354
                uint8_t speed = rxMsg->Data[1];
317
                uint8_t direction = rxMsg->Data[2];
355
                uint8_t direction = rxMsg->Data[2];
318
                uint8_t steps = rxMsg->Data[3];
356
                uint8_t steps = rxMsg->Data[3];
319
               
357
               
320
                fadeSpeedCntCh1 = 0;
358
                fadeSpeedCnt = 0;
321
                fadeSpeedCh1 = 0;
359
                fadeSpeed = 0;
322
                uint8_t tempDimVal = dimmerValueCh1;
360
                uint8_t tempDimVal = dimmerValue;
323
                uint8_t tempDimVal2 = dimmerValueCh1;
361
                uint8_t tempDimVal2 = dimmerValue;
324
                if (direction == 1) {                   //if increase
362
                if (direction == 1) {                   //if increase
325
                    tempDimVal2 += steps;               //calculate new value
363
                    tempDimVal2 += steps;               //calculate new value
326
                    if (tempDimVal2 < tempDimVal) {     //make overflow test
364
                    if (tempDimVal2 < tempDimVal) {     //make overflow test
327
                        tempDimVal2 = ACT_DIMMMER230_MAX_DIM;
365
                        tempDimVal2 = ACT_DIMMMER230_MAX_DIM;
328
                    }
366
                    }
Line 331... Line 369...
331
                    if (tempDimVal2 > tempDimVal) {
369
                    if (tempDimVal2 > tempDimVal) {
332
                        tempDimVal2 = ACT_DIMMMER230_MIN_DIM;
370
                        tempDimVal2 = ACT_DIMMMER230_MIN_DIM;
333
                    }
371
                    }
334
                }
372
                }
335
                if (speed == 0) {
373
                if (speed == 0) {
336
                    dimmerValueCh1 = tempDimVal2;       //set dimmer value immediately
374
                    dimmerValue = tempDimVal2;      //set dimmer value immediately
337
                } else {
375
                } else {
338
                    fadeTargetCh1 = tempDimVal2;        //set the fade target
376
                    fadeTarget = tempDimVal2;       //set the fade target
339
                   
377
                   
340
                    if (fadeTargetCh1 != dimmerValueCh1) {
378
                    if (fadeTarget != dimmerValue) {
341
                        if ((speed&0x80) == 0) {
379
                        if ((speed&0x80) == 0) {
342
                            fadeSpeedCh1 = speed&0x7f;
380
                            fadeSpeed = speed&0x7f;
343
                            fadeSpeedFracCh1 = 1;
381
                            fadeSpeedFrac = 1;
344
                        } else {
382
                        } else {
345
                            fadeSpeedCh1 = 1;
383
                            fadeSpeed = 1;
346
                            fadeSpeedFracCh1 = speed&0x7f;
384
                            fadeSpeedFrac = speed&0x7f;
347
                        }
385
                        }
348
                        if (fadeTargetCh1 < dimmerValueCh1) {
386
                        if (fadeTarget < dimmerValue) {
349
                            fadeSpeedCh1 = -fadeSpeedCh1;
387
                            fadeSpeed = -fadeSpeed;
350
                        }
388
                        }
351
                    }
389
                    }
352
                }
390
                }
353
               
-
 
354
            }
391
            }
355
        break;
392
        break;
356
}
393
}
357
    }
394
    }
358
}
395
}