Subversion Repositories HomeAutomation

Rev

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

Rev 2100 Rev 2115
Line 3... Line 3...
3 
#include <avr/pgmspace.h>
 3 
#include <avr/pgmspace.h>
4 
 
 4 
 
5 
uint16_t pwmValue[4];
 5 
uint16_t pwmValue[4];
6 
uint8_t sendInfo[4] = {0,0,0,0};
 6 
uint8_t sendInfo[4] = {0,0,0,0};
7 
 
 7 
 
8 
int8_t fadeSpeed[4] = {0,0,0,0};
 8 
int8_t hw_fadeSpeed[4] = {0,0,0,0};
9 
uint8_t fadeSpeedFrac[4] = {0,0,0,0};
 9 
uint8_t hw_fadeSpeedFrac[4] = {0,0,0,0};
10 
uint16_t fadeTarget[4] = {0,0,0,0};
 10 
uint16_t hw_fadeTarget[4] = {0,0,0,0};
11 
uint8_t fadeSpeedCnt[4] = {0,0,0,0};
 11 
uint8_t hw_fadeSpeedCnt[4] = {0,0,0,0};
12 
 
 12 
 
13 
uint16_t demoEndValue[4] = {0,0,0,0};
 13 
uint16_t hw_demoEndValue[4] = {0,0,0,0};
14 
uint16_t demoHighValue[4] = {0,0,0,0};
 14 
uint16_t hw_demoHighValue[4] = {0,0,0,0};
15 
uint8_t demoState[4] = {ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING};
 15 
uint8_t hw_demoState[4] = {ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING, ACT_HWPWM_DEMO_STATE_NOT_RUNNING};
16 
 
 16 
 
17 
static uint16_t lookuptable[257] PROGMEM =
 17 
static uint16_t lookuptable[257] PROGMEM =
18 
{
 18 
{
19 
  0 ,  4    ,  8    ,  12   ,  17   ,  21   ,  25   ,  30   ,  34   ,  39   ,  //0
 19 
  0 ,  4    ,  8    ,  12   ,  17   ,  21   ,  25   ,  30   ,  34   ,  39   ,  //0
20 
43  ,  48   ,  52   ,  57   ,  62   ,  67   ,  72   ,  77   ,  82   ,  87   ,  //10
 20 
43  ,  48   ,  52   ,  57   ,  62   ,  67   ,  72   ,  77   ,  82   ,  87   ,  //10
Line 64... Line 64...
64 
void act_hwPWM_timer_callback(uint8_t timer)
 64 
void act_hwPWM_timer_callback(uint8_t timer)
65 
{
 65 
{
66 
    uint8_t channel = 0;
 66 
    uint8_t channel = 0;
67 
    for (channel = 0; channel < 4; channel++) {
 67 
    for (channel = 0; channel < 4; channel++) {
68 
        /* Check demo states */
 68 
        /* Check demo states */
69 
        if (pwmValue[channel] == fadeTarget[channel]) {
 69 
        if (pwmValue[channel] == hw_fadeTarget[channel]) {
70 
            switch (demoState[channel])
 70 
            switch (hw_demoState[channel])
71 
            {
 71 
            {
72 
            case ACT_HWPWM_DEMO_STATE_NOT_RUNNING:
 72 
            case ACT_HWPWM_DEMO_STATE_NOT_RUNNING:
73 
            break;
 73 
            break;
74 
            case ACT_HWPWM_DEMO_STATE_DECREASE:
 74 
            case ACT_HWPWM_DEMO_STATE_DECREASE:
75 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_INCREASE;
 75 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_INCREASE;
76 
                fadeTarget[channel] = demoHighValue[channel];
 76 
                hw_fadeTarget[channel] = hw_demoHighValue[channel];
77 
                fadeSpeed[channel] = -fadeSpeed[channel];
 77 
                hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
78 
            break;
 78 
            break;
79 
            case ACT_HWPWM_DEMO_STATE_INCREASE:
 79 
            case ACT_HWPWM_DEMO_STATE_INCREASE:
80 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_GOBACK;
 80 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_GOBACK;
81 
                fadeTarget[channel] = demoEndValue[channel];
 81 
                hw_fadeTarget[channel] = hw_demoEndValue[channel];
82 
                fadeSpeed[channel] = -fadeSpeed[channel];
 82 
                hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
83 
            break;
 83 
            break;
84 
            case ACT_HWPWM_DEMO_STATE_GOBACK:
 84 
            case ACT_HWPWM_DEMO_STATE_GOBACK:
85 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
 85 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
86 
            break;
 86 
            break;
87 
            }
 87 
            }
88 
        }
 88 
        }
89 
       
 89 
       
90 
        /* Change the dimmerValue according to the current fading */
 90 
        /* Change the dimmerValue according to the current fading */
91 
        fadeSpeedCnt[channel]++;
 91 
        hw_fadeSpeedCnt[channel]++;
92 
        if (fadeSpeedCnt[channel] == fadeSpeedFrac[channel] && pwmValue[channel] != (fadeTarget[channel]))
 92 
        if (hw_fadeSpeedCnt[channel] == hw_fadeSpeedFrac[channel] && pwmValue[channel] != (hw_fadeTarget[channel]))
93 
        {
 93 
        {
94 
            fadeSpeedCnt[channel] = 0;
 94 
            hw_fadeSpeedCnt[channel] = 0;
95 
            uint16_t tempDimVal = pwmValue[channel];
 95 
            uint16_t tempDimVal = pwmValue[channel];
96 
            pwmValue[channel] += (fadeSpeed[channel]*39);
 96 
            pwmValue[channel] += (hw_fadeSpeed[channel]*39);
97 
            if ((fadeSpeed[channel] > 0 && (pwmValue[channel] < tempDimVal || pwmValue[channel] >= (fadeTarget[channel]))) ||
 97 
            if ((hw_fadeSpeed[channel] > 0 && (pwmValue[channel] < tempDimVal || pwmValue[channel] >= (hw_fadeTarget[channel]))) ||
98 
                (fadeSpeed[channel] < 0 && (pwmValue[channel] > tempDimVal || pwmValue[channel] <= (fadeTarget[channel]))))
 98 
                (hw_fadeSpeed[channel] < 0 && (pwmValue[channel] > tempDimVal || pwmValue[channel] <= (hw_fadeTarget[channel]))))
99 
            {
 99 
            {
100 
                pwmValue[channel] = (fadeTarget[channel]);
 100 
                pwmValue[channel] = (hw_fadeTarget[channel]);
101 
            }
 101 
            }
102 
            if (pwmValue[channel] > 10000) {
 102 
            if (pwmValue[channel] > 10000) {
103 
                pwmValue[channel] = 10000;
 103 
                pwmValue[channel] = 10000;
104 
            }
 104 
            }
105 
            /* if targetvalue was reached then send the netinfo packet */
 105 
            /* if targetvalue was reached then send the netinfo packet */
106 
            if (pwmValue[channel] == fadeTarget[channel])
 106 
            if (pwmValue[channel] == hw_fadeTarget[channel])
107 
            {
 107 
            {
108 
                sendInfo[channel] = 1;
 108 
                sendInfo[channel] = 1;
109 
            }
 109 
            }
110 
        }
 110 
        }
111 
    }
 111 
    }
Line 439... Line 439...
439 
            if (rxMsg->Length == 4) {
 439 
            if (rxMsg->Length == 4) {
440 
                channel = rxMsg->Data[0];
 440 
                channel = rxMsg->Data[0];
441 
                uint8_t speed = rxMsg->Data[1];
 441 
                uint8_t speed = rxMsg->Data[1];
442 
                uint16_t steps = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
 442 
                uint16_t steps = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
443 
               
 443 
               
444 
                fadeSpeedCnt[channel] = 0;
 444 
                hw_fadeSpeedCnt[channel] = 0;
445 
                fadeSpeed[channel] = 0;
 445 
                hw_fadeSpeed[channel] = 0;
446 
                if (speed == 0) {
 446 
                if (speed == 0) {
447 
                    /* do nothing */
 447 
                    /* do nothing */
448 
                } else {
 448 
                } else {
449 
                    uint16_t diffToMin = pwmValue[channel] - ACT_HWPWM_MIN_DIM;
 449 
                    uint16_t diffToMin = pwmValue[channel] - ACT_HWPWM_MIN_DIM;
450 
                    uint16_t diffToMax = ACT_HWPWM_MAX_DIM - pwmValue[channel];
 450 
                    uint16_t diffToMax = ACT_HWPWM_MAX_DIM - pwmValue[channel];
451 
               
 451 
               
452 
                    demoEndValue[channel] = pwmValue[channel];
 452 
                    hw_demoEndValue[channel] = pwmValue[channel];
453 
                    if (diffToMin >= steps && diffToMax >= steps)
 453 
                    if (diffToMin >= steps && diffToMax >= steps)
454 
                    {
 454 
                    {
455 
                        /* not close to min or max */
 455 
                        /* not close to min or max */
456 
                        fadeTarget[channel] = pwmValue[channel] - steps;
 456 
                        hw_fadeTarget[channel] = pwmValue[channel] - steps;
457 
                        demoHighValue[channel] = pwmValue[channel] + steps;
 457 
                        hw_demoHighValue[channel] = pwmValue[channel] + steps;
458 
                    }
 458 
                    }
459 
                    else if (diffToMin >= steps)
 459 
                    else if (diffToMin >= steps)
460 
                    {
 460 
                    {
461 
                        /* close to max */
 461 
                        /* close to max */
462 
                        fadeTarget[channel] = pwmValue[channel] - steps - steps + diffToMax;
 462 
                        hw_fadeTarget[channel] = pwmValue[channel] - steps - steps + diffToMax;
463 
                        demoHighValue[channel] = ACT_HWPWM_MAX_DIM;
 463 
                        hw_demoHighValue[channel] = ACT_HWPWM_MAX_DIM;
464 
                    }
 464 
                    }
465 
                    else if (diffToMax >= steps)
 465 
                    else if (diffToMax >= steps)
466 
                    {
 466 
                    {
467 
                        /* close to min */
 467 
                        /* close to min */
468 
                        fadeTarget[channel] = ACT_HWPWM_MIN_DIM;
 468 
                        hw_fadeTarget[channel] = ACT_HWPWM_MIN_DIM;
469 
                        demoHighValue[channel] = pwmValue[channel] + steps + steps - diffToMin;
 469 
                        hw_demoHighValue[channel] = pwmValue[channel] + steps + steps - diffToMin;
470 
                    }
 470 
                    }
471 
                    demoState[channel] = ACT_HWPWM_DEMO_STATE_DECREASE;
 471 
                    hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_DECREASE;
472 
               
 472 
               
473 
                    if ((speed&0x80) == 0x80) {
 473 
                    if ((speed&0x80) == 0x80) {
474 
                        fadeSpeed[channel] = (speed&0x7f)+1;
 474 
                        hw_fadeSpeed[channel] = (speed&0x7f)+1;
475 
                        fadeSpeedFrac[channel] = 1;
 475 
                        hw_fadeSpeedFrac[channel] = 1;
476 
                    } else {
 476 
                    } else {
477 
                        fadeSpeed[channel] = 1;
 477 
                        hw_fadeSpeed[channel] = 1;
478 
                        fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
 478 
                        hw_fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
479 
                    }
 479 
                    }
480 
                    if (fadeTarget[channel] <= pwmValue[channel]) {
 480 
                    if (hw_fadeTarget[channel] <= pwmValue[channel]) {
481 
                        fadeSpeed[channel] = -fadeSpeed[channel];
 481 
                        hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
482 
                    }
 482 
                    }
483 
                }
 483 
                }
484 
            }
 484 
            }
485 
        break;
 485 
        break;
486 
       
 486 
       
Line 488... Line 488...
488 
            if (rxMsg->Length == 3) {
 488 
            if (rxMsg->Length == 3) {
489 
               
 489 
               
490 
                channel = rxMsg->Data[0];
 490 
                channel = rxMsg->Data[0];
491 
                uint8_t speed = rxMsg->Data[1];
 491 
                uint8_t speed = rxMsg->Data[1];
492 
                uint8_t direction = rxMsg->Data[2];
 492 
                uint8_t direction = rxMsg->Data[2];
493 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
 493 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
494 
                fadeSpeedCnt[channel] = 0;
 494 
                hw_fadeSpeedCnt[channel] = 0;
495 
                fadeSpeed[channel] = 0;
 495 
                hw_fadeSpeed[channel] = 0;
496 
                uint16_t endValue = 0;
 496 
                uint16_t endValue = 0;
497 
                if (direction == CAN_MODULE_ENUM_HWPWM_START_FADE_DIRECTION_INCREASE) {
 497 
                if (direction == CAN_MODULE_ENUM_HWPWM_START_FADE_DIRECTION_INCREASE) {
498 
                    endValue = ACT_HWPWM_MAX_DIM;
 498 
                    endValue = ACT_HWPWM_MAX_DIM;
499 
                } else if (direction == CAN_MODULE_ENUM_HWPWM_START_FADE_DIRECTION_DECREASE) {
 499 
                } else if (direction == CAN_MODULE_ENUM_HWPWM_START_FADE_DIRECTION_DECREASE) {
500 
                    endValue = ACT_HWPWM_MIN_DIM;
 500 
                    endValue = ACT_HWPWM_MIN_DIM;
Line 502... Line 502...
502 
                   
 502 
                   
503 
                if (speed == 0) {
 503 
                if (speed == 0) {
504 
                    pwmValue[channel] = endValue;   /* set dimmer value immediately */
 504 
                    pwmValue[channel] = endValue;   /* set dimmer value immediately */
505 
                    sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
 505 
                    sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
506 
                } else {
 506 
                } else {
507 
                    fadeTarget[channel] = endValue;
 507 
                    hw_fadeTarget[channel] = endValue;
508 
                    if (fadeTarget[channel] != pwmValue[channel]) {
 508 
                    if (hw_fadeTarget[channel] != pwmValue[channel]) {
509 
                        if ((speed&0x80) == 0x80) {
 509 
                        if ((speed&0x80) == 0x80) {
510 
                            fadeSpeed[channel] = (speed&0x7f)+1;
 510 
                            hw_fadeSpeed[channel] = (speed&0x7f)+1;
511 
                            fadeSpeedFrac[channel] = 1;
 511 
                            hw_fadeSpeedFrac[channel] = 1;
512 
                        } else {
 512 
                        } else {
513 
                            fadeSpeed[channel] = 1;
 513 
                            hw_fadeSpeed[channel] = 1;
514 
                            fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
 514 
                            hw_fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
515 
                        }
 515 
                        }
516 
                        if (fadeTarget[channel] < pwmValue[channel]) {
 516 
                        if (hw_fadeTarget[channel] < pwmValue[channel]) {
517 
                            fadeSpeed[channel] = -fadeSpeed[channel];
 517 
                            hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
518 
                        }
 518 
                        }
519 
                    }
 519 
                    }
520 
                }
 520 
                }
521 
            }
 521 
            }
522 
        break;
 522 
        break;
523 
 
 523 
 
524 
        case CAN_MODULE_CMD_HWPWM_STOP_FADE:    /* StopFade(channel) */
 524 
        case CAN_MODULE_CMD_HWPWM_STOP_FADE:    /* StopFade(channel) */
525 
            if (rxMsg->Length == 1) {
 525 
            if (rxMsg->Length == 1) {
526 
                channel = rxMsg->Data[0];
 526 
                channel = rxMsg->Data[0];
527 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
 527 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
528 
                fadeSpeed[channel] = 0;
 528 
                hw_fadeSpeed[channel] = 0;
529 
                sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
 529 
                sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
530 
            }
 530 
            }
531 
        break;
 531 
        break;
532 
 
 532 
 
533 
        case CAN_MODULE_CMD_HWPWM_ABS_FADE: /* AbsFade(channel, speed, endValue) */
 533 
        case CAN_MODULE_CMD_HWPWM_ABS_FADE: /* AbsFade(channel, speed, endValue) */
534 
            if (rxMsg->Length == 4) {
 534 
            if (rxMsg->Length == 4) {
535 
                channel = rxMsg->Data[0];
 535 
                channel = rxMsg->Data[0];
536 
                uint8_t speed = rxMsg->Data[1];
 536 
                uint8_t speed = rxMsg->Data[1];
537 
                uint16_t endValue = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
 537 
                uint16_t endValue = (rxMsg->Data[2]<<8)+(rxMsg->Data[3]);
538 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
 538 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
539 
                fadeSpeedCnt[channel] = 0;
 539 
                hw_fadeSpeedCnt[channel] = 0;
540 
                fadeSpeed[channel] = 0;
 540 
                hw_fadeSpeed[channel] = 0;
541 
                if (speed == 0) {
 541 
                if (speed == 0) {
542 
                    pwmValue[channel] = endValue;   /* set dimmer value immediately */
 542 
                    pwmValue[channel] = endValue;   /* set dimmer value immediately */
543 
                    sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
 543 
                    sendInfo[channel] = 1;      /* send netinfo with the current dimmervalue*/
544 
                } else {
 544 
                } else {
545 
                    fadeTarget[channel] = endValue;
 545 
                    hw_fadeTarget[channel] = endValue;
546 
                    if (fadeTarget[channel] != pwmValue[channel]) {
 546 
                    if (hw_fadeTarget[channel] != pwmValue[channel]) {
547 
                        if ((speed&0x80) == 0x80) {
 547 
                        if ((speed&0x80) == 0x80) {
548 
                            fadeSpeed[channel] = (speed&0x7f)+1;
 548 
                            hw_fadeSpeed[channel] = (speed&0x7f)+1;
549 
                            fadeSpeedFrac[channel] = 1;
 549 
                            hw_fadeSpeedFrac[channel] = 1;
550 
                        } else {
 550 
                        } else {
551 
                            fadeSpeed[channel] = 1;
 551 
                            hw_fadeSpeed[channel] = 1;
552 
                            fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
 552 
                            hw_fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
553 
                        }
 553 
                        }
554 
                        if (fadeTarget[channel] < pwmValue[channel]) {
 554 
                        if (hw_fadeTarget[channel] < pwmValue[channel]) {
555 
                            fadeSpeed[channel] = -fadeSpeed[channel];
 555 
                            hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
556 
                        }
 556 
                        }
557 
                    }
 557 
                    }
558 
                }
 558 
                }
559 
                //printf("abs fade %d %d %d!\n",fadeTarget[channel], endValue ,pwmValue[channel] );
 559 
                //printf("abs fade %d %d %d!\n",hw_fadeTarget[channel], endValue ,pwmValue[channel] );
560 
            }
 560 
            }
561 
        break;
 561 
        break;
562 
 
 562 
 
563 
        case CAN_MODULE_CMD_HWPWM_REL_FADE: /* RelFade(channel, speed, direction, steps) */
 563 
        case CAN_MODULE_CMD_HWPWM_REL_FADE: /* RelFade(channel, speed, direction, steps) */
564 
            if (rxMsg->Length == 5) {
 564 
            if (rxMsg->Length == 5) {
Line 566... Line 566...
566 
                channel = rxMsg->Data[0];
 566 
                channel = rxMsg->Data[0];
567 
                uint8_t speed = rxMsg->Data[1];
 567 
                uint8_t speed = rxMsg->Data[1];
568 
                uint8_t direction = rxMsg->Data[2];
 568 
                uint8_t direction = rxMsg->Data[2];
569 
                uint16_t steps = (rxMsg->Data[3]<<8)+(rxMsg->Data[4]);
 569 
                uint16_t steps = (rxMsg->Data[3]<<8)+(rxMsg->Data[4]);
570 
               
 570 
               
571 
                demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
 571 
                hw_demoState[channel] = ACT_HWPWM_DEMO_STATE_NOT_RUNNING;
572 
                fadeSpeedCnt[channel] = 0;
 572 
                hw_fadeSpeedCnt[channel] = 0;
573 
                fadeSpeed[channel] = 0;
 573 
                hw_fadeSpeed[channel] = 0;
574 
                uint16_t tempDimVal = pwmValue[channel];
 574 
                uint16_t tempDimVal = pwmValue[channel];
575 
                uint16_t tempDimVal2 = pwmValue[channel];
 575 
                uint16_t tempDimVal2 = pwmValue[channel];
576 
                if (direction == CAN_MODULE_ENUM_HWPWM_REL_FADE_DIRECTION_INCREASE) {                   /* if increase */
 576 
                if (direction == CAN_MODULE_ENUM_HWPWM_REL_FADE_DIRECTION_INCREASE) {                   /* if increase */
577 
                    tempDimVal2 += steps;               /* calculate new value */
 577 
                    tempDimVal2 += steps;               /* calculate new value */
578 
                    if (tempDimVal2 < tempDimVal) {     /* make overflow test */
 578 
                    if (tempDimVal2 < tempDimVal) {     /* make overflow test */
Line 586... Line 586...
586 
                }
 586 
                }
587 
                if (speed == 0) {
 587 
                if (speed == 0) {
588 
                    pwmValue[channel] = tempDimVal2;        /* set dimmer value immediately */
 588 
                    pwmValue[channel] = tempDimVal2;        /* set dimmer value immediately */
589 
                    sendInfo[channel] = 1;              /* send netinfo with the current dimmervalue*/
 589 
                    sendInfo[channel] = 1;              /* send netinfo with the current dimmervalue*/
590 
                } else {
 590 
                } else {
591 
                    fadeTarget[channel] = tempDimVal2;      /* set the fade target */
 591 
                    hw_fadeTarget[channel] = tempDimVal2;       /* set the fade target */
592 
                   
 592 
                   
593 
                    if (fadeTarget[channel] != pwmValue[channel]) {
 593 
                    if (hw_fadeTarget[channel] != pwmValue[channel]) {
594 
                        if ((speed&0x80) == 0x80) {
 594 
                        if ((speed&0x80) == 0x80) {
595 
                            fadeSpeed[channel] = (speed&0x7f)+1;
 595 
                            hw_fadeSpeed[channel] = (speed&0x7f)+1;
596 
                            fadeSpeedFrac[channel] = 1;
 596 
                            hw_fadeSpeedFrac[channel] = 1;
597 
                        } else {
 597 
                        } else {
598 
                            fadeSpeed[channel] = 1;
 598 
                            hw_fadeSpeed[channel] = 1;
599 
                            fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
 599 
                            hw_fadeSpeedFrac[channel] = 0x80-(speed&0x7f);
600 
                        }
 600 
                        }
601 
                        if (fadeTarget[channel] < pwmValue[channel]) {
 601 
                        if (hw_fadeTarget[channel] < pwmValue[channel]) {
602 
                            fadeSpeed[channel] = -fadeSpeed[channel];
 602 
                            hw_fadeSpeed[channel] = -hw_fadeSpeed[channel];
603 
                        }
 603 
                        }
604 
                    }
 604 
                    }
605 
                }
 605 
                }
606 
            }
 606 
            }
607 
        break;
 607 
        break;