WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/module/act_hwPWM/act_hwPWM.c



            pwmValue[channel] += (fadeSpeed[channel]*39);
            if ((fadeSpeed[channel] > 0 && (pwmValue[channel] < tempDimVal || pwmValue[channel] >= (fadeTarget[channel]))) ||
                (fadeSpeed[channel] < 0 && (pwmValue[channel] > tempDimVal || pwmValue[channel] <= (fadeTarget[channel]))))
            {
                pwmValue[channel] = (fadeTarget[channel]);
            }
            if (pwmValue[channel] > 10000) {
                pwmValue[channel] = 10000;
            }
            /* if targetvalue was reached then send the netinfo packet */
            if (pwmValue[channel] == fadeTarget[channel])
            {
                sendInfo[channel] = 1;
            }
        }
    }
 
}
#endif
 
 
void act_hwPWM_Init(void)
{

      eeprom_write_word_crc(EEDATA16.ch3, 0x0000, WITHOUT_CRC);
      eeprom_write_word_crc(EEDATA16.ch4, 0x0000, WITHOUT_CRC);
      EEDATA_UPDATE_CRC;
    }
#endif
 
    TCCR1A = 0;
    TCCR1B = 0;
    TCCR0A = 0;
    TCCR0B = 0;
 

    if (pwmValue[2]>0)
    {
        TCCR0A|=(act_hwPWM_CH3_COM<<COM0A0);
    }
    if (pwmValue[3]>0)
    {
        TCCR0A|=(act_hwPWM_CH4_COM<<COM0B0);
    }
    #endif
 
    /* enable timer 0 */
    #if act_hwPWM_CH3_COM>0
    TCCR0B|=(act_hwPWM_CH3_CS<<CS00);

            TCCR1A&=~((1<<COM1B0)|(1<<COM1B1));
        }
        else
        {
            TCCR1A|=(act_hwPWM_CH1_COM<<COM1B0);
        }
        sei();
        Timer_SetTimeout(act_hwPWM_STORE_VALUE_TIMEOUT, act_hwPWM_STORE_VALUE_TIMEOUT_TIME*1000, TimerTypeOneShot, 0);
    }
#endif
#if act_hwPWM_CH2_COM>0
    if (OCR_2 != (uint16_t)((uint32_t)pwmValue[1]*act_hwPWM_CH2_FACT)>>8) {
        cli(); 
        OCR_2=(uint16_t)(((uint32_t)pwmValue[1]*act_hwPWM_CH2_FACT)>>8);
        if (OCR_2==0)
        {
            TCCR1A&=~((1<<COM1A0)|(1<<COM1A1));
        }
        else

    if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
        StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
        rxMsg->Header.ModuleType == CAN_MODULE_TYPE_ACT_HWPWM &&
        rxMsg->Header.ModuleId == act_hwPWM_ID)
    {
        uint8_t channel = 0;
        switch (rxMsg->Header.Command)
        {
        case CAN_MODULE_CMD_PHYSICAL_PWM:
            if (rxMsg->Length == 3) {
                channel = rxMsg->Data[0];
                pwmValue[channel-1] = (rxMsg->Data[1]<<8)+(rxMsg->Data[2]);
            }
           
        break;
#if act_hwPWM_ENABLE_FADE == 1
        case CAN_MODULE_CMD_HWPWM_DEMO:     /* Demo(channel, speed, steps) */
            if (rxMsg->Length == 4) {
                channel = rxMsg->Data[0]-1;
                uint8_t speed = rxMsg->Data[1];
                uint16_t steps = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
               
                fadeSpeedCnt[channel] = 0;
                fadeSpeed[channel] = 0;

        break;
       
        case CAN_MODULE_CMD_HWPWM_START_FADE:   /* StartFade(channel, speed, direction) */
            if (rxMsg->Length == 3) {
               
                channel = rxMsg->Data[0]-1;
                uint8_t speed = rxMsg->Data[1];
                uint8_t direction = rxMsg->Data[2];
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
                fadeSpeedCnt[channel] = 0;
                fadeSpeed[channel] = 0;

            }
        break;
 
        case CAN_MODULE_CMD_HWPWM_STOP_FADE:    /* StopFade(channel) */
            if (rxMsg->Length == 1) {
                channel = rxMsg->Data[0]-1;
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
                fadeSpeed[channel] = 0;
                sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
            }
        break;
 
        case CAN_MODULE_CMD_HWPWM_ABS_FADE: /* AbsFade(channel, speed, endValue) */
            if (rxMsg->Length == 4) {
                channel = rxMsg->Data[0]-1;
                uint8_t speed = rxMsg->Data[1];
                uint16_t endValue = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
                fadeSpeedCnt[channel] = 0;
                fadeSpeed[channel] = 0;
                if (speed == 0) {
                    pwmValue[channel] = endValue;   /* set dimmer value immediately */
                    sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
                } else {
                    fadeTarget[channel] = endValue;
                    if (fadeTarget[channel] != pwmValue[channel]) {
                        if ((speed&0x80) == 0x80) {
                            fadeSpeed[channel] = (speed&0x7f)+1;
                            fadeSpeedFrac[channel] = 1;
                        } else {
                            fadeSpeed[channel] = 1;
                            fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
                        }
                        if (fadeTarget[channel] < pwmValue[channel]) {
                            fadeSpeed[channel] = -fadeSpeed[channel];
                        }
                    }
                }
                //printf("abs fade %d %d %d!\n",fadeTarget[channel], endValue ,pwmValue[channel] );
            }
        break;
 
        case CAN_MODULE_CMD_HWPWM_REL_FADE: /* RelFade(channel, speed, direction, steps) */
            if (rxMsg->Length == 5) {
               
                channel = rxMsg->Data[0]-1;
                uint8_t speed = rxMsg->Data[1];
                uint8_t direction = rxMsg->Data[2];
                uint16_t steps = (rxMsg->Data[3]<<8)+(rxMsg->Data[4]);
               
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;

                    }
                }
            }
        break;
#endif
 
        }
    }
}
 
void act_hwPWM_List(uint8_t ModuleSequenceNumber)

Rev 1566	Rev 1591
Line 64...	Line 64...
64	pwmValue[channel] += (fadeSpeed[channel]*39);	64	pwmValue[channel] += (fadeSpeed[channel]*39);
65	if ((fadeSpeed[channel] > 0 && (pwmValue[channel] < tempDimVal \|\| pwmValue[channel] >= (fadeTarget[channel]))) \|\|	65	if ((fadeSpeed[channel] > 0 && (pwmValue[channel] < tempDimVal \|\| pwmValue[channel] >= (fadeTarget[channel]))) \|\|
66	(fadeSpeed[channel] < 0 && (pwmValue[channel] > tempDimVal \|\| pwmValue[channel] <= (fadeTarget[channel]))))	66	(fadeSpeed[channel] < 0 && (pwmValue[channel] > tempDimVal \|\| pwmValue[channel] <= (fadeTarget[channel]))))
67	{	67	{
68	pwmValue[channel] = (fadeTarget[channel]);	68	pwmValue[channel] = (fadeTarget[channel]);
-		69	}
-		70	if (pwmValue[channel] > 10000) {
-		71	pwmValue[channel] = 10000;
69	}	72	}
70	/* if targetvalue was reached then send the netinfo packet */	73	/* if targetvalue was reached then send the netinfo packet */
71	if (pwmValue[channel] == fadeTarget[channel])	74	if (pwmValue[channel] == fadeTarget[channel])
72	{	75	{
73	sendInfo[channel] = 1;	76	sendInfo[channel] = 1;
74	}	77	}
75	}	78	}
76	}	79	}
77		80
78	}	81	}
79	#endif	82	#endif
80		83
81		84
82	void act_hwPWM_Init(void)	85	void act_hwPWM_Init(void)
83	{	86	{
Line 96...	Line 99...
96	eeprom_write_word_crc(EEDATA16.ch3, 0x0000, WITHOUT_CRC);	99	eeprom_write_word_crc(EEDATA16.ch3, 0x0000, WITHOUT_CRC);
97	eeprom_write_word_crc(EEDATA16.ch4, 0x0000, WITHOUT_CRC);	100	eeprom_write_word_crc(EEDATA16.ch4, 0x0000, WITHOUT_CRC);
98	EEDATA_UPDATE_CRC;	101	EEDATA_UPDATE_CRC;
99	}	102	}
100	#endif	103	#endif
101		-
102	TCCR1A = 0;	104	TCCR1A = 0;
103	TCCR1B = 0;	105	TCCR1B = 0;
104	TCCR0A = 0;	106	TCCR0A = 0;
105	TCCR0B = 0;	107	TCCR0B = 0;
106		108
Line 180...	Line 182...
180	if (pwmValue[2]>0)	182	if (pwmValue[2]>0)
181	{	183	{
182	TCCR0A\|=(act_hwPWM_CH3_COM<<COM0A0);	184	TCCR0A\|=(act_hwPWM_CH3_COM<<COM0A0);
183	}	185	}
184	if (pwmValue[3]>0)	186	if (pwmValue[3]>0)
185	{	187	{
186	TCCR0A\|=(act_hwPWM_CH4_COM<<COM0B0);	188	TCCR0A\|=(act_hwPWM_CH4_COM<<COM0B0);
187	}	189	}
188	#endif	190	#endif
189		191
190	/* enable timer 0 */	192	/* enable timer 0 */
191	#if act_hwPWM_CH3_COM>0	193	#if act_hwPWM_CH3_COM>0
192	TCCR0B\|=(act_hwPWM_CH3_CS<<CS00);	194	TCCR0B\|=(act_hwPWM_CH3_CS<<CS00);
Line 300...	Line 302...
300	TCCR1A&=~((1<<COM1B0)\|(1<<COM1B1));	302	TCCR1A&=~((1<<COM1B0)\|(1<<COM1B1));
301	}	303	}
302	else	304	else
303	{	305	{
304	TCCR1A\|=(act_hwPWM_CH1_COM<<COM1B0);	306	TCCR1A\|=(act_hwPWM_CH1_COM<<COM1B0);
305	}	307	}
306	sei();	308	sei();
307	Timer_SetTimeout(act_hwPWM_STORE_VALUE_TIMEOUT, act_hwPWM_STORE_VALUE_TIMEOUT_TIME*1000, TimerTypeOneShot, 0);	309	Timer_SetTimeout(act_hwPWM_STORE_VALUE_TIMEOUT, act_hwPWM_STORE_VALUE_TIMEOUT_TIME*1000, TimerTypeOneShot, 0);
308	}	310	}
309	#endif	311	#endif
310	#if act_hwPWM_CH2_COM>0	312	#if act_hwPWM_CH2_COM>0
311	if (OCR_2 != (uint16_t)((uint32_t)pwmValue[1]*act_hwPWM_CH2_FACT)>>8) {	313	if (OCR_2 != (uint16_t)((uint32_t)pwmValue[1]*act_hwPWM_CH2_FACT)>>8) {
312	cli();	314	cli();
313	OCR_2=(uint16_t)((uint32_t~~)pwmValue[~~1]*act_hwPWM_CH2_FACT)>>8;	315	OCR_2=(uint16_t)(((uint32_t)pwmValue[1]*act_hwPWM_CH2_FACT)>>8);
314	if (OCR_2==0)	316	if (OCR_2==0)
315	{	317	{
316	TCCR1A&=~((1<<COM1A0)\|(1<<COM1A1));	318	TCCR1A&=~((1<<COM1A0)\|(1<<COM1A1));
317	}	319	}
318	else	320	else
Line 362...	Line 364...
362	if ( StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&	364	if ( StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
363	StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&	365	StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
364	rxMsg->Header.ModuleType == CAN_MODULE_TYPE_ACT_HWPWM &&	366	rxMsg->Header.ModuleType == CAN_MODULE_TYPE_ACT_HWPWM &&
365	rxMsg->Header.ModuleId == act_hwPWM_ID)	367	rxMsg->Header.ModuleId == act_hwPWM_ID)
366	{	368	{
-		369	uint8_t channel = 0;
367	switch (rxMsg->Header.Command)	370	switch (rxMsg->Header.Command)
368	{	371	{
369	case CAN_MODULE_CMD_PHYSICAL_PWM:	372	case CAN_MODULE_CMD_PHYSICAL_PWM:
370	if (rxMsg->Length == 3) {	373	if (rxMsg->Length == 3) {
371	~~uint8_t~~ channel = rxMsg->Data[0];	374	channel = rxMsg->Data[0];
372	pwmValue[channel-1] = (rxMsg->Data[1]<<8)+(rxMsg->Data[2]);	375	pwmValue[channel-1] = (rxMsg->Data[1]<<8)+(rxMsg->Data[2]);
373	}	376	}
374		377
375	break;	378	break;
376	#if act_hwPWM_ENABLE_FADE == 1	379	#if act_hwPWM_ENABLE_FADE == 1
377	case CAN_MODULE_CMD_HWPWM_DEMO: /* Demo(channel, speed, steps) */	380	case CAN_MODULE_CMD_HWPWM_DEMO: /* Demo(channel, speed, steps) */
378	if (rxMsg->Length == 4) {	381	if (rxMsg->Length == 4) {
379	~~uint8_t~~ channel = rxMsg->Data[0]-1;	382	channel = rxMsg->Data[0]-1;
380	uint8_t speed = rxMsg->Data[1];	383	uint8_t speed = rxMsg->Data[1];
381	uint16_t steps = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);	384	uint16_t steps = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
382		385
383	fadeSpeedCnt[channel] = 0;	386	fadeSpeedCnt[channel] = 0;
384	fadeSpeed[channel] = 0;	387	fadeSpeed[channel] = 0;
Line 424...	Line 427...
424	break;	427	break;
425		428
426	case CAN_MODULE_CMD_HWPWM_START_FADE: /* StartFade(channel, speed, direction) */	429	case CAN_MODULE_CMD_HWPWM_START_FADE: /* StartFade(channel, speed, direction) */
427	if (rxMsg->Length == 3) {	430	if (rxMsg->Length == 3) {
428		431
429	~~uint8_t~~ channel = rxMsg->Data[0]-1;	432	channel = rxMsg->Data[0]-1;
430	uint8_t speed = rxMsg->Data[1];	433	uint8_t speed = rxMsg->Data[1];
431	uint8_t direction = rxMsg->Data[2];	434	uint8_t direction = rxMsg->Data[2];
432	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;	435	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
433	fadeSpeedCnt[channel] = 0;	436	fadeSpeedCnt[channel] = 0;
434	fadeSpeed[channel] = 0;	437	fadeSpeed[channel] = 0;
Line 460...	Line 463...
460	}	463	}
461	break;	464	break;
462		465
463	case CAN_MODULE_CMD_HWPWM_STOP_FADE: /* StopFade(channel) */	466	case CAN_MODULE_CMD_HWPWM_STOP_FADE: /* StopFade(channel) */
464	if (rxMsg->Length == 1) {	467	if (rxMsg->Length == 1) {
465	~~uint8_t~~ channel = rxMsg->Data[0]-1;	468	channel = rxMsg->Data[0]-1;
466	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;	469	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
467	fadeSpeed[channel] = 0;	470	fadeSpeed[channel] = 0;
468	sendInfo[channel] = 1; /* send netinfo with the current dimmervalue*/	471	sendInfo[channel] = 1; /* send netinfo with the current dimmervalue*/
469	}	472	}
470	break;	473	break;
471		474
472	case CAN_MODULE_CMD_HWPWM_ABS_FADE: /* AbsFade(channel, speed, endValue) */	475	case CAN_MODULE_CMD_HWPWM_ABS_FADE: /* AbsFade(channel, speed, endValue) */
473	if (rxMsg->Length == 4) {	476	if (rxMsg->Length == 4) {
474	~~uint8_t~~ channel = rxMsg->Data[0]-1;	477	channel = rxMsg->Data[0]-1;
475	uint8_t speed = rxMsg->Data[1];	478	uint8_t speed = rxMsg->Data[1];
476	uint16_t endValue = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);	479	uint16_t endValue = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
477	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;	480	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
478	fadeSpeedCnt[channel] = 0;	481	fadeSpeedCnt[channel] = 0;
479	fadeSpeed[channel] = 0;	482	fadeSpeed[channel] = 0;
480	if (speed == 0) {	483	if (speed == 0) {
481	pwmValue[channel] = endValue; /* set dimmer value immediately */	484	pwmValue[channel] = endValue; /* set dimmer value immediately */
482	sendInfo[channel] = 1; /* send netinfo with the current dimmervalue*/	485	sendInfo[channel] = 1; /* send netinfo with the current dimmervalue*/
483	} else {	486	} else {
484	fadeTarget[channel] = endValue;	487	fadeTarget[channel] = endValue;
485	if (fadeTarget[channel] != pwmValue[channel]) {	488	if (fadeTarget[channel] != pwmValue[channel]) {
486	if ((speed&0x80) == 0x80) {	489	if ((speed&0x80) == 0x80) {
487	fadeSpeed[channel] = (speed&0x7f)+1;	490	fadeSpeed[channel] = (speed&0x7f)+1;
488	fadeSpeedFrac[channel] = 1;	491	fadeSpeedFrac[channel] = 1;
489	} else {	492	} else {
490	fadeSpeed[channel] = 1;	493	fadeSpeed[channel] = 1;
491	fadeSpeedFrac[channel] = 0x80-(speed&0x7f);	494	fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
492	}	495	}
493	if (fadeTarget[channel] < pwmValue[channel]) {	496	if (fadeTarget[channel] < pwmValue[channel]) {
494	fadeSpeed[channel] = -fadeSpeed[channel];	497	fadeSpeed[channel] = -fadeSpeed[channel];
495	}	498	}
496	}	499	}
497	}	500	}
498	//printf("abs fade %d %d %d!\n",fadeTarget[channel], endValue ,pwmValue[channel] );	501	//printf("abs fade %d %d %d!\n",fadeTarget[channel], endValue ,pwmValue[channel] );
499	}	502	}
500	break;	503	break;
501		504
502	case CAN_MODULE_CMD_HWPWM_REL_FADE: /* RelFade(channel, speed, direction, steps) */	505	case CAN_MODULE_CMD_HWPWM_REL_FADE: /* RelFade(channel, speed, direction, steps) */
503	if (rxMsg->Length == 5) {	506	if (rxMsg->Length == 5) {
504		507
505	~~uint8_t~~ channel = rxMsg->Data[0]-1;	508	channel = rxMsg->Data[0]-1;
506	uint8_t speed = rxMsg->Data[1];	509	uint8_t speed = rxMsg->Data[1];
507	uint8_t direction = rxMsg->Data[2];	510	uint8_t direction = rxMsg->Data[2];
508	uint16_t steps = (rxMsg->Data[3]<<8)+(rxMsg->Data[4]);	511	uint16_t steps = (rxMsg->Data[3]<<8)+(rxMsg->Data[4]);
509		512
510	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;	513	demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
Line 543...	Line 546...
543	}	546	}
544	}	547	}
545	}	548	}
546	break;	549	break;
547	#endif	550	#endif
-		551
548	}	552	}
549	}	553	}
550	}	554	}
551		555
552	void act_hwPWM_List(uint8_t ModuleSequenceNumber)	556	void act_hwPWM_List(uint8_t ModuleSequenceNumber)

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/act_hwPWM/act_hwPWM.c – Rev 1566 → 1591