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;

}