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 |
5 | int8_t fadeSpeed = 0; |
| 7 | uint8_t |
6 | uint8_t fadeSpeedFrac = 0; |
| 8 | uint8_t |
7 | uint8_t fadeTarget = 0; |
| 9 | uint8_t |
8 | uint8_t fadeSpeedCnt = 0; |
| 10 | 9 | ||
| 11 | #ifdef USEDEMO |
- | |
| 12 | uint8_t |
10 | uint8_t demoEndValue = 0; |
| 13 |
|
11 | uint8_t demoHighValue = 0; |
| 14 |
|
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 |
|
14 | uint8_t netConnected = CAN_MODULE_ENUM_DIMMER230_NETINFO_CONNECTION_DISCONNECTED; |
| - | 15 | ||
| 21 |
|
16 | uint8_t frequency = CAN_MODULE_ENUM_DIMMER230_NETINFO_FREQUENCY_ERROR_UNKNOWN; |
| 22 | uint16_t periodTime = 0; |
- | |
| 23 | // |
17 | //don't calculate net frequency since the internal oscillator is not to be trusted, instead check if 50Hz or 60Hz system |
| 24 | // |
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 |
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 |
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 |
|
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 |
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 |
|
123 | uint16_t newTimerVal = xcTimeDiff; |
| 65 | 124 | ||
| 66 | if ( |
125 | if (dimmerValue > 0 && dimmerValue <= 127) |
| 67 | { |
126 | { |
| 68 | newTimerVal += |
127 | newTimerVal += ACT_DIMMMER230_50HZ_PERIOD_TIME - pgm_read_word(&powerStepTable[dimmerValue-1]); |
| 69 | } |
128 | } |
| 70 | else if ( |
129 | else if (dimmerValue < 255) |
| 71 | { |
130 | { |
| 72 | newTimerVal += pgm_read_word(&powerStepTable[254- |
131 | newTimerVal += pgm_read_word(&powerStepTable[254-dimmerValue]); |
| 73 | } |
132 | } |
| 74 | else if ( |
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 |
|
155 | fadeSpeedCnt++; |
| 97 | if ( |
156 | if (fadeSpeedCnt == fadeSpeedFrac && dimmerValue != fadeTarget) |
| 98 | { |
157 | { |
| 99 |
|
158 | fadeSpeedCnt = 0; |
| 100 | uint8_t tempDimVal = |
159 | uint8_t tempDimVal = dimmerValue; |
| 101 |
|
160 | dimmerValue += fadeSpeed; |
| 102 | if (( |
161 | if ((fadeSpeed > 0 && (dimmerValue < tempDimVal || dimmerValue >= fadeTarget)) || |
| 103 | ( |
162 | (fadeSpeed < 0 && (dimmerValue > tempDimVal || dimmerValue <= fadeTarget))) |
| 104 | { |
163 | { |
| 105 |
|
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 |
|
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 |
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 |
|
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 |
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 |
|
285 | fadeSpeedCnt = 0; |
| 251 |
|
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 |
|
295 | dimmerValue = endValue; //set dimmer value immediately |
| 261 | } else { |
296 | } else { |
| 262 |
|
297 | fadeTarget = endValue; |
| 263 | if ( |
298 | if (fadeTarget != dimmerValue) { |
| 264 | if ((speed&0x80) == 0) { |
299 | if ((speed&0x80) == 0) { |
| 265 |
|
300 | fadeSpeed = speed&0x7f; |
| 266 |
|
301 | fadeSpeedFrac = 1; |
| 267 | } else { |
302 | } else { |
| 268 |
|
303 | fadeSpeed = 1; |
| 269 |
|
304 | fadeSpeedFrac = speed&0x7f; |
| 270 | } |
305 | } |
| 271 | if ( |
306 | if (fadeTarget < dimmerValue) { |
| 272 |
|
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 |
|
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 |
|
328 | fadeSpeedCnt = 0; |
| 292 |
|
329 | fadeSpeed = 0; |
| 293 | if (speed == 0) { |
330 | if (speed == 0) { |
| 294 |
|
331 | dimmerValue = endValue; //set dimmer value immediately |
| 295 | } else { |
332 | } else { |
| 296 |
|
333 | fadeTarget = endValue; |
| 297 | if ( |
334 | if (fadeTarget != dimmerValue) { |
| 298 | if ((speed&0x80) == 0) { |
335 | if ((speed&0x80) == 0) { |
| 299 |
|
336 | fadeSpeed = speed&0x7f; |
| 300 |
|
337 | fadeSpeedFrac = 1; |
| 301 | } else { |
338 | } else { |
| 302 |
|
339 | fadeSpeed = 1; |
| 303 |
|
340 | fadeSpeedFrac = speed&0x7f; |
| 304 | } |
341 | } |
| 305 | if ( |
342 | if (fadeTarget < dimmerValue) { |
| 306 |
|
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 |
|
358 | fadeSpeedCnt = 0; |
| 321 |
|
359 | fadeSpeed = 0; |
| 322 | uint8_t tempDimVal = |
360 | uint8_t tempDimVal = dimmerValue; |
| 323 | uint8_t tempDimVal2 = |
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 |
|
374 | dimmerValue = tempDimVal2; //set dimmer value immediately |
| 337 | } else { |
375 | } else { |
| 338 |
|
376 | fadeTarget = tempDimVal2; //set the fade target |
| 339 | 377 | ||
| 340 | if ( |
378 | if (fadeTarget != dimmerValue) { |
| 341 | if ((speed&0x80) == 0) { |
379 | if ((speed&0x80) == 0) { |
| 342 |
|
380 | fadeSpeed = speed&0x7f; |
| 343 |
|
381 | fadeSpeedFrac = 1; |
| 344 | } else { |
382 | } else { |
| 345 |
|
383 | fadeSpeed = 1; |
| 346 |
|
384 | fadeSpeedFrac = speed&0x7f; |
| 347 | } |
385 | } |
| 348 | if ( |
386 | if (fadeTarget < dimmerValue) { |
| 349 |
|
387 | fadeSpeed = -fadeSpeed; |
| 350 | } |
388 | } |
| 351 | } |
389 | } |
| 352 | } |
390 | } |
| 353 | - | ||
| 354 | } |
391 | } |
| 355 | break; |
392 | break; |
| 356 | } |
393 | } |
| 357 | } |
394 | } |
| 358 | } |
395 | } |