Subversion Repositories HomeAutomation

Rev

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

Rev 1834 Rev 1835
Line 45... Line 45...
45 
    uint8_t             sendComplete;
 45 
    uint8_t             sendComplete;
46 
    // pronto params
 46 
    // pronto params
47 
    uint8_t             sendingPronto;
 47 
    uint8_t             sendingPronto;
48 
    uint8_t             onceSeqLen;
 48 
    uint8_t             onceSeqLen;
49 
    uint8_t             repSeqLen;
 49 
    uint8_t             repSeqLen;
50 
    uint8_t             numberOfRepeats;
 - 
 
51 
} irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
 50 
} irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
52 
#endif
 51 
#endif
53 
 
 52 
 
54 
uint16_t    buf[IR_SUPPORTED_NUM_CHANNELS][MAX_NR_TIMES];
 53 
uint16_t    buf[IR_SUPPORTED_NUM_CHANNELS][MAX_NR_TIMES];
55 
 
 54 
 
Line 597... Line 596...
597 
        case sns_irTransceive_STATE_IDLE:
 596 
        case sns_irTransceive_STATE_IDLE:
598 
            /* transmission is started when a command is received on can */
 597 
            /* transmission is started when a command is received on can */
599 
            break;
 598 
            break;
600 
 
 599 
 
601 
        case sns_irTransceive_STATE_START_TRANSMIT:
 600 
        case sns_irTransceive_STATE_START_TRANSMIT:
- 
 
 601 
        {
602 
            if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) == IR_OK)
 602 
            if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) == IR_OK)
603 
            {
 603 
            {
604 
                IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen);
 604 
                IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen);
605 
                irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
 605 
                irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
606 
            }
 606 
            }
607 
            else
 607 
            else
608 
            {
 608 
            {
609 
                irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
 609 
                irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
610 
            }
 610 
            }
611 
            break;
 611 
            break;
612 
 
 612 
        }
613 
        case sns_irTransceive_STATE_START_TRANSMIT_PRONTO:
 613 
        case sns_irTransceive_STATE_START_TRANSMIT_PRONTO:
- 
 
 614 
        {
- 
 
 615 
            /* Start IR transmission. */
614 
            IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen);
 616 
            IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].onceSeqLen - 1);
- 
 
 617 
 
615 
            irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
 618 
            /* Enter transmitting state. */
616 
            irTxChannel[channel].sendingPronto = TRUE;
 619 
            irTxChannel[channel].sendingPronto = TRUE;
- 
 
 620 
            irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
- 
 
 621 
            break;
- 
 
 622 
        }
- 
 
 623 
        case sns_irTransceive_STATE_PRONTO_REPEAT:
- 
 
 624 
        {
- 
 
 625 
            /* Check if done. */
- 
 
 626 
            if (irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats && irTxChannel[channel].proto.repeats != 0xFF)
- 
 
 627 
            {
- 
 
 628 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
617 
            break;
 629 
                break;
- 
 
 630 
            }
- 
 
 631 
 
- 
 
 632 
            if (irTxChannel[channel].repeatCount < 255) {
- 
 
 633 
                irTxChannel[channel].repeatCount++;
- 
 
 634 
            }
618 
           
 635 
 
- 
 
 636 
            // repeat sequence exists?
- 
 
 637 
            if (irTxChannel[channel].repSeqLen != 0) {
- 
 
 638 
                // use repeat seq
- 
 
 639 
                uint16_t offset = ((uint16_t)irTxChannel[channel].onceSeqLen);
- 
 
 640 
                // don't transmit last passive. last passive handled by timer
- 
 
 641 
                IrTransceiver_Transmit(channel, &irTxChannel[channel].txbuf[offset], 0, ((uint16_t)irTxChannel[channel].repSeqLen) - 1);
- 
 
 642 
            }
- 
 
 643 
            else {
- 
 
 644 
                // use once seq
- 
 
 645 
                // don't transmit last passive. last passive handled by timer
- 
 
 646 
                IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen - 1);
- 
 
 647 
            }
- 
 
 648 
            irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
- 
 
 649 
        }
619 
        case sns_irTransceive_STATE_TRANSMITTING:
 650 
        case sns_irTransceive_STATE_TRANSMITTING:
- 
 
 651 
        {
620 
            if (irTxChannel[channel].sendComplete == TRUE)
 652 
            if (irTxChannel[channel].sendComplete == TRUE)
621 
            {
 653 
            {
622 
                cli();
 654 
                cli();
623 
                irTxChannel[channel].sendComplete = FALSE;
 655 
                irTxChannel[channel].sendComplete = FALSE;
624 
                sei();
 656 
                sei();
- 
 
 657 
 
- 
 
 658 
                if (irTxChannel[channel].sendingPronto)
- 
 
 659 
                {
- 
 
 660 
                    if(irTxChannel[channel].repeatCount == 0 || irTxChannel[channel].repSeqLen == 0)
- 
 
 661 
                    {
- 
 
 662 
                        // use last passive time as timeout
- 
 
 663 
                        uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].onceSeqLen - 1] / 1000;
- 
 
 664 
                        Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
- 
 
 665 
                    }
- 
 
 666 
                    else
- 
 
 667 
                    {
- 
 
 668 
                        // use last passive time as timeout
- 
 
 669 
                        uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1]  / 1000;
- 
 
 670 
                        Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
- 
 
 671 
                    }
- 
 
 672 
                    irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
- 
 
 673 
                }
- 
 
 674 
                else
- 
 
 675 
                {
625 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
 676 
                    irTxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
- 
 
 677 
                }
626 
            }
 678 
            }
627 
            break;
 679 
            break;
628 
 
 680 
        }
629 
        case sns_irTransceive_STATE_START_PAUSE:
 681 
        case sns_irTransceive_STATE_START_PAUSE:
- 
 
 682 
        {
630 
            if (irTxChannel[channel].repeatCount < irTxChannel[channel].proto.repeats)
 683 
            if (irTxChannel[channel].repeatCount < irTxChannel[channel].proto.repeats)
631 
            {
 684 
            {
632 
                irTxChannel[channel].repeatCount++;
 685 
                irTxChannel[channel].repeatCount++;
633 
            }
 686 
            }
634 
           
 687 
           
635 
            Timer_SetTimeout(irTxChannel[channel].timerNum, irTxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
 688 
            Timer_SetTimeout(irTxChannel[channel].timerNum, irTxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
636 
 
 689 
 
637 
            if (irTxChannel[channel].proto.framecnt != 255)
 690 
            if (irTxChannel[channel].proto.framecnt != 255)
638 
            {
 691 
            {
639 
                irTxChannel[channel].proto.framecnt++;
 692 
                irTxChannel[channel].proto.framecnt++;
640 
            }
 693 
            }
641 
           
 694 
           
642 
            irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
 695 
            irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
643 
            break;
 696 
            break;
644 
 
 697 
        }
645 
        case sns_irTransceive_STATE_PAUSING:
 698 
        case sns_irTransceive_STATE_PAUSING:
646 
            if (Timer_Expired(irTxChannel[channel].timerNum))
 - 
 
647 
            {
 699 
        {
648 
                if (irTxChannel[channel].sendingPronto) {
 700 
            if (irTxChannel[channel].sendingPronto)
649 
                    irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
 - 
 
650 
                }
 701 
            {
- 
 
 702 
                if (Timer_Expired(irTxChannel[channel].timerNum))
651 
                else {
 703 
                {
652 
                    irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
 704 
                    irTxChannel[channel].state = sns_irTransceive_STATE_PRONTO_REPEAT;
653 
                }
 705 
                }
- 
 
 706 
                break;
- 
 
 707 
            }
- 
 
 708 
 
- 
 
 709 
            if (Timer_Expired(irTxChannel[channel].timerNum))
- 
 
 710 
            {
- 
 
 711 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
654 
            }
 712 
            }
655 
           
 713 
           
656 
            /* transmission is stopped when such command is recevied on can */
 714 
            /* transmission is stopped when such command is recevied on can */
657 
            if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
 715 
            if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
658 
            {
 716 
            {
659 
                //TODO maybe send message on can for status? to confirm stopped sending, ready for new command
 717 
                //TODO maybe send message on can for status? to confirm stopped sending, ready for new command
660 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
 718 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
661 
            }
 719 
            }
662 
 
 - 
 
663 
            if (irTxChannel[channel].sendingPronto &&  irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
 - 
 
664 
            {
 - 
 
665 
                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
 - 
 
666 
            }
 - 
 
667 
 
 - 
 
668 
            break;
 720 
            break;
669 
 
 721 
        }
670 
        case sns_irTransceive_STATE_START_IDLE:
 722 
        case sns_irTransceive_STATE_START_IDLE:
671 
            irTxChannel[channel].stopSend = FALSE;
 723 
            irTxChannel[channel].stopSend = FALSE;
672 
            irTxChannel[channel].repeatCount = 0;
 724 
            irTxChannel[channel].repeatCount = 0;
673 
            irTxChannel[channel].proto.framecnt = 0;
 725 
            irTxChannel[channel].proto.framecnt = 0;
674 
            irTxChannel[channel].sendingPronto = FALSE;
 726 
            irTxChannel[channel].sendingPronto = FALSE;
675 
 
 - 
 
676 
            irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
 727 
            irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
677 
            break;
 728 
            break;
678 
 
 729 
 
679 
        default:
 730 
        default:
680 
            break;
 731 
            break;
681 
        }
 732 
        }
682 
#endif
 733 
#endif
683 
 
 734 
 
684 
    }
 735 
    }
685 
}
 736 
}
686 
 
 737 
 
687 
 
 738 
 
688 
/* Handle incoming CAN data */
 739 
/* Handle incoming CAN data */
689 
void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
 740 
void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
690 
{
 741 
{
- 
 
 742 
    /* Sanity check. */
691 
    if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_SNS &&
 743 
    if (StdCan_Ret_class(rxMsg->Header) != CAN_MODULE_CLASS_SNS ||
692 
        StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
 744 
        StdCan_Ret_direction(rxMsg->Header) != DIRECTIONFLAG_TO_OWNER ||
693 
        rxMsg->Header.ModuleType == CAN_MODULE_TYPE_SNS_IRTRANSCEIVE &&
 745 
        rxMsg->Header.ModuleType != CAN_MODULE_TYPE_SNS_IRTRANSCEIVE ||
694 
        rxMsg->Header.ModuleId == sns_irTransceive_ID)
 746 
        rxMsg->Header.ModuleId != sns_irTransceive_ID) return;
- 
 
 747 
 
- 
 
 748 
    /* Get IR channel. */
- 
 
 749 
    uint8_t channel = rxMsg->Data[0] >> 4;
695 
    {
 750 
 
696 
        switch (rxMsg->Header.Command)
 751 
    switch (rxMsg->Header.Command)
697 
        {
 752 
    {
698 
#if IR_TX_ENABLE==1
 753 
#if IR_TX_ENABLE==1
699 
        case CAN_MODULE_CMD_PHYSICAL_IR: {
 754 
    case CAN_MODULE_CMD_PHYSICAL_IR:
700 
            uint8_t channel = rxMsg->Data[0]>>4;
 - 
 
- 
 
 755 
    {
701 
            if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED && channel < IR_SUPPORTED_NUM_CHANNELS)
 756 
        if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED && channel < IR_SUPPORTED_NUM_CHANNELS)
702 
            {
 757 
        {
703 
                if (irTxChannel[channel].state == sns_irTransceive_STATE_IDLE)
 758 
            if (irTxChannel[channel].state == sns_irTransceive_STATE_IDLE)
704 
                {
 759 
            {
705 
                    irTxChannel[channel].proto.protocol = rxMsg->Data[1];
 760 
                irTxChannel[channel].proto.protocol = rxMsg->Data[1];
Line 726... Line 781...
726 
        }
 781 
    }
727 
       
 782 
 
728 
#if sns_irTransceive_PRONTO_SUPPORT==1
 783 
#if sns_irTransceive_PRONTO_SUPPORT==1
729 
        /* TODO: add struct which stores pronto info:
 784 
    /* TODO: add struct which stores pronto info:
730 
        channel, pronto receive state, buffer length of once burst pairs, buffer length of repeat burst pairs */
 785 
    channel, pronto receive state, buffer length of once burst pairs, buffer length of repeat burst pairs */
731 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART: {
 786 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART:
- 
 
 787 
    {
- 
 
 788 
        /* Sanity check. */
- 
 
 789 
        if (channel >= IR_SUPPORTED_NUM_CHANNELS) break;
- 
 
 790 
        if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) break;
732 
 
 791 
 
733 
            uint8_t channel = rxMsg->Data[0]>>4;
 792 
        /* Check if format is supported. */
734 
            if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
 - 
 
735 
                // invalid channel
 - 
 
736 
                break;
 - 
 
737 
            }
 - 
 
738 
 
 - 
 
739 
            printf("TxSt=%03d", irTxChannel[channel].state);
 - 
 
740 
 
 - 
 
741 
            if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) {
 - 
 
742 
                // busy
 - 
 
743 
                break;
 - 
 
744 
            }
 - 
 
745 
 
 - 
 
746 
            /* TODO: check pronto state, response is different if already sending data */
 - 
 
747 
            uint16_t format = (uint16_t)(rxMsg->Data[0] & 0x0F) << 8 | (uint16_t)(rxMsg->Data[1]);
 793 
        if ((uint16_t)(rxMsg->Data[0] & 0x0F) << 8 | (uint16_t)(rxMsg->Data[1]) != 0) break;
748 
            if (format != 0) {
 - 
 
749 
                // unsupported format
 - 
 
750 
                break;
 - 
 
751 
            }
 - 
 
752 
 
 - 
 
753 
            irTxChannel[channel].state = sns_irTransceive_STATE_PREPARING_PRONTO;
 - 
 
754 
            irTxChannel[channel].txlen = 0;
 - 
 
755 
           
 794 
 
- 
 
 795 
        /* Extract received data. */
756 
            //irTxChannel[channel].modfreq = rxMsg->Data[2];
 796 
        //irTxChannel[channel].modfreq = rxMsg->Data[2];
757 
            irTxChannel[channel].modfreq = (((F_CPU/2000)/IR_NEC_F_MOD) -1); // for testing
 797 
        irTxChannel[channel].modfreq = (((F_CPU/2000)/IR_NEC_F_MOD) -1); // for testing
758 
            irTxChannel[channel].proto.modfreq = (((F_CPU/2000)/IR_NEC_F_MOD) -1);
 798 
        irTxChannel[channel].proto.modfreq = (((F_CPU/2000)/IR_NEC_F_MOD) -1);
759 
            irTxChannel[channel].proto.timeout = 100;
 - 
 
760 
            irTxChannel[channel].proto.repeats = 2;
 799 
        // convert lenghts to bytes
761 
 
 - 
 
762 
            irTxChannel[channel].onceSeqLen = rxMsg->Data[3];
 800 
        irTxChannel[channel].onceSeqLen = 2*((((uint16_t)rxMsg->Data[4]) << 8) | (((uint16_t)rxMsg->Data[5]) << 0));
763 
            irTxChannel[channel].repSeqLen = rxMsg->Data[4];
 801 
        irTxChannel[channel].repSeqLen = 2*((((uint16_t)rxMsg->Data[6]) << 8) | (((uint16_t)rxMsg->Data[7]) << 0));
764 
 
 802 
 
- 
 
 803 
        /* Enter prepering pronto state and clear transmit buffer. */
- 
 
 804 
        irTxChannel[channel].state = sns_irTransceive_STATE_PREPARING_PRONTO;
- 
 
 805 
        irTxChannel[channel].txlen = 0;
765 
            activeChannel = channel;
 806 
        activeChannel = channel;
766 
 
 807 
 
767 
            /* TODO: Send response frame */
 808 
        /* TODO: Send response frame */
768 
            break;
 809 
        break;
769 
        }
 810 
    }
Line 792... Line 833...
792 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA11: /* Fall through */
 833 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA11: /* Fall through */
793 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through */
 834 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through */
794 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through */
 835 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through */
795 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through */
 836 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through */
796 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through */
 837 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through */
797 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA16: {
 838 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA16:
798 
            if (activeChannel>=IR_SUPPORTED_NUM_CHANNELS) {
 - 
 
799 
                break;
 - 
 
800 
            }
 839 
    {
- 
 
 840 
        // unexpected CAN msg, out of order
801 
            if (irTxChannel[activeChannel].state!=sns_irTransceive_STATE_PREPARING_PRONTO) {
 841 
        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) break;
802 
                // invalid state
 - 
 
803 
                break;
 - 
 
804 
            }
 842 
 
805 
            if ((uint16_t)irTxChannel[activeChannel].txlen+(uint16_t)rxMsg->Length >= MAX_NR_TIMES) {
 843 
        if ((uint16_t)irTxChannel[activeChannel].txlen + (uint16_t)rxMsg->Length >= MAX_NR_TIMES) {
806 
                // too long
 844 
            // too long
- 
 
 845 
            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
807 
                break;
 846 
            break;
808 
            }
 847 
        }
809 
            for (uint8_t i=0; i<rxMsg->Length; i++) {
 848 
        for (uint8_t i=0; i < rxMsg->Length; i++) {
810 
                // TODO: (109 * 1) / (4.145146 MHz) = 27, fix formula with modfreq
 849 
            // TODO: (109 * 1) / (4.145146 MHz) = 27, fix formula with modfreq
811 
                irTxChannel[activeChannel].txbuf[irTxChannel[activeChannel].txlen++] = 27*rxMsg->Data[i];
 850 
            irTxChannel[activeChannel].txbuf[irTxChannel[activeChannel].txlen++] = 27 * rxMsg->Data[i];
812 
            }
 851 
        }
813 
            break;
 852 
        break;
814 
        }
 853 
    }
815 
 
 - 
 
816 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through */
 854 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through */
817 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through */
 855 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through */
818 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through */
 856 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through */
819 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND4:   /* Fall through */
 857 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND4:   /* Fall through */
820 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND5:   /* Fall through */
 858 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND5:   /* Fall through */
Line 827... Line 865...
827 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND12:  /* Fall through */
 865 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND12:  /* Fall through */
828 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND13:  /* Fall through */
 866 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND13:  /* Fall through */
829 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through */
 867 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through */
830 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through */
 868 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through */
831 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through */
 869 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through */
832 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND17: {
 870 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND17:
833 
            if (activeChannel>=IR_SUPPORTED_NUM_CHANNELS) {
 - 
 
834 
                break;
 - 
 
835 
            }
 871 
    {
- 
 
 872 
        // unexpected CAN msg, out of order
836 
            if (irTxChannel[activeChannel].state!=sns_irTransceive_STATE_PREPARING_PRONTO) {
 873 
        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
837 
                // invalid state
 874 
            //printf("StERR:%02d", irTxChannel[activeChannel].state);
838 
                break;
 875 
            break;
839 
            }
 876 
        }
- 
 
 877 
 
840 
            if ((uint16_t)irTxChannel[activeChannel].txlen + (uint16_t)(rxMsg->Length-1) >= MAX_NR_TIMES) {
 878 
        if ((uint16_t)irTxChannel[activeChannel].txlen + (uint16_t)(rxMsg->Length - 1) >= MAX_NR_TIMES) {
841 
                // too long
 879 
            // too long
- 
 
 880 
            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
842 
                break;
 881 
            break;
843 
            }
 882 
        }
- 
 
 883 
 
- 
 
 884 
        uint16_t nrBytesRemaining = (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen)) - irTxChannel[activeChannel].txlen;
- 
 
 885 
        //printf("TXLEN:%02d", irTxChannel[activeChannel].txlen);
- 
 
 886 
        //printf("BYTES:%02d", nrBytesRemaining);
844 
            // end packet does not always contain data, last byte is reserved
 887 
        // end packet does not always contain data, last byte is reserved
845 
            for (uint8_t i=0; i<rxMsg->Length-1; i++) {
 888 
        for (uint8_t i=0; i < nrBytesRemaining; i++) {
846 
                // TODO: (109 * 1) / (4.145146 MHz) = 27, fix formula with modfreq
 889 
            // TODO: (109 * 1) / (4.145146 MHz) = 27, fix formula with modfreq
847 
                irTxChannel[activeChannel].txbuf[irTxChannel[activeChannel].txlen++] = 27*rxMsg->Data[i];
 890 
            irTxChannel[activeChannel].txbuf[irTxChannel[activeChannel].txlen++] = 27 * rxMsg->Data[i];
848 
            }
 891 
        }
- 
 
 892 
 
- 
 
 893 
        // sanity check
- 
 
 894 
        if(irTxChannel[activeChannel].txlen != (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen)))
- 
 
 895 
        {
- 
 
 896 
            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
- 
 
 897 
            break;
- 
 
 898 
        }
- 
 
 899 
 
849 
            // last byte tells what to do with IR data (nr of repeats)
 900 
        // last byte tells what to do with IR data (nr of repeats)
850 
            irTxChannel[activeChannel].numberOfRepeats = rxMsg->Data[rxMsg->Length-1];
 901 
        irTxChannel[activeChannel].proto.repeats = rxMsg->Data[rxMsg->Length-1];
- 
 
 902 
        irTxChannel[activeChannel].proto.timeout = 1;
851 
 
 903 
 
852 
            // send
 904 
        // send
853 
            irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
 905 
        irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
854 
 
 906 
 
855 
            irTxChannel[activeChannel].sendingPronto = TRUE;
 - 
 
856 
 
 - 
 
857 
            /* TODO: Send response frame */
 907 
        /* TODO: Send response frame */
858 
 
 - 
 
859 
            break;
 908 
        break;
860 
        }
 909 
    }
861 
 
 910 
 
862 
/* TODO: In IR state machine add sending a response frame when ir stops sending, also implement pronto repeat */
 911 
/* TODO: In IR state machine add sending a response frame when ir stops sending, also implement pronto repeat */
863 
#endif
 912 
#endif
864 
#endif
 913 
#endif
865 
       
 914 
 
866 
        case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG: {
 915 
    case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG: {
867 
            uint8_t channel = rxMsg->Data[0]>>4;
 - 
 
868 
            uint8_t config = rxMsg->Data[0] & 0x0f;
 916 
        uint8_t config = rxMsg->Data[0] & 0x0f;
869 
            uint8_t power = rxMsg->Data[1]>>6;
 917 
        uint8_t power = rxMsg->Data[1]>>6;
870 
            uint8_t modfreq = rxMsg->Data[2];
 918 
        uint8_t modfreq = rxMsg->Data[2];
871 
           
 919 
       
872 
            sns_irTransceive_setConfig(channel, config, power, modfreq);
 920 
        sns_irTransceive_setConfig(channel, config, power, modfreq);
873 
 
 921 
 
874 
#ifdef sns_irTransceive_USEEEPROM
 922 
#ifdef sns_irTransceive_USEEEPROM
875 
            if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
 923 
        if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
876 
            {
 924 
        {
877 
                switch (channel)
 925 
            switch (channel)
878 
                {
 926 
            {
Line 889... Line 937...
889 
                    case 2:
 937 
                case 2:
890 
                        eeprom_write_byte_crc(EEDATA.ch2_config, config, WITHOUT_CRC);
 938 
                    eeprom_write_byte_crc(EEDATA.ch2_config, config, WITHOUT_CRC);
891 
                        eeprom_write_byte_crc(EEDATA.ch2_txpower, power, WITHOUT_CRC);
 939 
                    eeprom_write_byte_crc(EEDATA.ch2_txpower, power, WITHOUT_CRC);
892 
                        eeprom_write_byte_crc(EEDATA.ch2_modfreq, modfreq, WITHOUT_CRC);
 940 
                    eeprom_write_byte_crc(EEDATA.ch2_modfreq, modfreq, WITHOUT_CRC);
893 
                        break;
 941 
                    break;
894 
                    default:
 942 
                default:
895 
                        break;
 943 
                    break;
896 
                }
 944 
            }
897 
                EEDATA_UPDATE_CRC;
 945 
            EEDATA_UPDATE_CRC;
898 
            }
 946 
        }
899 
#endif 
947 
#endif 
900 
            break;
 948 
        break;
901 
        }
 949 
    }
902 
           
 950 
 
903 
        default:
 951 
    default:
904 
            break;
 952 
        break;
905 
           
 953 
 
906 
        }
 954 
    }
907 
    }
 955 
 
908 
}
 956 
}
909 
 
 957 
 
910 
void sns_irTransceive_List(uint8_t ModuleSequenceNumber)
 958 
void sns_irTransceive_List(uint8_t ModuleSequenceNumber)
911 
{
 959 
{
912 
    StdCan_Msg_t txMsg;
 960 
    StdCan_Msg_t txMsg;