Subversion Repositories Projects

// *************************************************************
// ** Spektrum Diversity - use up to 4 satellite receivers    **
// *************************************************************
// ** Target: An Atmel ATtiny2313 (RC-Oscillator @ 8 MHz)     **
// **         controls a 74HC151 Multiplexer                  **
// *************************************************************
// ** It monitors the data from 4 satellite receivers and     **
// ** connects a valid one to the output via the multiplexer  **
// *************************************************************
// ** LED-Modes during startup (in chronological order)       **
// ** ************************                                **
// ** LED fast blink: Waiting for first datapulse             **
// ** LED slow blink: Waiting 3 seconds while counting sat's  **
// ** LED flashes:    Indicates the number of active sat's    **
// **                                                         **
// ** LED-Modes during operation                              **
// ** **************************                              **
// ** LED OFF: Everything is fine                             **
// ** LED ON:  FAILURE - The first selected sat had lost sync **
// **                                                         **
// ** LED-Modes during Self-Test                              **
// ** **************************                              **
// ** LED flashes at 1 Hz: Everything is fine                 **
// ** LED flashes some times:  FAILURE                        **
// *************************************************************
// ** (c) 2010-0xFFFF Stefan Pendsa                           **
// ** License: don't know - use it and have fun               **
// *************************************************************

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define LED_OFF PORTD |= 1 << PORTD0
#define LED_ON  PORTD &= ~(1 << PORTD0)

volatile unsigned int TimerEvent;



ISR(TIMER1_OVF_vect)                                                                            // Triggered every 8,192 msec
{
        TimerEvent++;
}



void SelectSat(unsigned char sat)
{
        PORTD = (PORTD & 0b00000001) | (sat<<3);                                // Select the Input for 74HC151
}



void ResetTimer(void)
{
        TCNT1H = 0;
        TCNT1L = 0;
        TimerEvent = 0;
}



void Binding(void)                                                                                      // Binding sequence for DX7
{
        unsigned char i = 0;

        DDRB = 0b11110000;                                                                              // Sat-Pins to output
        _delay_ms(80);                                                                                  // Let them boot up
        
        for (i=0;i<3;i++)                                                                               // send three negative 100µs pulses to all sat's
        {
                PORTB = 0b00000000;
                _delay_us(100);
                PORTB = 0b11110000;
                _delay_us(100);
        }

        _delay_ms(1000);
        DDRB = 0b00000000;                                                                              // Sat-Pins to input after 1sec
}



void Testing(void)                                                                                      // Self Test
{
        unsigned char error = 0;
        unsigned char i = 0;

        DDRB = 0b11110000;                                                                              // Port B Output for satellites, Input for feedback

        PORTB = 0b01010000;                                                                             // Test Pattern
        SelectSat(0);
        if (!(PINB & (1<<PB3))) error++;
        SelectSat(1);
        if (PINB & (1<<PB3)) error++;
        SelectSat(2);
        if (!(PINB & (1<<PB3))) error++;
        SelectSat(3);
        if (PINB & (1<<PB3)) error++;

        PORTB = 0b10100000;                                                                             // Another (inverted) Test Pattern
        SelectSat(0);
        if (PINB & (1<<PB3)) error++;
        SelectSat(1);
        if (!(PINB & (1<<PB3))) error++;
        SelectSat(2);
        if (PINB & (1<<PB3)) error++;
        SelectSat(3);
        if (!(PINB & (1<<PB3))) error++;

        DDRB = 0b00000000;                                                                              // Port B Input again

        while(1)                                                                                                // Never return
        {
                if (error == 0)                                                                         // When no error occured -> LED flashes at 1 Hz
                {
                        LED_ON;
                        _delay_ms(100);
                        LED_OFF;
                        _delay_ms(900);
                }
                else
                {
                        for (i=0;i<error;i++)                                                   // When error occured -> Flash once for every error
                        {
                                LED_ON;
                                _delay_ms(100);
                                LED_OFF;
                                _delay_ms(400);
                        }
                        _delay_ms(1000);
                }

        }

}



int main(void)
{
        unsigned char i = 0;
        unsigned char j = 0;
        unsigned char active[4];
        unsigned char sat = 4;

        DDRB = 0b00000000;                                                                              // Port B Input for satellites and feedback
        DDRD = 0b0011001;                                                                               // Port D Output for MUX and LED, Input for Switch & Test
        PORTB = 0b11110000;                                                                             // Port B Pullup's for (unused) satellites
        PORTD = 0b1100001;                                                                              // Port D Pullup's for Switch & Test, LED on

        for (i=0;i<4;i++) active[i] = 0;                                                // Reset active-array

        if (!(PIND & (1<<PD5))) Testing();                                              // Initiate Self-Test when Test-Pad is low
        if (!(PIND & (1<<PD6))) Binding();                                              // Initiate Binding when Bind-Button is pressed

        TCCR1B = ( 1 << CS10 );                                                                 // Timer1 Prescaler = 1 -> 8,192 msec
        TIMSK = ( 1 << TOIE1 );                                                                 // Timer1 Overflow Interrupt Enable
        sei();                                                                                                  // Global Interrupts enable

        ResetTimer();
        while((PINB & 0b11110000) == 0b11110000)                                // Wait for first signal (SYNC to frame)
        {
                if (TimerEvent == 10) LED_ON;                                           // Blink while waiting...
                if (TimerEvent == 20)
                {
                        LED_OFF;
                        TimerEvent = 0;
                }
        }
        LED_OFF;

        ResetTimer();
        while(1)                                                                                                // Check active satellites for 5 seconds
        {
                if (TimerEvent == 20) LED_ON;                                           // Blink (slower) while waiting...
                if (TimerEvent == 40)
                {
                        LED_OFF;
                        TimerEvent = 0;
                        j++;
                }

                for (i=0;i<4;i++)
                {
                        if (!(PINB & (1<<(i+4))))
                        {
                                active[i] = 1;
                                if (sat == 4)                                                           // Select first active satellite (only once)
                                {
                                        sat = i;
                                        SelectSat(i);
                                }

                        }
                }
                
                if (j == 16) break;                                                                     // 16 * 40 * 8ms = ~5sec
        }

        LED_OFF;
        _delay_ms(1000);

        for (i=0;i<4;i++)                                                                               // Flash once for every active satellite
        {
                if (active[i] == 1)
                {
                        LED_ON;
                        _delay_ms(100);
                        LED_OFF;
                        _delay_ms(400);
                }
        }




        while(1)                                                                                                // Main-Loop
        {
                for (i=0;i<4;i++) active[i] = 0;                                        // Reset active-array

                ResetTimer();
                while((PINB & 0b11110000) == 0b11110000)                        // Wait for first signal (SYNC to frame)
                {
                        if (TimerEvent > 3) break;                                              // (max. 3*8=24ms)
                }
                
                ResetTimer();
                while(TimerEvent < 1)                                                           // Check active satellites (for 1*8=8ms)
                {

                        for (i=0;i<4;i++)
                        {
                                if (!(PINB & (1<<(i+4))))
                                {
                                        active[i] = 1;
                                }
                        }
                }

                if (active[sat] == 0)                                                           // Detect fail on active satellite
                {
                        LED_ON;                                                                                 // Failure-LED ON
                        for (i=0;i<4;i++)                                                               // Select lowest active satellite
                        {
                                if (active[i] == 1)
                                {
                                        sat = i;
                                        SelectSat(sat);
                                        break;
                                }
                        }
                }

                if (!(PIND & (1<<PD6))) LED_OFF;                                        // Reset Failure-LED when Bind-Button is pressed
        }

}