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

    }

}