Subversion Repositories Projects

/*****************************************************************************
 *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
 *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.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  pkt.c
//#
//# 25.06.2014 OG
//# - chg: PKT_Ask(), PKT_Ask_P() auf PKT_AskX() angepasst
//# - add: PKT_AskX() - ehemals _pkt_ask(), jetzt erweitert um zusaetzliche progmen Parameter und exportiert
//#
//# 24.06.2014 OG
//# - add: PKT_Gauge_Begin(), PKT_Gauge_End(), PKT_Gauge_Next()
//#
//# 15.06.2014 OG
//# - add: PKT_Progress_Init(), PKT_Progress_Next()
//#
//# 14.06.2014 OG
//# - add: PKT_TitlePKTlipo() fuer optionale Anzeige der LiPo-Spannung
//#
//# 13.06.2014 OG
//# - add: PKT_Ask_Restart()
//#
//# 12.06.2014 OG
//# - add: PKT_Reset_EEprom()  (ehemals in setup.c)
//# - chg: PKT_Update() auf PKT_Ask_P() umgestellt
//# - add: PKT_Ask(), PKT_Ask_P(), _pkt_ask()
//#
//# 11.06.2014 OG
//# - add: PKT_Title(), PKT_Title_P(), _pkt_title()
//# - chg: PKT_TitleFromMenuItem() umgestellt auf _pkt_title()
//# - chg: PKT_TitlePKTVersion() umbenannt zu PKT_TitlePKT()
//# - fix: PKT_TitleFromMenuItem() funktioniert jetzt auch wenn kein Menue vorhanden ist
//#
//# 04.06.2014 OG
//# - add: PKT_Message_Datenverlust()
//#
//# 31.05.2014 OG
//# - fix: PKT_CtrlHook() bzgl. PKT_CheckUpdate() - seit Februar 2014 Probleme
//#        mit Update-Anforderung vom PKT-Updatetool -> PKT war zu schnell
//#        Es wurde jetzt ein Timer in PKT_CtrlHook() eingebaut der den Aufruf
//#        von PKT_CheckUpdate() etwas einbremst ohne das PKT auszubremsen.
//#        Ich hoffe, das es ist Loesung ist (bin guter Dinge nach Test's)
//# - chg: PKT_CheckUpdate() - Code optimiert
//# - add: PKT_Info() - Anzeige ob SV2-Patch vorhanden ist oder nicht (ganz oben)
//# - add: PKT_Info() - Anzeige fuer USE_OSD_SCREEN_WAYPOINTS
//# - add: PKT_KeylineUpDown()
//#
//# 23.05.2014 OG
//# - add: PKT_TitleFromMenuItem()
//# - add: #include "../utils/menuctrl.h"
//#
//# 06.05.2014 OG
//# - chg: PKT_CheckUpdate() - seit Februar funktioniert die Update-Anforderung
//#        vom PKT-Updatetool an das PKT nicht immer zuverlaessig - fgf. weil sich
//#        seitens des PKT's Timings etwas geaendert haben (durch weglassen von Code).
//#        Hier ein Versuch etwas daran wieder zu aendern... its zwar weiterhin
//#        nicht immer zuverlaessig aber vieleicht etwas besser.
//#        Wahrscheinlich kann man das nur richtig korrigieren in Verbindung mit
//#        Anpassungen am PKT-Updatetool - aber das ist ein anderes Thema...
//# - chg: PKT_Update() - ein kurzer Beep wenn das PKT-Update aufgerufen wird
//#
//# 05.05.2014 OG
//# - add: PKT_Popup(), PKT_Popup_P(), _pkt_popup()
//#
//# 11.04.2014 OG
//# - chg: _pkt_message() ergaenzt um clear_key_all()
//#
//# 09.04.2014 OG
//# - chg: PKT_Update() - umgestellt auf ShowTitle_P()
//#
//# 08.04.2014 OG
//# - chg: PKT_Update() - Text bzgl. "Druecke Start..." zentriert
//#
//# 04.04.2014 OG
//# - fix: define ESC umbenannt zu PKTESC da es einen Namenskonflikt mit enum
//#        STR in messages.h gab
//# - add: _pkt_message() zeigt einen Titel mit PKT Version und Lipo an
//#
//# 03.04.2014 OG
//# - chg: _pkt_message() abgesichert bzgl. zu langen Texten
//#
//# 27.03.2014 OG
//# - chg: PKT_SwitchOff() Anzeige optimiert
//#
//# 21.02.2014 OG
//# - fix: PKT_CheckUpdate() Zeile 0 flimmerte wegen einer nicht mehr
//#        benoetigten Textausgabe
//# - chg: PKT_SwitchOff() auf PKT_TitlePKTVersion() angepasst
//# - chg: PKT_TitlePKTVersion()
//#
//# 17.02.2014 OG
//# - add: PKT_Message(), PKT_Message_P(), _pkt_message()
//# - chg: MK_Info() auf USE_MKSETTINGS angepasst (ehemals MKPARAMETER)
//#
//# 13.02.2014 OG
//# - chg: Screenlayout von PKT_Update()
//# - chg: Screenlayout von PKT_SwitchOff()
//#
//# 11.02.2014 OG
//# - chg: PKT_Info() Anzeige der FC-Version entfernt
//#
//# 04.02.2014 OG
//# - fix: #include "../lipo/lipo.h" hinzugefuegt
//#
//# 03.02.2014 OG
//# - chg: Layout von PKT_SwitchOff() und bessere Unterstuetzung von PKT_CtrlHook()
//# - add: PKT_ShowTitleVersion()
//#
//# 30.01.2014 OG
//# - chg: geaenderte Anzeige der Reihenfolgen unterstuetzter Module in PKT_Info()
//# - add: Unterstuetzung fuer USE_BLUETOOTH
//#
//# 24.01.2014 OG
//# - chg: PKT_SwitchOff(): Layout; Code eliminiert; Beep;
//#        add PKT_Hook() (für PKT-Update)
//# - chg: PKT_Update(): Layout
//#
//# 21.10.2013 CB
//# - add: PKT_Info WyFly hinzugefügt
//#
//# 07.07.2013 OG
//# - del: PKT_Info(): USE_OSD_SCREEN_ELECTRIC_N

//# 26.06.2013 OG
//# - del: PKT_Info(): USE_PKT_STARTINFO
//#
//# 13.06.2013 OG
//# - add: PKT-Hardwareversion in der Titelanzeige von PKT_Info()
//# - chg: Layout Titelanzeige von PKT_Info()
//# - del: USE_PCFASTCONNECT in PKT_Info() (nicht mehr benoetigt)
//# - del: PC_Fast_Connect() - ersetzt durch Menu_PKTTools() in menu.c
//#
//# 20.05.2013 OG
//# - chg: PKT_CtrlHook() bei PKT-Update um WriteParameter() ergaenzt
//#
//# 19.05.2013 OG
//# - add: PKT_CtrlHook() ruft ggf. PKT_Update() auf und kann spaeter weitere
//#        PKT interne Sachen verarbeiten wie z.B. senden von Daten an den PC
//# - chg: PKT_CheckUpdate() umgestellt auf timer_pktctrl um Konflikte mit
//#        mit z.B. osd zu vermeiden
//# - chg: PKT_Info() bzgl. Codeverbrauch verringert
//# - fix: PKT_Info() Anzeige von USE_OSD_SCREEN_NAVIGATION
//# - add: PC_Fast_Connect() aus menu.c
//# - add: PKT_* Funktionen aus main.c bzw. menu.c
//############################################################################


#include "../cpu.h"
#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <util/delay.h>
#include <avr/eeprom.h>
#include <util/atomic.h>

#include "../main.h"
#include "../lcd/lcd.h"
#include "../uart/usart.h"

#include "../uart/uart1.h"
#include "../mk-data-structs.h"
#include "../timer/timer.h"
#include "../eeprom/eeprom.h"
#include "../messages.h"
#include "../utils/scrollbox.h"
#include "../utils/xutils.h"
#include "../lipo/lipo.h"
#include "../utils/menuctrl.h"
#include "pkt.h"


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

uint8_t pkt_progress_act    = 0;
uint8_t pkt_progress_max    = 0;
int8_t  pkt_progress_yoffs  = 0;
uint8_t pkt_progress_width  = 0;
uint8_t pkt_progress_height = 0;

#define PROGRESS_YOFFS  -8
#define PROGRESS_WIDTH  96



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

//--------------------------------------------------------------
//--------------------------------------------------------------
void PKT_Progress_Init( uint8_t max, int8_t yoffs, uint8_t width, uint8_t height)
{
    pkt_progress_act    = 0;
    pkt_progress_max    = max;
    pkt_progress_yoffs  = yoffs;
    pkt_progress_width  = 0;        // Parameter width - aktuell nicht unterstuetzt
    pkt_progress_height = 0;        // Parameter height - aktuell nicht unterstuetzt

    if( pkt_progress_width == 0 )
        pkt_progress_width = PROGRESS_WIDTH;

    lcd_rect_round( 13, 32+pkt_progress_yoffs, 102, 6, 1, R1);              // Rahmen fuer Progress
}



//--------------------------------------------------------------
//--------------------------------------------------------------
uint8_t PKT_Progress_Next( void )
{
    uint8_t width;

    pkt_progress_act++;                                                 // Progress: hochzaehlen
    width = (pkt_progress_act*pkt_progress_width) / pkt_progress_max;           // Progress: Breite berechnen
    lcd_frect( 16, 34+pkt_progress_yoffs, width, 2,  1);                // Progress: anzeigen

    return true;
}



//#############################################################################################
//# Anzeigefunktionen
//#############################################################################################


//--------------------------------------------------------------
// PKT_KeylineUpDown( xUp, xDown,  xoffs,yoffs)
//
// gibt in der Keyline (y=7) ein Up- und Down-Zeichen aus.
// Das Up-Zeichen wird dabei um einen Pixel versetzt damit
// es besser aussieht
//
// Parameter:
//  xUp  : x-Position des Up-Zeichens in Zeile 7
//  xDown: x-Position des Down-Zeichens in Zeile 7
//  xoffs, yoffs: normalerweise 0,0
//--------------------------------------------------------------
void PKT_KeylineUpDown( uint8_t xUp, uint8_t xDown,  uint8_t xoffs, uint8_t yoffs)
{
    lcdx_printp_at( xUp  , 7, PSTR("\x1a")    , MNORMAL, xoffs,yoffs+1);    // Up
    lcdx_printp_at( xDown, 7, PSTR("\x1b")    , MNORMAL, xoffs,yoffs);      // Down
}



//#############################################################################################
//# Titel Funktionen
//#############################################################################################

//--------------------------------------------------------------
//--------------------------------------------------------------
void _pkt_title( uint8_t progmem, const char *text, uint8_t lShowLipo, uint8_t clearscreen )
{
    const char *pMask;

    if( clearscreen )   lcd_cls();

    lcd_frect( 0, 0, 127, 7, 1);                             // Titel: Invers

    if( progmem )   pMask = PSTR("%19S");
    else            pMask = PSTR("%19s");

    lcdx_printf_at_P( 1, 0, MINVERS, 0,0, pMask, text );

    if( lShowLipo )     show_Lipo();
}



//--------------------------------------------------------------
// PKT_Title( text, lShowLipo, clearscreen )
//
// text im RAM
//--------------------------------------------------------------
void PKT_Title( const char *text, uint8_t lShowLipo, uint8_t clearscreen )
{
    _pkt_title( false, text, lShowLipo, clearscreen );
}



//--------------------------------------------------------------
// PKT_Title_P( text, lShowLipo, clearscreen )
//
// text im PROGMEM
//--------------------------------------------------------------
void PKT_Title_P( const char *text, uint8_t lShowLipo, uint8_t clearscreen )
{
    _pkt_title( true, text, lShowLipo, clearscreen );
}



//--------------------------------------------------------------
// zeigt als Titel die PKT-Version (invers)
// optional: rechts die PKT Lipo-Spannung anzeigen
//--------------------------------------------------------------
void PKT_TitlePKTlipo( uint8_t lShowLipo )
{
    //PKT_Title( buffered_sprintf_P(PSTR("PKT v%S"),PSTR(PKTSWVersion)), true, false ); // showlipo, kein clearscreen
    PKT_Title( buffered_sprintf_P(PSTR("PKT v%S"),PSTR(PKTSWVersion)), lShowLipo, true );   // showlipo und clearscreen
}



//--------------------------------------------------------------
// zeigt als Titel die PKT-Version (invers)
// und rechts die PKT Lipo-Spannung
//--------------------------------------------------------------
void PKT_TitlePKT( void )
{
    PKT_TitlePKTlipo( true );
}



//--------------------------------------------------------------
// PKT_TitleFromMenuItem( lShowLipo )
//
// zeigt eine PKT-Titelzeile mit Text vom aufrufenden Menuepunkt
// optional kann die PKT LiPo-Spannung angezeigt werden
//
// wenn kein Menue vorhandenist wird die PKT-Version angezeigt
//--------------------------------------------------------------
void PKT_TitleFromMenuItem( uint8_t lShowLipo )
{
    const char *pStr;
    uint8_t     isPGM;

    if( MenuCtrl_GetMenuIndex() < 0 )
    {
        PKT_TitlePKT();                                     // kein Menue vorhanden -> PKT-Version anzeigen
        return;
    }

    pStr  = MenuCtrl_GetItemText();
    isPGM = MenuCtrl_IsItemTextPGM();

    _pkt_title( isPGM, pStr, lShowLipo, true );             // true = clearscreen
}



//#############################################################################################
//# PKT Message
//#############################################################################################

//--------------------------------------------------------------
// _pkt_message( progmem, text, error, timeout, beep, clearscreen)
//
// INTERN
// fuer: PKT_Message(), PKT_Message_P()
// Parameter? -> siehe dort...
//--------------------------------------------------------------
void _pkt_message( uint8_t progmem, const char *text, uint8_t error, uint16_t timeout, uint8_t beep, uint8_t clearscreen )
{
    char *pStr;

    if( clearscreen )
        lcd_cls();

    PKT_TitlePKT();

    if( error )
    {
        //lcd_frect_round(   0+36, (2*8)-2, 127-73, 8+2, 1, R1);        // Fill: Schwarz
        lcd_frect_round(   0+36, (2*8)-1, 127-74, 8+2, 1, R1);          // Fill: Schwarz
        lcdx_printp_center( 2, strGet(STR_ERROR), MINVERS, 0,1);        // "FEHLER"
    }
    else
        lcdx_printp_center( 2, strGet(STR_PKT)  , MNORMAL, 0,1);        // "PKT"


    //-----------------------
    // Ausgabe der Nachricht
    //-----------------------
    pStr = buffered_sprintf_P( ( progmem ? PSTR("%20S") : PSTR("%20s")), text); // max. 20 Zeichen
    strrtrim( pStr );                                                           // alle Leerzeichen rechts loeschen
    lcdx_print_center( 4, (uint8_t *)pStr, MNORMAL, 0,5);                       // Text zentriert; String im RAM
    lcd_rect_round( 0, 32, 127, 16, 1, R2);                                     // Rahmen

    if( beep )
    {
        if( error )
            set_beep( 1000, 0xffff, BeepNormal );                       // langer Error-Beep
        else
            set_beep( 25, 0xffff, BeepNormal );                         // kurzer Bestaetigungs-Beep
    }

    if( timeout )
    {
        //lcd_printp_at( 19, 7, strGet(OK), MNORMAL);                   // Keyline... tja, welche Variante nehmen wir denn nun Final??? OK oder ENDE?
        lcd_printp_at(12, 7, strGet(ENDE), MNORMAL);                    // Keyline

        clear_key_all();

        timer2 = timeout;                                               // max. Anzeigezeit (z.B. 800 = 8 Sekunden)
        while( timer2 > 0 )
        {
            //if( get_key_short(1 << KEY_ENTER) )   break;
            if( get_key_short(1 << KEY_ESC) )       break;
            PKT_CtrlHook();
        }
    }
    clear_key_all();
}



//--------------------------------------------------------------
// PKT_Message( text, error, timeout, beep, clearscreen)
//
// zeigt eine Nachricht an ggf. mit Display-Timeout, Tasten, Beep (String im RAM)
//
// Parameter:
//  text       : String im RAM
//  error      : true/false
//  timeout    : 0 = direktes Verlassen der Funktion ohne warten
//               1..nnnn = max. Anzeigezeit (timer); Keyline wird
//                  eingeblendet -> Benutzer kann auch eher beenden
//  beep       : true/false - bei true haengt die Art des Beep's von 'error' ab
//  clearscreen: true/false - ggf. Bildschirm loeschen
//--------------------------------------------------------------
void PKT_Message( const char *text, uint8_t error, uint16_t timeout, uint8_t beep, uint8_t clearscreen )
{
    _pkt_message( false, text, error, timeout, beep, clearscreen );
}



//--------------------------------------------------------------
// PKT_Message_P( text, error, timeout, beep, clearscreen)
//
// zeigt eine Nachricht an ggf. mit Display-Timeout, Tasten, Beep (String im PROGMEM)
//
// Parameter:
//  text     : String im PROGMEM
//  error    : true/false
//  timeout  : 0 = direktes Verlassen der Funktion ohne warten
//             1..nnnn = max. Anzeigezeit (timer); Keyline wird
//                eingeblendet -> Benutzer kann auch eher beenden
//  beep     : true/false - bei true haengt die Art des Beep's von 'error' ab
//  clrscreen: true/false - ggf. Bildschirm loeschen
//--------------------------------------------------------------
void PKT_Message_P( const char *text, uint8_t error, uint16_t timeout, uint8_t beep, uint8_t clearscreen )
{
    _pkt_message( true, text, error, timeout, beep, clearscreen );
}



//--------------------------------------------------------------
// PKT_Message_Datenverlust( timeout, beep)
//--------------------------------------------------------------
void PKT_Message_Datenverlust( uint16_t timeout, uint8_t beep )
{
  //_pkt_message( true, text,                 error, timeout, beep, clearscreen );
    _pkt_message( true, strGet(ERROR_NODATA), true,  timeout, beep, true );
}



//#############################################################################################
//# PKT Popup
//#############################################################################################

//--------------------------------------------------------------
// INTERN
//
// PARAMETER:
//   progmem : true  = Texte in PROGMEM
//             false = Texte im RAM (RAM geht noch nicht!)
//   timeout : Zeit bis zum automatischen beenden (z.B. 400 = 4 Sekunden)
//             wenn timeout == 0 dann direkt beenden ohne auf Tastendruck zu warten
//   text1..4: Text (die Hoehe des Popups berechnet sich aus der Anzahl der Texte)
//             -> ein nicht benutzer Text wird mit NULL oder Dezimal 0 uebergeben
//--------------------------------------------------------------
void _pkt_popup( uint8_t progmem, uint16_t timeout, const char *text1, const char *text2, const char *text3, const char *text4)
{
    uint8_t n     = 0;
    uint8_t yoffs = 0;

    if( text1 ) { n = 1; yoffs = 1; }
    if( text2 ) { n = 2; yoffs = 2; }
    if( text3 ) { n = 3; yoffs = 2; }
    if( text4 ) { n = 4; yoffs = 3; }

    Popup_Draw(n+1);

    if( text1 ) lcdx_printp_center(  8-n, text1, MINVERS, 0,-5-yoffs);          // Text zentriert; String im PROGMEM
    if( text2 ) lcdx_printp_center(  9-n, text2, MINVERS, 0,-4-yoffs);          // Text zentriert; String im PROGMEM
    if( text3 ) lcdx_printp_center( 10-n, text3, MINVERS, 0,-3-yoffs);          // Text zentriert; String im PROGMEM
    if( text4 ) lcdx_printp_center( 11-n, text4, MINVERS, 0,-2-yoffs);          // Text zentriert; String im PROGMEM

    if( timeout )
    {
        clear_key_all();

        timer2 = timeout;                                                       // max. Anzeigezeit (z.B. 800 = 8 Sekunden)
        while( timer2 > 0 )
        {
            if(    get_key_short(1<<KEY_ESC)
                || get_key_short(1<<KEY_ENTER)
                || get_key_short(1<<KEY_PLUS)
                || get_key_short(1<<KEY_MINUS) )
            {
                break;
            }
        }

        lcd_frect( 0, 58-((n+1)*8), 127,  5+((n+1)*8), 0);                      // Box clear - der Bereich des Popup's wird wieder geloescht (nur wenn timeout > 0!)
    }
    clear_key_all();
}



//--------------------------------------------------------------
// PKT_Popup( timeout, text1, text2, text3, text4 )
//
// Texte im RAM
//--------------------------------------------------------------
void PKT_Popup( uint16_t timeout, const char *text1, const char *text2, const char *text3, const char *text4 )
{
    _pkt_popup( false, timeout, text1, text2, text3, text4 );
}



//--------------------------------------------------------------
// PKT_Popup_P( timeout, text1, text2, text3, text4 )
//
// Texte im PROGMEM
//--------------------------------------------------------------
void PKT_Popup_P( uint16_t timeout, const char *text1, const char *text2, const char *text3, const char *text4 )
{
    _pkt_popup( true, timeout, text1, text2, text3, text4 );
}



//#############################################################################################
//# PKT Ask
//#############################################################################################

//--------------------------------------------------------------
// wahl = PKT_AskX( asktype, text1, text2, text_progmem, headline, headline_progmem, title, title_progmem)
//
// PARAMETER:
//   asktype         : ASK_YES_NO, ASK_NO_YES, ASK_CANCEL_OK, ASK_END_OK, ASK_END_START
//   text1           : 1. Zeile Text
//   text2           : optionale 2. Zeile Text
//   text_progmem    : text1 & text2 in PROGMEM oder RAM  (PROGMEM = true)
//   headline        : Ueberschrift
//   headline_progmem: -> PROGMEM oder RAM
//   title           : ganz oben der Titel (Zeile 0, Invers)
//   title_progmem   : -> PROGMEM oder RAM
//
// RUECKGABE:
//   true  : Ja
//   false : Nein
//--------------------------------------------------------------
uint8_t PKT_AskX( uint8_t asktype, const char *text1, const char *text2, uint8_t text_progmem, const char *headline, uint8_t headline_progmem, const char *title, uint8_t title_progmem )
{
    uint8_t redraw   = true;
    uint8_t keyenter = false;
    uint8_t retcode  = false;
    const char *pMaskP;
    const char *pMaskR;
    const char *pMask;

    pMaskP = PSTR("%S");
    pMaskR = PSTR("%s");

    set_beep( 35, 0xffff, BeepNormal );                                     // kurzer Beep

    while( true )
    {
        //------------------------
        // Screen zeichnen
        //------------------------
        if( redraw )
        {
            if(      title == NULL )    PKT_TitlePKT();                     // Titel mit PKT-Version anzeigen (und clearscreen)
            else if( title_progmem )    PKT_Title_P( title, true, true );   // uebergebenen Titel anzeigen (und clearscreen) (PROGMEM)
            else                        PKT_Title(   title, true, true );   // uebergebenen Titel anzeigen (und clearscreen) (RAM)

            if( text2 == NULL )
            {
                // 1 zeiliger Text
                pMask = (headline_progmem ? pMaskP : pMaskR);               // Formatmaske fuer headline je nach PROGMEN oder RAM
                lcdx_printf_center_P( 2, MNORMAL, 0,2, pMask, headline);    // headline

                lcd_rect_round( 0, 3*7+2+10, 127, 16+0, 1, R2);             // Rahmen

                pMask = (text_progmem ? pMaskP : pMaskR);                   // Formatmaske fuer text1 und text2 je nach PROGMEN oder RAM
                lcdx_printf_center_P( 4, MNORMAL, 0,6, pMask, text1);       // text1
            }
            else
            {
                // 2 zeiliger Text
                pMask = (headline_progmem ? pMaskP : pMaskR);               // Formatmaske fuer headline je nach PROGMEN oder RAM
                lcdx_printf_center_P( 2, MNORMAL, 0,-1, pMask, headline);   // headline

                lcd_rect_round(0, 4*8-5, 127, 16+7, 1, R2);                 // Rahmen

                pMask = (text_progmem ? pMaskP : pMaskR);                   // Formatmaske fuer text1 und text2 je nach PROGMEN oder RAM
                lcdx_printf_center_P( 4, MNORMAL, 0,-1, pMask, text1);      // text1
                lcdx_printf_center_P( 5, MNORMAL, 0, 0, pMask, text2);      // text2
            }


            //------------------------
            // Keyline
            //------------------------
            switch( asktype )
            {
                case ASK_NO_YES:     lcd_printp_at(12, 7, strGet(NOYES), MNORMAL);               // Keyline: "Nein   Ja"
                                     break;

                case ASK_YES_NO:     lcd_printp_at(12, 7, strGet(YESNO), MNORMAL);               // Keyline: "Nein   Ja"
                                     break;

                case ASK_CANCEL_OK:  lcd_printp_at(11, 7, strGet(KEYCANCEL), MNORMAL);           // Keyline: "Abbr.   OK"
                                     lcd_printp_at(19, 7, PSTR("OK")       , MNORMAL);
                                     break;

                case ASK_END_OK:     lcd_printp_at(12, 7, strGet(KEYLINE4), MNORMAL);            // Keyline: "Ende   OK"
                                     break;

                case ASK_END_START:  lcd_printp_at(11, 7, strGet(ENDSTART), MNORMAL);            // Keyline: "Ende Start"
                                     break;
            }

            redraw = false;
        }

        //------------------------
        // LiPo Spannung zeigen
        //------------------------
        show_Lipo();

        //------------------------
        // ggf. auf PKT-Update reagieren
        //------------------------
        if( PKT_CtrlHook() )
        {
            redraw = true;
        }

        //------------------------
        // Tasten abfragen
        //------------------------
        if( get_key_short(1 << KEY_ESC) )       // 3. Taste
        {
            break;
        }

        if( get_key_press(1 << KEY_ENTER) )     // 4. Taste
        {
            keyenter = true;
            break;
        }
    } // end: while( true )


    //-------------------------
    retcode = keyenter;
    if( asktype == ASK_YES_NO ) retcode = !retcode;

    clear_key_all();

    return retcode;
}


//--------------------------------------------------------------
// wahl = PKT_Ask( asktype, text1, text2, headline, title)
//
// text1 und text2 im RAM
//--------------------------------------------------------------
uint8_t PKT_Ask( uint8_t asktype, const char *text1, const char *text2, const char *headline, const char *title )
{
  //wahl = PKT_AskX( asktype, text1, text2, text_progmem, headline, headline_progmem, title, title_progmem)
    return PKT_AskX( asktype, text1, text2, false, headline, true, title, true);
  //return _pkt_ask( false, asktype, text1, text2, headline, title);
}



//--------------------------------------------------------------
// wahl = PKT_Ask_P( asktype, text1, text2, headline, title)
//
// text1 und text2 im PROGMEM
//--------------------------------------------------------------
uint8_t PKT_Ask_P( uint8_t asktype, const char *text1, const char *text2, const char *headline, const char *title )
{
  //wahl = PKT_AskX( asktype, text1, text2, text_progmem, headline, headline_progmem, title, title_progmem)
    return PKT_AskX( asktype, text1, text2, true, headline, true, title, true);
  //return _pkt_ask( true, asktype, text1, text2, headline, title);
}


//#############################################################################################
//# PKT Gauge
//#############################################################################################

uint8_t Gauge_px;
uint8_t Gauge_py;
uint8_t Gauge_rx;
uint8_t Gauge_ry;
uint8_t Gauge_step;
volatile uint8_t Gauge_active;          // wird in timer.c abgefragt

#define GAUGE_DEFAULT_PX    64          // Default X (Pixel)
#define GAUGE_DEFAULT_PY    40          // Default Y (Pixel)
#define GAUGE_DEFAULT_RX    10          // Default Radius X Gauge-Kreis
#define GAUGE_DEFAULT_RY     8          // Default Radius Y Gauge-Kreis

#define GAUGE_TIMER         40          // alle n aktualisieren (Timer Intervall)
#define GAUGE_DEGREE        45          // Winkel von Schritt zu Schritt
#define GAUGE_LROFFS        -2          // die Laenge der Gauge-Linie verringern/vergroessern

//--------------------------------------------------------------
// PKT_Gauge_Begin( py )
//--------------------------------------------------------------
void PKT_Gauge_Begin( uint8_t py )
{
    Gauge_px = GAUGE_DEFAULT_PX;
    Gauge_py = GAUGE_DEFAULT_PY;
    Gauge_rx = GAUGE_DEFAULT_RX;
    Gauge_ry = GAUGE_DEFAULT_RY;

    if( py>0 ) Gauge_py = py;

    Gauge_step   = 0;
    timer_gauge  = GAUGE_TIMER;
    Gauge_active = true;

    lcd_ellipse_line( Gauge_px, Gauge_py, Gauge_rx+GAUGE_LROFFS, Gauge_ry+GAUGE_LROFFS, (0), 1);
    lcd_ellipse( Gauge_px, Gauge_py, Gauge_rx, Gauge_ry, 1);
}


//--------------------------------------------------------------
// PKT_Gauge_End()
//--------------------------------------------------------------
void PKT_Gauge_End( void )
{
    Gauge_active = false;
}


//  uint8_t old_step;

//--------------------------------------------------------------
// PKT_Gauge_Next()
//
// INTERN fuer Timer ISR!
//--------------------------------------------------------------
void PKT_Gauge_Next( void )
{
    uint8_t old_step;

    old_step = Gauge_step;
    Gauge_step++;
    if( Gauge_step >= (360/GAUGE_DEGREE))   Gauge_step = 0;

    lcd_ellipse_line( Gauge_px, Gauge_py, Gauge_rx+GAUGE_LROFFS, Gauge_ry+GAUGE_LROFFS, (old_step*GAUGE_DEGREE)  , 0);
    lcd_ellipse_line( Gauge_px, Gauge_py, Gauge_rx+GAUGE_LROFFS, Gauge_ry+GAUGE_LROFFS, (Gauge_step*GAUGE_DEGREE), 1);

    timer_gauge  = GAUGE_TIMER;
}



//#############################################################################################
//# PKT Kontrollfunktionen
//#############################################################################################

//--------------------------------------------------------------
//--------------------------------------------------------------
void PKT_Reset_EEprom( void )
{
    // Text1: "PKT-EEProm"        (EEPROM1)
    // Text2: "wirklich löschen?" (EEPROM2)
    // Head : "* ACHTUNG '"       (STR_ATTENTION)
    // Titel: PKT-Version         (NULL)

    if( PKT_Ask_P( ASK_YES_NO, strGet(EEPROM1), strGet(EEPROM2), strGet(STR_ATTENTION), NULL) )
    {
        Delete_EEPROM();
        clr_V_On();
    }
}



//--------------------------------------------------------------
//--------------------------------------------------------------
void PKT_SwitchOff( void )
{
    // Text1: "PKT ausschalten?"  (SHUTDOWN)
    // Text2: NULL
    // Head : "PKT"               (STR_PKT)
    // Titel: PKT-Version         (NULL)

    if( PKT_Ask_P( ASK_NO_YES, strGet(SHUTDOWN), NULL, strGet(STR_PKT), NULL) )
    {
        WriteParameter();   // am Ende alle Parameter sichern
        clr_V_On();         // Spannung abschalten
    }
}



//--------------------------------------------------------------
//--------------------------------------------------------------
void PKT_Ask_Restart( const char *title )
{
    // Text1: "jetzt ausschalten?"  (STR_PKT_SWITCHOFF_NOW)
    // Text2: NULL
    // Head : "PKT neu starten!"    (STR_PKT_RESTART_NOW)
    // Titel: via Parameter

    if( PKT_Ask_P( ASK_NO_YES, strGet(STR_PKT_SWITCHOFF_NOW), NULL, strGet(STR_PKT_RESTART_NOW), title) )
    {
        WriteParameter();       // am Ende alle Parameter sichern
        clr_V_On();             // Spannung abschalten
    }
}



//--------------------------------------------------------------
//--------------------------------------------------------------
void PKT_Update( void )
{
    // Text1: "Drücke 'Start' für"   (UPDATE2)
    // Text2: "min. 2 Sekunden"      (UPDATE3)
    // Head : "Verbinde PKT mit PC!" (UPDATE1)
    // Titel: "PKT Update"

    if( PKT_Ask_P( ASK_END_START, strGet(UPDATE2), strGet(UPDATE3), strGet(UPDATE1), PSTR("PKT Update")) )
    {
        uart1_putc('S');            // Startzeichen zum Updatetool schicken
        wdt_enable( WDTO_250MS );   // start bootloader with Reset, Hold KEY_ENTER
        while(true);
    }
}



//void PKT_Update( void )
//{
//    ShowTitle_P( PSTR("PKT Update"), true );
//    lcdx_printp_center( 2, strGet(UPDATE1), MNORMAL, 0,-1);      // "Verbinde PKT mit PC!"
//    lcd_rect_round(0, 4*8-5, 127, 16+7, 1, R2);                  // Rahmen
//    lcdx_printp_center( 4, strGet(UPDATE2), MNORMAL, 0,-1);      // "Drücke 'Start' für"
//    lcdx_printp_center( 5, strGet(UPDATE3), MNORMAL, 0, 0);      // "min. 2 Sekunden"
//    lcd_printp_at(11, 7, strGet(ENDSTART), MNORMAL);           // Keyline
//    //PKTupdate = false; // Flag löschen
//
//    set_beep( 80, 0x000f, BeepNormal);                           // kurzer Beep
//
//    do
//    {
//        if( get_key_press (1 << KEY_ESC) )
//        {
//            //get_key_press(KEY_ALL);
//            clear_key_all();
//            return;
//        }
//    }
//    while( !(get_key_press (1 << KEY_ENTER)) );
//
//    uart1_putc('S');          // Startzeichen zum Updatetool schicken
//    wdt_enable( WDTO_250MS ); // start bootloader with Reset, Hold KEY_ENTER
//    while(true);
//}



//--------------------------------------------------------------
// prueft im Menue ob das Updatetool ein Update machen will
//--------------------------------------------------------------
uint8_t PKT_CheckUpdate(void)
{
    unsigned int uart_data;
    uint8_t state         = 0;
    uint8_t update        = false;
    uint8_t error         = false;
    uint8_t SendVersion   = false;
    char s[7];


    //----------------------------
    // empfangen
    //----------------------------
    if( uart1_available() > 0 )             // Zeichen von der USB-Schnittstelle vorhanden?
    {
        timer_pktupdatecheck = 100;         // Timeouttimer um die Funktion abzubrechen

        while( !timer_pktupdatecheck==0 && !update && !error && !SendVersion )
        {
            uart_data = uart1_getc();
            if( !((uart_data & 0xFF00) == UART_NO_DATA) )
            {
                switch (state)
                {
                    case  0:    if( uart_data == PKTESC )
                                {
                                    state = 1;
                                }
                                else error = true;
                                break;

                    case  1:    if( uart_data == PKTESC )
                                {
                                    state = 2;
                                }
                                else error = true;
                                break;

                    case  2:    if(      uart_data == PKTUPDATE ) update = true;
                                else if (uart_data == PKTVERSION) SendVersion = true;
                                else error = true;
                                break;
                } // end: switch
            } // end: if
        } // end: while


        //----------------------------
        // Rueckmeldungen
        //----------------------------
        if( error )
        {
            uart1_putc('E');                            // Rueckmeldungen zum Updatetool
        }
        else if( update )
        {
            uart1_putc('U');
        }
        else if( SendVersion )
        {
            uart1_putc('V');
            itoa( EEpromVersion, s, 10 );
            uart1_puts(s);
         }
        else if( timer_pktupdatecheck==0 )
        {
            uart1_putc('T');
        }

         //uart1_flush();
    }

    return update;
}



//--------------------------------------------------------------
// retcode = PKT_CtrlHook()
//
// ruft ggf. PKT_Update() auf und kann spaeter weitere PKT interne
// Sachen verarbeiten wenn der Hook (=Nagel) in entsprechende
// Routienen eingebaut ist (z.B. senden von Daten an den PC)
//
// Aktuell verwendet von: menuctrl, scrollbox, osd
//
// Rueckgabe:
//   retcode: 0 = nichts wurde gemacht (false)
//            1 = es wurde etwas durchgefuehrt und die Aufruffunktion
//                muss gff. einen Screenrefresh durchfuehren
//                (z.B. wenn der PKT-Update Screen gezeigt wurde)
//--------------------------------------------------------------
uint8_t PKT_CtrlHook( void )
{
    uint8_t retcode = 0;

    // 31.05.2014 OG: PKT_CheckUpdate() darf nicht in 'Hoechstgeschwindigkeit'
    // aufgerufen werden da es sonst seitens des PKT-Updatetools ggf. zu einer
    // Fehlermeldung kommt - deswegen hier timer_pktupdatecheck der PKT_CheckUpdate
    // etwas einbremst sich aber nicht negativ auf die PKT-Performance auswirkt.
    if( !timer_pktupdatecheck )
    {
        if( PKT_CheckUpdate() )                  // Update vom Updatetool angefordert?
        {
            WriteParameter();
            PKT_Update();
            retcode = 1;
        }
        timer_pktupdatecheck = 10;
    }

    return retcode;
}



//--------------------------------------------------------------
// zeigt PKT-Version und Credits / Entwickler
//--------------------------------------------------------------
void PKT_Info( void )
{
    char *HWV_39m = "3.9m";
    char *HWV_39x = "3.9x";
    char *HWV     = "????";

    if( PCB_Version == PKT39m )    HWV = HWV_39m;
    if( PCB_Version == PKT39x )    HWV = HWV_39x;

    lcd_cls();

    if( !ScrollBox_Create(55) )     // max. 55 Zeilen
        return;                     //   kein RAM mehr

    ScrollBox_Push_P( MINVERS, PSTR(" PKT v%8S %s"), PSTR(PKTSWVersion), HWV );     // "3.6.8a..." und die PKT-Hardwareversion
    ScrollBox_Push_P( MINVERS, PSTR(" %S SV2-Patch"), (PCB_SV2RxTxPatch ? strGet(STR_WITH) : strGet(STR_WITHOUT)) );
    ScrollBox_Push_P( MNORMAL, PSTR("") );
    ScrollBox_Push_P( MNORMAL, PSTR("(C) GNU GPL License") );
    ScrollBox_Push_P( MNORMAL, PSTR("    NO WARRANTY") );
    ScrollBox_Push_P( MNORMAL, PSTR("") );


#ifdef USE_MODULEINFO

    const char *fmt = PSTR("%15S %4S");

    //--- MODULE SUPPORT INFO ---
    ScrollBox_Push_P( MINVERS, PSTR(" Modules installed") );

    #ifdef USE_BLUETOOTH
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Bluetooth"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Bluetooth"), strGet(NOO) );
    #endif


    #ifdef USE_WLAN
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("WLAN WyFly"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("WLAN WyFly"), strGet(NOO) );
    #endif


    #ifdef USE_MKSETTINGS
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Settings"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Settings"), strGet(NOO) );
    #endif


    #ifdef USE_MKDEBUGDATA
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Debug Data"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Debug Data"), strGet(NOO) );
    #endif


    #ifdef USE_MKDISPLAY
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Display"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("MK Display"), strGet(NOO) );
    #endif


    #ifdef USE_OSDDATA
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD-Data"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD-Data"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_OLD
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Old Screens"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Old Screens"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_NAVIGATION
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Navigation"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Navigation"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_WAYPOINTS
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Waypoints"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Waypoints"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_ELECTRIC
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Electric"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Electric"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_MKSTATUS
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD MKStatus"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD MKStatus"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_USERGPS
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD UserGPS"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD UserGPS"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_3DLAGE
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD 3D-Lage"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD 3D-Lage"), strGet(NOO) );
    #endif


    #ifdef USE_OSD_SCREEN_STATISTIC
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Statistic"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("OSD Statistic"), strGet(NOO) );
    #endif


    #ifdef USE_TRACKING
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Tracking"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Tracking"), strGet(NOO) );
    #endif


    #ifdef USE_FOLLOWME
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Follow Me"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Follow Me"), strGet(NOO) );
    #endif


    #ifdef USE_JOYSTICK
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Joystick"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Joystick"), strGet(NOO) );
    #endif


    #ifdef USE_I2CMOTORTEST
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("I2C Motortest"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("I2C Motortest"), strGet(NOO) );
    #endif


    #ifdef USE_SOUND
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Sound"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Sound"), strGet(NOO) );
    #endif


    #ifdef USE_FONT_BIG
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Font Big"), strGet(YES) );
    #else
        ScrollBox_Push_P( MNORMAL, fmt, PSTR("Font Big"), strGet(NOO) );
    #endif

    ScrollBox_Push_P( MNORMAL, PSTR("") );

#endif // USE_MODULEINFO


    //--- CREDITS INFO ---
    ScrollBox_Push_P( MINVERS, PSTR(" Credits") );
    ScrollBox_Push_P( MNORMAL, PSTR("2013 Oliver Gemesi") );
    ScrollBox_Push_P( MNORMAL, PSTR("2012 Chr. Brandtner" ) );
    ScrollBox_Push_P( MNORMAL, PSTR("     Harald Bongartz") );
    ScrollBox_Push_P( MNORMAL, PSTR("2012 Martin Runkel") );
    ScrollBox_Push_P( MNORMAL, PSTR("2012 gebad") );
    ScrollBox_Push_P( MNORMAL, PSTR("2010 Sebastian Boehm") );
    ScrollBox_Push_P( MNORMAL, PSTR("2009-2010 Peter Mack") );
    ScrollBox_Push_P( MNORMAL, PSTR("2008 Thomas Kaiser") );

    ScrollBox_Show();
    ScrollBox_Destroy();            // free memory
}