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*

 *****************************************************************************/

//############################################################################

//# HISTORY  timer.c

//#

//#

//# 08.08.2015 CB

//# - add: timer_nmea_timeout

//#

//# 29.06.2014 OG

//# - chg: ISR( TIMER0_COMPA_vect ) - LipoCheck() wieder hinzugefuegt

//# - chg: LipoCheck() - leichte optische Anpassung und lcd-Ausgabe an ISR angepasst

//# - add: #include "../lipo/lipo.h"

//#

//# 24.06.2014 OG

//# - add: timer_gauge

//# - add: #include "../pkt/pkt.h"

//#

//# 13.06.2014 OG

//# - del: IdleTimer entfernt da nicht verwendet

//# - chg: ISR(TIMER0_COMPA_vect) - "PKT aus nach" (via timer_pkt_off)

//# - chg: ISR(TIMER0_COMPA_vect) - "LCD aus nach" umgestellt von Sekunden

//#        auf Minuten (via timer_lcd_off)

//# - chg: Code-Formattierung

//#

//# 31.05.2014 OG

//# - chg: 'timer_pktctrl' umbenannt zu 'timer_pktupdatecheck' (exklusiv fuer pkt.c)

//#

//# 25.04.2014 OG

//# - add: timer_get_displaydata

//#

//# 24.04.2014 OG

//# - add: timer1 (generischer Timer)

//# - add: timer3 (generischer Timer)

//# - add: timer_mk_timeout

//# - del: timer_get_erdata

//#

//# 29.03.2014 OG

//# - add: clear_key_all() - loescht ALLE Tasten egal ob short, long, repeat...

//#

//# 13.06.2013 cebra

//# - chg: Abfrage nach Hardwaresound bei Displaybeleuchtung entfällt

//#

//# 19.05.2013 OG

//# - add: timer_pktctrl - exclusive Verwendung von pkt.c

//#

//# 24.03.2013 OG

//# - add: UTCTime - inkrementiert wird UTCTime.seconds auf der Basis

//#        von timer_pkt_uptime (modulo 100) aktuell initialisert von

//#        der MK-NC Time durch OSD_MK_UTCTime()

//# - add: timer_get_tidata

//#

//# 21.03.2013 OG

//# - add: timer_pkt_uptime (auch in timer.h)

//# - add: timer_osd_refresh (auch in timer.h)  -> verwendet in osd.c

//# - add: timer_get_bldata (auch in timer.h)   -> verwendet in osd.c

//# - add: timer_get_erdata (auch in timer.h)   -> verwendet in osd.c

//#

//# 09.03.2013 OG

//# - add: timer2 (auch in timer.h)

//############################################################################

#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/timer.h"

#include "../eeprom/eeprom.h"

#include "../lcd/lcd.h"

#include "../uart/uart1.h"

#include "../bluetooth/bluetooth.h"

#include "../setup/setup.h"

#include"../tracking/tracking.h"

#include "../sound/pwmsine8bit.h"

#include "../lipo/lipo.h"

#include "../pkt/pkt.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

//----------------------

// generische Timer

//----------------------

volatile uint16_t timer;

volatile uint16_t timer1;

volatile uint16_t timer2;

volatile uint16_t timer3;

//----------------------

// spezielle Timer

//----------------------

volatile uint16_t timer_pktupdatecheck;     // verwendet von pkt.c (!EXKLUSIV!)

volatile uint16_t timer_osd_refresh;        // verwendet in osd.c

volatile uint16_t timer_get_bldata;         // verwendet in osd.c

volatile uint16_t timer_get_tidata;         // verwendet in osd.c

volatile uint16_t timer_get_displaydata;    // verwendet in osd.c

volatile uint16_t timer_mk_timeout;         // verwendet u.a. in osd.c

volatile uint16_t timer_gauge;              // verwendet in pkt.c fuer den rotierenden Wartekreisel

volatile uint16_t timer_nmea_timeout;       // verwendet in nmea.c

volatile uint16_t abo_timer;

uint32_t timer_lcd_off = 0;                 // LCD aus nach... (der Zaehler muss 32Bit sein)

uint32_t timer_pkt_off = 0;                 // PKT aus nach... (der Zaehler muss 32Bit sein)

volatile uint16_t sound_timer;

volatile uint16_t soundpause_timer;

volatile static unsigned int tim_main;

volatile PKTdatetime_t  UTCTime;

volatile uint32_t timer_pkt_uptime = 0;     // OG: ja, 32 bit muss so sein!

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;

volatile uint8_t Display_on;                // LCD Flag Display on/off

volatile uint16_t WarnCount  = 0;           // Zähler der LIPO Warnzeit

volatile uint16_t WarnToggle = 0;           // Togglezähler zum blinken

volatile uint16_t WarnTime   = 10;          // Laenge der LIPO Warnzeit 10 Sek.

volatile uint16_t PoffTime   = 15;          // Laenge der Wartezeit vor abschalten 15 Sek.

//volatile uint16_t PoffTime   = 30;          // Laenge der Wartezeit vor abschalten 30 Sek.

unsigned int BeepTime   = 0;

unsigned int BeepMuster = 0xffff;

unsigned int BeepPrio   = 0;

volatile unsigned int CountMilliseconds = 0;

//--------------------------------------------------------------

// System (100Hz)

//--------------------------------------------------------------

void Timer0_Init( void )

{

    timer = 0;

    TCCR0A = (1 << WGM01);

    TCCR0B = (1 << CS02) | (1 << CS00);

    OCR0A  = (F_CPU / (100L * 1024L)) ;

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

}

//--------------------------------------------------------------

//--------------------------------------------------------------

//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

//}

//--------------------------------------------------------------

//--------------------------------------------------------------

ISR( TIMER2_COMPA_vect )

{

    PORTD |= (1 << PD7);

}

//--------------------------------------------------------------

//--------------------------------------------------------------

ISR( TIMER2_COMPB_vect )

{

    PORTD &= ~(1 << PD7);

}

//--------------------------------------------------------------

//--------------------------------------------------------------

void Timer2_Init( void )

{

    if( Config.HWSound == 1 )

    {                                                                   // Sound PWM

        TCCR2A = 0x00; //stop

        ASSR   = 0x00; //set async mode

        TCNT2  = 0x00; //setup

        OCR2A  = 0xff;

        //Fast PWM 0xFF BOTTOM MAX

        //Set OC2A on Compare Match

        //clkT2S/8 (From prescaler)

        TCCR2A |= (1 << WGM20) | (1 << WGM21) |(1 << COM2A1) | (1 << COM2A0);

        TCCR2B |= (1 << CS20);

    }

    else

    {                                                                   // 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;

    }

}

//--------------------------------------------------------------

// Sound, Timer CTC

//--------------------------------------------------------------

void Timer3_Init( void )

{

    TCCR3A = 0x00;              // stop

    TCNT3H = 0xF8;              // set count

    TCNT3L = 0x00;              // set count

    OCR3AH = 0x07;              // set compare

    OCR3AL = 0xFF;              // set compare

    TCCR3A |= (1 << WGM31);

    TCCR3B |= (1 << CS30);

    TIMSK3 |= (1 << OCIE3A);    // timer interrupt sources  2=t0 compare

}

//--------------------------------------------------------------

//--------------------------------------------------------------

#ifdef USE_SOUND

ISR(TIMER3_COMPA_vect)  // Sound

{

    //void timer0_comp_isr(void){

    //was 8 KHz 125usec  sampling rate

    //now 12 KHz 83usec  sampling rate

    unsigned char oldfpart;

    signed char fullsamp;

    signed int tmp;

    TCNT3 = 0;

    if( generate )

    {

        DDRD |= (1<<DDD7);              // Port aus Ausgang

        oldfpart=waveptfpart;           // remember fractional part

        waveptfpart+=freqincfpart;      // add frac part of freq inc to wave pointer

        if( waveptfpart < oldfpart )    // did it walk off the end?

        {

            waveptipart++;              // yes, bump integer part

        }

        waveptipart+=freqincipart;      // add int part of freq increment to wave pointer

        fullsamp=sindat[waveptipart];   // get 8 bit sin sample from table (signed)

        tmp=fullsamp*iattenfac;         // cvt 7 bit x 8 = 15 bit

        OCR2A=(tmp >> 8)+128;           // cvt 15 bit signed to 8 bit unsigned

    }

    else

    {

        DDRD &= ~(1 << DDD7);           // Port auf Eingang, sperrt das Rauschen

    }

}

#endif

//--------------------------------------------------------------

// Timer-Interrupt (100 Hz)

//--------------------------------------------------------------

ISR( TIMER0_COMPA_vect )

{

    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;

    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( !cnt-- )

    {

        cnt = 9;

        CountMilliseconds++;

        cnt_1ms++;

    }

    //--------------------------------

    // Key pressed -> Timer Reset

    //--------------------------------

    if( i!=0 )                                                      // eine Taste wurde gedrueckt! -> Timer Rest und weiteres...

    {

        if( Display_on == 0 )                                       // ggf. Displaylicht einschalten

          set_D_LIGHT();

        Display_on    = 1;                                          // Flag Display on

        timer_lcd_off = 0;                                          // Timer Reset

        timer_pkt_off = 0;                                          // Timer Reset

    }

    //--------------------------------

    // LCD off Timeout

    // LCD ausschalten nach n Minuten

    //--------------------------------

    if( (Config.DisplayTimeout > 0) && (Display_on == 1) )

    {

        timer_lcd_off++;

        if( (timer_lcd_off/(100*60)) == Config.DisplayTimeout )     // ISR laeuft mit 100Hz; umgerechnet auf Minuten

        {

            clr_D_LIGHT();                                          // Displaylicht ausschalten

            Display_on = 0;                                         // Flag Display off

        }

    }

    //--------------------------------

    // PKT off Timeout

    // PKT ausschalten nach n Minuten

    //--------------------------------

    if( Config.PKTOffTimeout > 0 )

    {

        timer_pkt_off++;

        if( (timer_pkt_off/(100*60)) == Config.PKTOffTimeout )      // ISR laeuft mit 100Hz; umgerechnet auf Minuten

        {

            WriteParameter();                                       // am Ende alle Parameter sichern

            set_beep( 50, 0xffff, BeepNormal );                     // ein Mini-Beep zum Abschied (laenger geht nicht, wahrscheinlich wegen der ISR)

            clr_V_On();                                             // Spannung abschalten

        }

    }

    //--------------------------------

    // PKT bei Unterspannung abschalten

    //--------------------------------

    LipoCheck();

    //--------------------------------

    // Beeper

    //--------------------------------

    if( Config.HWBeeper==1 )

    {

        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;

            BeepPrio   = BeepNormal;

        }

        if( beeper_ein == 1 )           set_BEEP();

        else                            clr_BEEP();

    }

    //--------------------------------

    // Sound

    //--------------------------------

    #ifdef USE_SOUND

    if (sound_timer > 0)                                            // Ton spielen

    {

        sound_timer--;

    }

    else

    {

      //TIMSK2 &= ~_BV(TOIE2);                                      // Interrupt sperren, verhindert Störgeräusche

      //TCCR2A = 0x00; //stop

        generate = 0;                                               // Sound aus

        tone_handler();

        if (soundpause_timer > 0)

        {

          soundpause_timer --;        // Ton pause

        }

    }

    #endif

    //--------------------------------

    // Tasten

    //--------------------------------

    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);

        }

    }

    //--------------------------------

    // generische Timer

    //--------------------------------

    if( timer > 0 )                 timer --;

    if( timer1 > 0 )                timer1 --;

    if( timer2 > 0 )                timer2 --;

    if( timer3 > 0 )                timer3 --;

    //--------------------------------

    // spezielle Timer

    //--------------------------------

    if( timer_osd_refresh > 0 )     timer_osd_refresh--;            // Timer fuer OSD-Screenrefresh (verwendet von osd.c)

    if( timer_get_bldata > 0 )      timer_get_bldata--;             // Timer um BL-Daten zu holen (verwendet von osd.c)

    if( timer_get_tidata > 0 )      timer_get_tidata--;             // Timer um Datum/Zeit vom MK zu holen (verwendet von osd.c)

    if( timer_get_displaydata > 0 ) timer_get_displaydata--;        // Timer um Display vom MK zu holen (verwendet von osd.c)

    if( timer_mk_timeout > 0 )      timer_mk_timeout--;             // verwendet u.a. von osd.c

    if( abo_timer > 0 )             abo_timer --;                   // Timer zum anfordern neuer Abo-Datenpakete wie OSD oder BL-Daten (verwendet u.a. von osd.c)

    if( timer_pktupdatecheck > 0 )  timer_pktupdatecheck--;         // Timer fuer pkt.c (PKT-Update-Check) - * FUER NICHTS ANDERES! *

    if( timer_nmea_timeout > 0 )    timer_nmea_timeout--;           // verwendet u.a. von osd.c

    //--------------------------------

    //--------------------------------

    if( Gauge_active )                                              // Gauge_active -> pkt.c

    {

        if( timer_gauge > 0 )       timer_gauge--;

        if( timer_gauge==0 )        PKT_Gauge_Next();

    }

    //--------------------------------

    // PKT Uptime Timer

    //--------------------------------

    timer_pkt_uptime++;

    if( timer_pkt_uptime % 100 == 0 )                               // theoretisch muesste noch die Tagesgrenze (0 Uhr) implementiert werden...

        UTCTime.seconds++;

} // end: ISR(TIMER0_COMPA_vect)

//--------------------------------------------------------------

// Lowbatpin des Spannungswandlers pruefen

// LBO des LT1308 wechselt zum Ende der Batterielaufzeit haeufig seinen Zustand in der Uebergangsphase zum LowBat

// Die Akkuspannung schwankt auch abhaengig vom momentanen Stromverbrauch

//--------------------------------------------------------------

void LipoCheck( void )

{

    uint8_t lcd_xpos_save;

    uint8_t lcd_ypos_save;

    if( WarnToggle == 1 )                               // Beim ersten Auftreten Warnung ausgeben, Rythmus 5/10 Sekunden

    {

        set_beep( 1000, 0x0020, BeepNormal);

        lcd_xpos_save = lcd_xpos;                       // innerhalb einer ISR -> LCD Screenpos muss gesichert werden!

        lcd_ypos_save = lcd_ypos;

        //lcdx_cls_row( y, mode, yoffs )

        lcdx_cls_row( 0, MINVERS ,0 );                              // Zeile 0 komplett invers

        lcd_printp_at( 0, 0, PSTR(" ** PKT LiPo! ** "), MINVERS);   // und Warn-Text ausgeben

        lcd_xpos = lcd_xpos_save;                                   // lcd Screenpos wieder herstellen

        lcd_ypos = lcd_ypos_save;

    }

    if( WarnToggle == WarnTime * 100 )

        WarnToggle = 0;                                 // erstmal bis hier warnen

    if( WarnToggle > 0 )

        WarnToggle++;                                   // weiter hochzaehlen

    if( PINC & (1 << LowBat) )                          // Kurzzeitige Unterspannung bearbeiten und Warnung ausgeben

    {

        WarnCount = 0;

      //if (WarnCount > 0)

      //    WarnCount--;                                // Bei LIPO OK erstmal runterzaehlen, LT1308 ueberlegt 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) )

    {

        set_beep( 50, 0xffff, BeepNormal );             // ein Mini-Beep zum Abschied (laenger geht nicht, wahrscheinlich wegen der ISR)

        WriteParameter();                               // am Ende alle Parameter sichern

        clr_V_On();                                     // Spannung abschalten

    }

}

//--------------------------------------------------------------

//--------------------------------------------------------------

//void LipoCheck_OLD( void )

//{

//    if( WarnToggle == 1 )                               // Beim ersten Auftreten Warnung ausgeben, Rythmus 5/10 Sekunden

//    {

//        set_beep ( 1000, 0x0020, BeepNormal);

//        lcd_printp_at (0, 0, PSTR("  LIPO  !!Warnung!!  "), 2);

//    }

//

//    if( WarnToggle == WarnTime * 100 )

//        WarnToggle = 0;                                 // erstmal bis hier warnen

//

//    if( WarnToggle > 0 )

//        WarnToggle++;                                   // weiter hochzaehlen

//

//    if( PINC & (1 << LowBat) )                          // Kurzzeitige Unterspannung bearbeiten und Warnung ausgeben

//    {

//        WarnCount = 0;

//      //if (WarnCount > 0)

//      //    WarnCount--;                                // Bei LIPO OK erstmal runterzaehlen, LT1308 ueberlegt 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

//  }

//}

//--------------------------------------------------------------

//--------------------------------------------------------------

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;

    cli();                      // disable all interrupts

    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;

    cli();                          // disable all interrupts

    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;

    cli();                          // disable all interrupts

    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;

    cli();                          // disable all interrupts

    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;

    cli();                          // disable all interrupts

    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;

    cli();                          // disable all interrupts

    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;

}

//--------------------------------------------------------------

//--------------------------------------------------------------

void clear_key_all( void )

{

    key_rpt   = 0;                  // clear key(s)

    key_rpts  = 0;                  // clear key(s)

    key_lrpt  = 0;                  // clear key(s)

    key_long  = 0;                  // clear key(s)

    key_press = 0;                  // clear key(s)

}

//--------------------------------------------------------------

//--------------------------------------------------------------

void set_beep( uint16_t Time, uint16_t Muster, uint8_t Prio)

{

    if( Config.HWBeeper == 1 )

    {

        if( (Prio == BeepNormal) && (BeepPrio == BeepNormal) )      // BEEPER: nur setzen wenn keine hohe Prio schon aktiv ist

        {

            BeepTime   = Time;

            BeepMuster = Muster;

        }

        if( (Prio == BeepSevere) && (!BeepPrio == BeepSevere) )     // BEEPER: hohe Prio setzen

        {

            BeepPrio   = BeepSevere;

            BeepTime   = Time;

            BeepMuster = Muster;

        }

        if( Prio == BeepOff )

        {

            BeepPrio   = BeepNormal;                                // BEEPER: Beep hohe Prio aus

            BeepTime   = 0;

            BeepMuster = 0;

        }

    } // end: if( Config.HWBeeper==1 )

    #ifdef USE_SOUND

    else

    {

        if( (Prio == BeepNormal) && (BeepPrio == BeepNormal) )      // SOUND: nur setzen wenn keine hohe Prio schon aktiv ist

        {

            playTone(900,Time/10,0);

        }

        if( (Prio == BeepSevere) && (!BeepPrio == BeepSevere) )

        {

            playTone(1200,Time/10,0);

            playTone(1100,Time/10,0);

        }

        if( Prio == BeepOff )

        {

            playTone(0,0,0);

        }

    }

    #endif // end: #ifdef USE_SOUND

}