Subversion Repositories Projects

/*****************************************************************************
 *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
 *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
 *   based on the key handling by Peter Dannegger                            *
 *     see www.mikrocontroller.net                                           *
 *   Copyright (C) 2011 Christian "Cebra" Brandtner, brandtner@brandtner.net *
 *   Copyright (C) 2011 Harald Bongartz                                      *
 *                                                                           *
 *   This program is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation; either version 2 of the License.          *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program; if not, write to the                           *
 *   Free Software Foundation, Inc.,                                         *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
 *                                                                           *
 *                                                                           *
 *   Credits to:                                                             *
 *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN  *
 *                          http://www.mikrokopter.de                        *
 *   Gregor "killagreg" Stobrawa for his version of the MK code              *
 *   Thomas Kaiser "thkais" for the original project. See                    *
 *                          http://www.ft-fanpage.de/mikrokopter/            *
 *                          http://forum.mikrokopter.de/topic-4061-1.html    *
 *   Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
 *                          http://www.mylifesucks.de/oss/c-osd/             *
 *   Harald Bongartz "HaraldB" for providing his Ideas and Code for usibility*
 *****************************************************************************/

#include "cpu.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <util/delay.h>
#include <inttypes.h>


#include "main.h"
#include "timer.h"
#include "eeprom.h"
#include "lcd.h"
#include "uart1.h"

#if defined HWVERSION1_2W || defined HWVERSION1_2
#include "HAL_HW1_2.h"
#endif

#if defined HWVERSION1_3W || defined HWVERSION1_3
#include "HAL_HW1_3.h"
#endif

#ifdef HWVERSION3_9
#include "HAL_HW3_9.h"
#endif

volatile uint16_t timer;
volatile uint16_t abo_timer;
volatile static unsigned int tim_main;

uint8_t key_state = 0;          // debounced and inverted key state:
                                                        // bit = 1: key pressed
uint8_t key_press = 0;          // key press detect
uint8_t key_long = 0;           // key long press
uint8_t key_rpt = 0;            // key repeat
uint8_t key_lrpt = 0;           // key long press and repeat
uint8_t key_rpts = 0;           // key long press and speed repeat
uint8_t repeat_speed = 0;

uint16_t DisplayTime = 0;       // Leuchtdauer
volatile uint16_t IdleTimer = 0;                // InaktivitätsTimer

uint16_t WarnCount = 0;         // Zähler der LIPO Warnzeit
uint16_t WarnToggle = 0;        // Togglezähler zum blinken
uint16_t WarnTime = 10;         // Länge der LIPO Warnzeit 10 Sek.
uint16_t PoffTime = 30;         // Länge der Wartezeit vor Abschalten 30 Sek.
//uint8_t       servo = 0;


volatile uint8_t Display_on;// Flag Display on/off

unsigned int BeepTime = 0;
unsigned int BeepMuster = 0xffff;

volatile unsigned int CountMilliseconds = 0;

// Size of Buffer for Converting unsigned int Value to ASCII
#define STRING_BUFFER_SIZE 5

// Buffer for Converting unsigned int Value to ASCII
char String_Buffer[STRING_BUFFER_SIZE];


//--------------------------------------------------------------
//
void Timer1_Init (void) // Timer 1-A
{
        // löschen
        TCCR1A = 0;
        TCCR1B = 0;
        TIMSK1 = 0;

        // setzen
        TCCR1A |=   (1 << COM1A1) | (1 << WGM11);
        TCCR1B |=   (1 << CS11)   | (1 << CS10)   | (1 << WGM13)  | (1 << WGM12);

        ICR1 = (F_CPU / 64) * 20 / 1000;

        OCR1A = 470;  // ca. Servomitte
}


//--------------------------------------------------------------
void Timer2_Init (void) // Displayhelligkeit
{
        DDRD   |= (1 << DDD7);                                                                          // PD7 output
        TCCR2A |= (1 << WGM21)  | (1 << WGM20)  | (1 << COM2A1);        // non invers
        TCCR2B |= (1 << CS20);                                                                          // Prescaler 1/1
        TIMSK2 |= (1 << OCIE2A) | (1 << OCIE2B);

        OCR2A = 255;
}


#if defined HWVERSION1_2 || defined HWVERSION1_2W
//--------------------------------------------------------------
ISR(TIMER2_COMPA_vect)
{
        PORTD &= ~(1 << PD7);
        PORTC &= ~(1 << PC0);
        PORTC &= ~(1 << PC1);
}
ISR(TIMER2_COMPB_vect)
{
        PORTD |= (1 << PD7);
        PORTC |= (1 << PC0);
        PORTC |= (1 << PC1);
}
#endif
#if defined HWVERSION1_3 || defined HWVERSION1_3W
//--------------------------------------------------------------
ISR(TIMER2_COMPA_vect)
{
        PORTD &= ~(1 << PD7);
        PORTD &= ~(1 << PD6);
        PORTC &= ~(1 << PC2);
}
ISR(TIMER2_COMPB_vect)
{
        PORTD |= (1 << PD7);
        PORTD |= (1 << PD6);
        PORTC |= (1 << PC2);
}
#endif
#ifdef HWVERSION3_9
//--------------------------------------------------------------
ISR(TIMER2_COMPA_vect)
{
        PORTD |= (1 << PD7);
}
ISR(TIMER2_COMPB_vect)
{
        PORTD &= ~(1 << PD7);
}
#endif


//--------------------------------------------------------------
void Timer0_Init (void)  // System (100Hz)
{
        timer = 0;

        TCCR0A = (1 << WGM01);
        TCCR0B = (1 << CS02) | (1 << CS00);
        OCR0A = (F_CPU / (100L * 1024L)) ;

        TIMSK0 |= (1 << OCIE0A);        // enable interrupt for OCR
}


//--------------------------------------------------------------
ISR(TIMER0_COMPA_vect)  // Timer-Interrupt (100 Hz)
{
        static uint8_t ct0 = 0;
        static uint8_t ct1 = 0;
        static uint8_t k_time_l = 0;
        static uint8_t k_time_r = 0;
        static uint8_t k_time_lr = 0;
        static uint8_t k_time_rs = 0;
        uint8_t i;

        static unsigned char cnt_1ms = 1,cnt = 0;
        unsigned char beeper_ein = 0;
//      unsigned char pieper_ein = 0;

        // Key handling by Peter Dannegger
        // see www.mikrocontroller.net

        i = key_state ^ ~KEY_PIN;               // key changed ?
        ct0 = ~(ct0 & i);                               // reset or count ct0
        ct1 = ct0 ^ (ct1 & i);                  // reset or count ct1
        i &= (ct0 & ct1);                               // count until roll over ?
        key_state ^= i;                                 // then toggle debounced state
        key_press |= (key_state & i);   // 0->1: key press detect

        if (PKT_IdleBeep == 1)
        {
                IdleTimer ++;                                   // nix zu tun? Timer hochzählen
                if (IdleTimer == 12000)                 // Warnhinweis
                {
                        BeepTime = 200;
                        BeepMuster = 0x0080;
                        IdleTimer = 0;
                }
        }

        if (!cnt--)
        {
                cnt = 9;
                CountMilliseconds++;
                cnt_1ms++;
        }

        if (i!=0)
        {                                               // Displaylicht einschalten, und bzw. Timeoutzählerreset wenn Taste gedrückt wurde
                if (Display_on == 0)
                  set_D_LIGHT();


                Display_on = 1;         // Flag Display on
                DisplayTime = 0;        // Timer Reset
                IdleTimer = 0;          // Idletimeout Reset

        }

        if (DisplayTimeout > 0)
        {
                if (Display_on == 1)
                {
                        DisplayTime++;
                        if ((DisplayTime / 100) == DisplayTimeout)      // ISR läuft mit 100Hz
                        {                                                                                       // Displaylicht ausschalten
                            clr_D_LIGHT();
                            Display_on = 0;                                                     // Flag Display off

                        }
                }
        }

//--------------------------------------------------------------
#ifdef HWVERSION3_9
        LipoCheck();    // Lipo prüfen
#endif

//--------------------------------------------------------------
        if (BeepTime)
        {
                if (BeepTime > 10)
                        BeepTime -= 10;
                else
                        BeepTime = 0;

                if (BeepTime & BeepMuster)
                        beeper_ein = 1;
                else
                        beeper_ein = 0;
        }
        else
        {
                beeper_ein = 0;
                BeepMuster = 0xffff;
        }

        if (beeper_ein)
                set_BEEP();
        else
                clr_BEEP();


//--------------------------------------------------------------
        if ((key_state & LONG_MASK) == 0)                       // check long key function
                k_time_l = REPEAT_START;                                // start delay

        if (--k_time_l == 0)                                            // long countdown
                key_long |= (key_state & LONG_MASK);

//--------------------------------------------------------------
        if ((key_state & REPEAT_MASK) == 0)                     // check repeat function
                k_time_r = 1;                                                   // kein delay

        if (--k_time_r == 0)
        {
                k_time_r = REPEAT_NEXT;                                 // repeat delay
                key_rpt |= (key_state & REPEAT_MASK);
        }

//--------------------------------------------------------------
        if ((key_state & LONG_REPEAT_MASK) == 0)        // check repeat function
                k_time_lr = REPEAT_START;                               // start delay

        if (--k_time_lr == 0)
        {
                k_time_lr = REPEAT_NEXT;                                // repeat delay
                key_lrpt |= (key_state & LONG_REPEAT_MASK);
        }

//--------------------------------------------------------------
        if ((key_state & LONG_REPEAT_SP_MASK) == 0)     // check repeatX function
                k_time_rs = REPEAT_START;                               // start delay

        if (--k_time_rs == 0)                                           // repeat countdown
        {
                if (repeat_speed == 1)
                {
                        k_time_rs = REPEAT_SPEED_1;
                        key_rpts |= (key_state & LONG_REPEAT_SP_MASK);
                }
                else if (repeat_speed == 2)
                {
                        k_time_rs = REPEAT_SPEED_2;
                        key_rpts |= (key_state & LONG_REPEAT_SP_MASK);
                }
                else if (repeat_speed == 3)
                {
                        k_time_rs = REPEAT_SPEED_3;
                        key_rpts |= (key_state & LONG_REPEAT_SP_MASK);
                }
        }

        if (timer > 0)
                timer --;

        if (abo_timer > 0)
                abo_timer --;


}


//--------------------------------------------------------------
#ifdef HWVERSION3_9

void LipoCheck (void)   // Lowbatpin des Spannungswandlers prüfen
                        // LBO des LT1308 wechselt zum Ende der Batterielaufzeit häufig seinen Zustand in der Übergangsphase zum LowBat
                        // Die Akkuspannung schwankt auch abhängig vom momentanen Stromverbrauch
{
        if (WarnToggle == 1)    // Beim ersten Auftreten Warnung ausgeben, Rythmus 5/10 Sekunden
        {
                BeepTime = 1000;
                BeepMuster = 0x0020;
                lcd_printp_at (0, 0, PSTR("  LIPO  !!Warnung!!  "), 2);
        }

        if (WarnToggle == WarnTime * 100)
                WarnToggle = 0;  // erstmal bis hier warnen

        if (WarnToggle > 0)
                WarnToggle++;  // weiter hochzählen

        if (PINC & (1 << LowBat))       // Kurzzeitige Unterspannung bearbeiten und Warnung ausgeben
        {
                WarnCount = 0;
//              if (WarnCount > 0)
//                      WarnCount--;  // Bei LIPO OK erstmal runterzählen, LT1308 überlegt sich noch genauer ob nun ok oder nicht
        }

        if (!(PINC & (1 << LowBat)) )  // LT1308 hat Unterspannung erkannt
        {
                WarnCount++;  // solange LBO low ist Zähler hochzählen
                if (WarnCount == 10 && WarnToggle == 0)  // mit "10" etwas unempfindlicher gegen kurze Impulse machen
                        WarnToggle = 1;  // Warnhinweis starten
        }

        if ((WarnCount) == PoffTime * 100)
                clr_V_On();  // Spannung abschalten
}

#endif


//--------------------------------------------------------------
unsigned int SetDelay (unsigned int t)
{
        return(CountMilliseconds + t + 1);
}


//--------------------------------------------------------------
char CheckDelay(unsigned int t)
{
        return(((t - CountMilliseconds) & 0x8000) >> 9);
}


//--------------------------------------------------------------
void Delay_ms(unsigned int w)
{
        unsigned int akt;
        akt = SetDelay(w);
        while (!CheckDelay(akt));
}


//--------------------------------------------------------------
//
uint8_t get_key_press (uint8_t key_mask)
{
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        key_mask &= key_press;  // read key(s)
        key_press ^= key_mask;  // clear key(s)

        SREG = sreg;    // restore status register

        return key_mask;
}


//--------------------------------------------------------------
//
uint8_t get_key_short (uint8_t key_mask)
{
        uint8_t ret;
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        ret = get_key_press (~key_state & key_mask);

        SREG = sreg;    // restore status register

        return ret;
}


//--------------------------------------------------------------
//
uint8_t get_key_long (uint8_t key_mask)
{
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        key_mask &= key_long;   // read key(s)
        key_long ^= key_mask;   // clear key(s)

        SREG = sreg;    // restore status register

  return get_key_press (get_key_rpt (key_mask));
}


//--------------------------------------------------------------
//
uint8_t get_key_rpt (uint8_t key_mask)
{
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        key_mask &= key_rpt;    // read key(s)
        key_rpt ^= key_mask;    // clear key(s)

        SREG = sreg;    // restore status register

        return key_mask;
}


//--------------------------------------------------------------
//
uint8_t get_key_long_rpt (uint8_t key_mask)
{
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        key_mask &= key_lrpt;   // read key(s)
        key_lrpt ^= key_mask;   // clear key(s)

        SREG = sreg;    // restore status register

        return get_key_rpt (~key_press^key_mask);
}


//--------------------------------------------------------------
//
uint8_t get_key_long_rpt_sp (uint8_t key_mask, uint8_t key_speed)
{
        uint8_t sreg = SREG;

        // disable all interrupts
        cli();

        key_mask &= key_rpts;   // read key(s)
        key_rpts ^= key_mask;   // clear key(s)

        repeat_speed = key_speed;

        SREG = sreg;    // restore status register

        return key_mask;
}