WebSVN - Projects - /Transportables_Koptertool/PKT/GPL_PKT_V3

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

Subversion Repositories Projects

(root)/Transportables_Koptertool/PKT/GPL_PKT_V3_85f/pkt/pkt.c @ 2143 - Rev