WebSVN - Projects - Diff - Rev 758 and 761 - /C-OSD/trunk/osd_ncmode


/****************************************************************************
 *   Copyright (C) 2009-2010 by Claas Anders "CaScAdE" Rathje               *
 *   admiralcascade@gmail.com                                               *
 *   Project-URL: http://www.mylifesucks.de/oss/c-osd/                      *
 *                                                                          *
 *   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.              *
 ****************************************************************************/
 
#include "main.h"
#include "max7456_software_spi.h"
#include "osd_helpers.h"
#include "osd_ncmode_default.h"
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 
int osd_ncmode_default() {
    uint8_t rc_signal = naviData.RC_RSSI ? naviData.RC_RSSI : naviData.RC_Quality; // if RSSI is present use it, else use Qality
 
    if (COSD_FLAGS_MODES & COSD_FLAG_HUD) {
        // write icons at init or after menu/mode-switch
        if (!(COSD_FLAGS_RUNTIME & COSD_ICONS_WRITTEN)) {
            if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
                write_char_xy(5, top_line, 0x7D); // mph
                write_char_xy(27, top_line + 1, 0x7E); // small feet ft home
                write_char_xy(27, top_line, 0x7E); // small feet ft height
            } else {
                write_char_xy(5, top_line, 0xCB); // km/h
                write_char_xy(27, top_line + 1, 0xCC); // small meters m home
                write_char_xy(27, top_line, 0xCC); // small meters m height
            }
 
            write_char_xy(10, top_line, 0xCA); // RC-transmitter
            write_char_xy(16, top_line, 0xD0); // degree symbol
 
            write_char_xy(20, top_line + 1, 0xB0); // left circle
            write_char_xy(22, top_line + 1, 0xB2); // right circle
 
 
            write_char_xy(7, bottom_line, 0x9E); // small V
            if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) || (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                write_char_xy(7, bottom_line - 1, 0x9F); // small A
                write_char_xy(14, bottom_line - 1, 0xB5); // mah
                if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {
                    write_char_xy(21, bottom_line - 1, 0x9E); // small V
                }
            }
            write_char_xy(14, bottom_line, 0xD1); // on clock
            write_char_xy(21, bottom_line, 0xD2); // fly clock
            write_char_xy(26, bottom_line, 0xC8); // sat1
            write_char_xy(27, bottom_line, 0xC9); // sat2
            COSD_FLAGS_RUNTIME |= COSD_ICONS_WRITTEN;
        }
 
        // first line
        if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
            // experimental cm/s -> mph
            write_ndigit_number_u(2, top_line, (uint16_t)(((uint32_t)naviData.GroundSpeed * (uint32_t)279) / (uint32_t)12500), 3, 0);
        } else {
            write_ndigit_number_u(2, top_line, (uint16_t)(((uint32_t)naviData.GroundSpeed * (uint32_t)9) / (uint32_t)250), 3, 0);
        }
 
        write_ndigit_number_u(7, top_line, rc_signal, 3, 0);
        if (rc_signal <= RCLVL_WRN && last_RC_Quality > RCLVL_WRN) {
            for (uint8_t x = 0; x < 4; x++)
                write_char_att_xy(7 + x, top_line, BLINK);
        } else if (rc_signal > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {
            for (uint8_t x = 0; x < 4; x++)
                write_char_att_xy(7 + x, top_line, 0);
        }
 
 
        if (naviData.NCFlags & NC_FLAG_NOSERIALLINK) {
            write_char_xy(11, top_line, 0); // clear
        } else {
            write_char_xy(11, top_line, 0xC6); // PC icon
        }
 
        write_ndigit_number_u(13, top_line, naviData.CompassHeading, 3, 0);
 
        write_ascii_string_pgm(17, top_line, (const char *)(pgm_read_word(&(directions[heading_conv(naviData.CompassHeading)]))));
 
        draw_variometer(21, top_line, naviData.Variometer);
 
        if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {
            if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
                // feet
                write_ndigit_number_s(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 1000 - altimeter_offset) * 32 / 10, 4, 0); // GPS
            } else {
                if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > 10 || naviData.CurrentPosition.Altitude / 1000 - altimeter_offset < -10) {
                    // above 10m only write full meters
                    write_ndigit_number_s(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 1000 - altimeter_offset), 4, 0); // GPS
                } else {
                    // up to 10m write meters.dm
                    write_ndigit_number_s_10th(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 100 - altimeter_offset * 10), 3, 0); // GPS
                }
            }
        } else {
            if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
                write_ndigit_number_s(23, top_line, naviData.Altimeter / 10 * 32 / 30, 4, 0); // BARO
            } else {
                //note:lephisto:according to several sources it's /30
                if (naviData.Altimeter > 300 || naviData.Altimeter < -300) {
                    // above 10m only write full meters
                    write_ndigit_number_s(23, top_line, naviData.Altimeter / 30, 4, 0); // BARO
                } else {
                    // up to 10m write meters.dm
                    write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 3, 0); // BARO
                }
            }
        }
 
 
        // seccond line
        draw_compass(11, top_line + 1, naviData.CompassHeading);
 
        // TODO: verify correctness
        uint16_t heading_home = (naviData.HomePositionDeviation.Bearing + 360 - naviData.CompassHeading) % 360;
        //write_char_xy(21, top_line + 1, arrowdir[heading_conv(heading_home)]);
        // finer resolution, 0xa0 is first character and we add the index 0 <= index < 16
        write_char_xy(21, top_line + 1, 0xa0 + heading_fine_conv(heading_home));
 
        if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
            // feet
            write_ndigit_number_u(23, top_line + 1, naviData.HomePositionDeviation.Distance / 10 * 32 / 10, 4, 0);
        } else {
            write_ndigit_number_u(23, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 4, 0);
        }
 
        // center
        if (naviData.FCFlags & FLAG_MOTOR_RUN) { // should be engines running
            if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle
                clear();
                // remember current heigth for gps offset
                altimeter_offset = naviData.CurrentPosition.Altitude / 1000;
                // set wasted counter to current offset
                if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                    wasted_ampere_offset = ampere_wasted / 10;
                } else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
                    wasted_ampere_offset = naviData.UsedCapacity;
                }
                // update flags to paint display again if needed
                COSD_FLAGS_RUNTIME &= ~COSD_ICONS_WRITTEN;
            }
            if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // horizon
                uint8_t horizon_bottom = bottom_line - 1;
                if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) || (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                    horizon_bottom--;
                }
                if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {
                    draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
                } else {
                    draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
                }
            }
            // motors are on, assume we were/are flying
            COSD_FLAGS_RUNTIME |= COSD_WASFLYING;
        } else {
            if ((old_MKFlags & FLAG_MOTOR_RUN)) { // motors just stopped
                clear(); // clear whole screen in case there is horizon stuff left
                // update flags to paint display again if needed
                COSD_FLAGS_RUNTIME &= ~COSD_ICONS_WRITTEN;
            }
            // stats
            if ((COSD_FLAGS_RUNTIME & COSD_WASFLYING) && (COSD_FLAGS_MODES & COSD_FLAG_STATS)) {
                uint8_t line = 3;
                write_ascii_string_pgm(1, line, (const char *)(pgm_read_word(&(stats_item_pointers[0])))); // max Altitude
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[1])))); // max Speed
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[2])))); // max Distance
 
                if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
                    write_ndigit_number_s(16, line - 2, max_Altimeter * 32 / 10, 4, 0);
                    write_char_xy(20, line - 2, 0x7E); // small feet ft
                    write_ndigit_number_u(17, line - 1, (uint16_t)(((uint32_t)max_GroundSpeed * (uint32_t)279) / (uint32_t)12500), 3, 0);
                    write_char_xy(20, line - 1, 0x7D); // mp/h
                    write_ndigit_number_u(17, line - 0, max_Distance / 10 * 32 / 10, 3, 0);
                    write_char_xy(20, line - 0, 0x7E); // small feet ft
                } else {
                    write_ndigit_number_s(16, line - 2, max_Altimeter, 4, 0);
                    write_char_xy(20, line - 2, 204); // small meters m
                    write_ndigit_number_u(17, line - 1, (uint16_t)(((uint32_t)max_GroundSpeed * (uint32_t)9) / (uint32_t)250), 3, 0);
                    write_char_xy(20, line - 1, 203); // km/h
                    write_ndigit_number_u(17, line - 0, max_Distance / 10, 3, 0);
                    write_char_xy(20, line - 0, 204); // small meters m
                }
 
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[3])))); // min voltage
                write_ndigit_number_u_10th(16, line, min_UBat, 3, 0);
                write_char_xy(20, line, 0x9E); // small V
                if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) || (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                    write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[7])))); // ampere
                    write_ndigit_number_u_10th(16, line, max_ampere / 10, 3, 0);
                    write_char_xy(20, line, 0x9F); // small A
 
                    // wasted mampere in this flight (will count up after landing)
                    if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                        write_ndigit_number_u(21, line, (ampere_wasted / 10) - wasted_ampere_offset, 5, 0);
                    } else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
 
                        write_ndigit_number_u(21, line, naviData.UsedCapacity - wasted_ampere_offset, 5, 0);
                    }
 
                    write_char_xy(26, line, 0xB5); // mah
                }
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[4])))); // max time
                write_time(14, line, max_FlyingTime);
                write_char_xy(20, line, 210); // fly clock
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[5])))); // longitude
                write_gps_pos(14, line, naviData.CurrentPosition.Longitude);
                write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[6])))); // latitude
                write_gps_pos(14, line, naviData.CurrentPosition.Latitude);
            } else if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon
                uint8_t horizon_bottom = bottom_line - 1;
                if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) || (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
                    horizon_bottom--;
                }
                if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {
                    draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
                } else {
                    draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
                }
            }
        }
        if (COSD_FLAGS_MODES & COSD_FLAG_BIGVARIO) {
            draw_big_variometer(27, 8, naviData.Variometer);
        }
 
        // pre-bottom line
        if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
            //write_ndigit_number_s(3, bottom_line - 1, ampere, 4, 0);
            write_ndigit_number_u_10th(3, bottom_line - 1, ampere / 10, 3, 0);
            write_ndigit_number_s(10, bottom_line - 1, ampere_wasted / 10, 4, 0);
            if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {
                write_ndigit_number_u_10th(17, bottom_line - 1, s_volt, 3, 0);
            }
        } else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
            write_ndigit_number_u_10th(3, bottom_line - 1, naviData.Current, 3, 0);
            write_ndigit_number_u(10, bottom_line - 1, naviData.UsedCapacity, 4, 0);
        }
 
        //DEBUGwrite_ndigit_number_u(1, 5, COSD_FLAGS_MODES, 3, 0);
 
        // bottom line
        draw_battery(2, bottom_line, min_voltage, naviData.UBat, max_voltage);
        write_ndigit_number_u_10th(3, bottom_line, naviData.UBat, 3, 0);
        if (naviData.UBat <= min_voltage && last_UBat > min_voltage) {
            for (uint8_t x = 2; x < 8; x++)
                write_char_att_xy(x, bottom_line, BLINK);
        } else if (naviData.UBat > min_voltage && last_UBat < min_voltage) {
            for (uint8_t x = 2; x < 8; x++)
                write_char_att_xy(x, bottom_line, 0);
        }
 
        write_time(8, bottom_line, uptime);
        write_time(15, bottom_line, naviData.FlyingTime);
 
        write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 2, 0);
 
        if (naviData.NCFlags & NC_FLAG_MANUAL_CONTROL) {
            write_char_xy(23, bottom_line, 0xB3); // rc transmitter
        } else {
            write_char_xy(23, bottom_line, 0); // clear
        }
 
        if (naviData.NCFlags & NC_FLAG_CH) {
            write_char_xy(27, bottom_line, 231); // gps ch
        } else if (naviData.NCFlags & NC_FLAG_PH) {
            write_char_xy(27, bottom_line, 230); // gps ph
        } else { // (naviData.NCFlags & NC_FLAG_FREE)
            write_char_xy(27, bottom_line, 201); // sat2 (free)
        }
    }
 
    //write_number_s(8, 5, RxDataLen);
    //write_number_s(16, 5, setsReceived++);
 
    // remember statistics (only when engines running)
    if (naviData.FCFlags & FLAG_MOTOR_RUN) {
        if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {
            if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > max_Altimeter) max_Altimeter = naviData.CurrentPosition.Altitude / 1000;
        } else {
            if (naviData.Altimeter / 30 > max_Altimeter) max_Altimeter = naviData.Altimeter / 30;
        }
        if (naviData.GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData.GroundSpeed;
        if (naviData.HomePositionDeviation.Distance > max_Distance) {
            max_Distance = naviData.HomePositionDeviation.Distance;
        }
        if (naviData.UBat < min_UBat) min_UBat = naviData.UBat;
        if (naviData.FlyingTime > max_FlyingTime) max_FlyingTime = naviData.FlyingTime;
        if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
            if (ampere > max_ampere) max_ampere = ampere;
        } else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
            if (naviData.Current * 10 > max_ampere) max_ampere = naviData.Current * 10;
        }
    }
 
    // remember last values
    last_RC_Quality = rc_signal;
    last_UBat = naviData.UBat;
    old_MKFlags = naviData.FCFlags;
    seconds_since_last_data = 0;
 
    return 0;
}
 
#endif
 
 

Rev 758	Rev 761
1	/****************************************************************************	1	/****************************************************************************
2	* Copyright (C) 2009-2010 by Claas Anders "CaScAdE" Rathje *	2	* Copyright (C) 2009-2010 by Claas Anders "CaScAdE" Rathje *
3	* admiralcascade@gmail.com *	3	* admiralcascade@gmail.com *
4	* Project-URL: http://www.mylifesucks.de/oss/c-osd/ *	4	* Project-URL: http://www.mylifesucks.de/oss/c-osd/ *
5	* *	5	* *
6	* This program is free software; you can redistribute it and/or modify *	6	* This program is free software; you can redistribute it and/or modify *
7	* it under the terms of the GNU General Public License as published by *	7	* it under the terms of the GNU General Public License as published by *
8	* the Free Software Foundation; either version 2 of the License. *	8	* the Free Software Foundation; either version 2 of the License. *
9	* *	9	* *
10	* This program is distributed in the hope that it will be useful, *	10	* This program is distributed in the hope that it will be useful, *
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13	* GNU General Public License for more details. *	13	* GNU General Public License for more details. *
14	* *	14	* *
15	* You should have received a copy of the GNU General Public License *	15	* You should have received a copy of the GNU General Public License *
16	* along with this program; if not, write to the *	16	* along with this program; if not, write to the *
17	* Free Software Foundation, Inc., *	17	* Free Software Foundation, Inc., *
18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#include "main.h"	21	#include "main.h"
22	#include "max7456_software_spi.h"	22	#include "max7456_software_spi.h"
23	#include "osd_helpers.h"	23	#include "osd_helpers.h"
24	#include "osd_ncmode_default.h"	24	#include "osd_ncmode_default.h"
25		25
26	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))	26	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
27		27
28	int osd_ncmode_default() {	28	int osd_ncmode_default() {
29	uint8_t rc_signal = naviData.RC_RSSI?naviData.RC_RSSI:naviData.RC_Quality; // if RSSI is present use it, else use Qality	29	uint8_t rc_signal = naviData.RC_RSSI ? naviData.RC_RSSI : naviData.RC_Quality; // if RSSI is present use it, else use Qality
30		30
31	if (COSD_FLAGS_MODES & COSD_FLAG_HUD) {	31	if (COSD_FLAGS_MODES & COSD_FLAG_HUD) {
32	// write icons at init or after menu/mode-switch	32	// write icons at init or after menu/mode-switch
33	if (!(COSD_FLAGS_RUNTIME & COSD_ICONS_WRITTEN)) {	33	if (!(COSD_FLAGS_RUNTIME & COSD_ICONS_WRITTEN)) {
34	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	34	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
35	write_char_xy(5, top_line, 0x7D); // mph	35	write_char_xy(5, top_line, 0x7D); // mph
36	write_char_xy(27, top_line + 1, 0x7E); // small feet ft home	36	write_char_xy(27, top_line + 1, 0x7E); // small feet ft home
37	write_char_xy(27, top_line, 0x7E); // small feet ft height	37	write_char_xy(27, top_line, 0x7E); // small feet ft height
38	} else {	38	} else {
39	write_char_xy(5, top_line, 0xCB); // km/h	39	write_char_xy(5, top_line, 0xCB); // km/h
40	write_char_xy(27, top_line + 1, 0xCC); // small meters m home	40	write_char_xy(27, top_line + 1, 0xCC); // small meters m home
41	write_char_xy(27, top_line, 0xCC); // small meters m height	41	write_char_xy(27, top_line, 0xCC); // small meters m height
42	}	42	}
43		43
44	write_char_xy(10, top_line, 0xCA); // RC-transmitter	44	write_char_xy(10, top_line, 0xCA); // RC-transmitter
45	write_char_xy(16, top_line, 0xD0); // degree symbol	45	write_char_xy(16, top_line, 0xD0); // degree symbol
46		46
47	write_char_xy(20, top_line + 1, 0xB0); // left circle	47	write_char_xy(20, top_line + 1, 0xB0); // left circle
48	write_char_xy(22, top_line + 1, 0xB2); // right circle	48	write_char_xy(22, top_line + 1, 0xB2); // right circle
49		49
50		50
51	write_char_xy(7, bottom_line, 0x9E); // small V	51	write_char_xy(7, bottom_line, 0x9E); // small V
52	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	52	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
53	write_char_xy(7, bottom_line - 1, 0x9F); // small A	53	write_char_xy(7, bottom_line - 1, 0x9F); // small A
54	write_char_xy(14, bottom_line - 1, 0xB5); // mah	54	write_char_xy(14, bottom_line - 1, 0xB5); // mah
55	if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {	55	if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {
56	write_char_xy(21, bottom_line - 1, 0x9E); // small V	56	write_char_xy(21, bottom_line - 1, 0x9E); // small V
57	}	57	}
58	}	58	}
59	write_char_xy(14, bottom_line, 0xD1); // on clock	59	write_char_xy(14, bottom_line, 0xD1); // on clock
60	write_char_xy(21, bottom_line, 0xD2); // fly clock	60	write_char_xy(21, bottom_line, 0xD2); // fly clock
61	write_char_xy(26, bottom_line, 0xC8); // sat1	61	write_char_xy(26, bottom_line, 0xC8); // sat1
62	write_char_xy(27, bottom_line, 0xC9); // sat2	62	write_char_xy(27, bottom_line, 0xC9); // sat2
63	COSD_FLAGS_RUNTIME \|= COSD_ICONS_WRITTEN;	63	COSD_FLAGS_RUNTIME \|= COSD_ICONS_WRITTEN;
64	}	64	}
65		65
66	// first line	66	// first line
67	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	67	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
68	// experimental cm/s -> mph	68	// experimental cm/s -> mph
69	write_ndigit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * (uint32_t) 279) / (uint32_t) 12500), 3, 0);	69	write_ndigit_number_u(2, top_line, (uint16_t)(((uint32_t)naviData.GroundSpeed * (uint32_t)279) / (uint32_t)12500), 3, 0);
70	} else {	70	} else {
71	write_ndigit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);	71	write_ndigit_number_u(2, top_line, (uint16_t)(((uint32_t)naviData.GroundSpeed * (uint32_t)9) / (uint32_t)250), 3, 0);
72	}	72	}
73		73
74	write_ndigit_number_u(7, top_line, rc_signal, 3, 0);	74	write_ndigit_number_u(7, top_line, rc_signal, 3, 0);
75	if (rc_signal <= RCLVL_WRN && last_RC_Quality > RCLVL_WRN) {	75	if (rc_signal <= RCLVL_WRN && last_RC_Quality > RCLVL_WRN) {
76	for (uint8_t x = 0; x < 4; x++)	76	for (uint8_t x = 0; x < 4; x++)
77	write_char_att_xy(7 + x, top_line, BLINK);	77	write_char_att_xy(7 + x, top_line, BLINK);
78	} else if (rc_signal > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {	78	} else if (rc_signal > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {
79	for (uint8_t x = 0; x < 4; x++)	79	for (uint8_t x = 0; x < 4; x++)
80	write_char_att_xy(7 + x, top_line, 0);	80	write_char_att_xy(7 + x, top_line, 0);
81	}	81	}
82		82
83		83
84	if (naviData.NCFlags & NC_FLAG_NOSERIALLINK) {	84	if (naviData.NCFlags & NC_FLAG_NOSERIALLINK) {
85	write_char_xy(11, top_line, 0); // clear	85	write_char_xy(11, top_line, 0); // clear
86	} else {	86	} else {
87	write_char_xy(11, top_line, 0xC6); // PC icon	87	write_char_xy(11, top_line, 0xC6); // PC icon
88	}	88	}
89		89
90	write_ndigit_number_u(13, top_line, naviData.CompassHeading, 3, 0);	90	write_ndigit_number_u(13, top_line, naviData.CompassHeading, 3, 0);
91		91
92	write_ascii_string_pgm(17, top_line, (const char *) (pgm_read_word ( &(directions[heading_conv(naviData.CompassHeading)]))));	92	write_ascii_string_pgm(17, top_line, (const char *)(pgm_read_word(&(directions[heading_conv(naviData.CompassHeading)]))));
93		93
94	draw_variometer(21, top_line, naviData.Variometer);	94	draw_variometer(21, top_line, naviData.Variometer);
95		95
96	if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {	96	if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {
97	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	97	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
98	// feet	98	// feet
99	write_ndigit_number_s(23, top_line, (int16_t) (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset) * 32 / 10, 4, 0); // GPS	99	write_ndigit_number_s(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 1000 - altimeter_offset) * 32 / 10, 4, 0); // GPS
100	} else {	100	} else {
101	if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > 10 \|\| naviData.CurrentPosition.Altitude / 1000 - altimeter_offset < -10) {	101	if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > 10 \|\| naviData.CurrentPosition.Altitude / 1000 - altimeter_offset < -10) {
102	// above 10m only write full meters	102	// above 10m only write full meters
103	write_ndigit_number_s(23, top_line, (int16_t) (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset), 4, 0); // GPS	103	write_ndigit_number_s(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 1000 - altimeter_offset), 4, 0); // GPS
104	} else {	104	} else {
105	// up to 10m write meters.dm	105	// up to 10m write meters.dm
106	write_ndigit_number_s_10th(23, top_line, (int16_t) (naviData.CurrentPosition.Altitude / 100 - altimeter_offset * 10), 3, 0); // GPS	106	write_ndigit_number_s_10th(23, top_line, (int16_t)(naviData.CurrentPosition.Altitude / 100 - altimeter_offset * 10), 3, 0); // GPS
107	}	107	}
108	}	108	}
109	} else {	109	} else {
110	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	110	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
111	write_ndigit_number_s(23, top_line, naviData.Altimeter / 10 * 32 / 30, 4, 0); // BARO	111	write_ndigit_number_s(23, top_line, naviData.Altimeter / 10 * 32 / 30, 4, 0); // BARO
112	} else {	112	} else {
113	//note:lephisto:according to several sources it's /30	113	//note:lephisto:according to several sources it's /30
114	if (naviData.Altimeter > 300 \|\| naviData.Altimeter < -300) {	114	if (naviData.Altimeter > 300 \|\| naviData.Altimeter < -300) {
115	// above 10m only write full meters	115	// above 10m only write full meters
116	write_ndigit_number_s(23, top_line, naviData.Altimeter / 30, 4, 0); // BARO	116	write_ndigit_number_s(23, top_line, naviData.Altimeter / 30, 4, 0); // BARO
117	} else {	117	} else {
118	// up to 10m write meters.dm	118	// up to 10m write meters.dm
119	write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 3, 0); // BARO	119	write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 3, 0); // BARO
120	}	120	}
121	}	121	}
122	}	122	}
-		123
123		124
124		125	// seccond line
125	// seccond line	126	draw_compass(11, top_line + 1, naviData.CompassHeading);
126	draw_compass(11, top_line + 1, naviData.CompassHeading);	127
127		128	// TODO: verify correctness
128	// TODO: verify correctness	129	uint16_t heading_home = (naviData.HomePositionDeviation.Bearing + 360 - naviData.CompassHeading) % 360;
129	uint16_t heading_home = (naviData.HomePositionDeviation.Bearing + 360 - naviData.CompassHeading) % 360;	130	//write_char_xy(21, top_line + 1, arrowdir[heading_conv(heading_home)]);
130	//write_char_xy(21, top_line + 1, arrowdir[heading_conv(heading_home)]);	131	// finer resolution, 0xa0 is first character and we add the index 0 <= index < 16
131	// finer resolution, 0xa0 is first character and we add the index 0 <= index < 16	132	write_char_xy(21, top_line + 1, 0xa0 + heading_fine_conv(heading_home));
132	write_char_xy(21, top_line + 1, 0xa0 + heading_fine_conv(heading_home));	133
133		134	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
134	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	135	// feet
135	// feet	136	write_ndigit_number_u(23, top_line + 1, naviData.HomePositionDeviation.Distance / 10 * 32 / 10, 4, 0);
136	write_ndigit_number_u(24, top_line + 1, naviData.HomePositionDeviation.Distance / 10 * 32 / 10, 3, 0);	137	} else {
137	} else {	138	write_ndigit_number_u(23, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 4, 0);
138	write_ndigit_number_u(24, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 3, 0);	139	}
139	}	140
140		141	// center
141	// center	142	if (naviData.FCFlags & FLAG_MOTOR_RUN) { // should be engines running
142	if (naviData.FCFlags & FLAG_MOTOR_RUN) { // should be engines running	143	if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle
143	if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle	144	clear();
144	clear();	145	// remember current heigth for gps offset
145	// remember current heigth for gps offset	146	altimeter_offset = naviData.CurrentPosition.Altitude / 1000;
146	altimeter_offset = naviData.CurrentPosition.Altitude / 1000;	147	// set wasted counter to current offset
147	// set wasted counter to current offset	148	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
148	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	149	wasted_ampere_offset = ampere_wasted / 10;
149	wasted_ampere_offset = ampere_wasted / 10;	150	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
150	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {	151	wasted_ampere_offset = naviData.UsedCapacity;
151	wasted_ampere_offset = naviData.UsedCapacity;	152	}
152	}	153	// update flags to paint display again if needed
153	// update flags to paint display again if needed	154	COSD_FLAGS_RUNTIME &= ~COSD_ICONS_WRITTEN;
154	COSD_FLAGS_RUNTIME &= ~COSD_ICONS_WRITTEN;	155	}
155	}	156	if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // horizon
156	if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // horizon	157	uint8_t horizon_bottom = bottom_line - 1;
157	uint8_t horizon_bottom = bottom_line - 1;	158	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
158	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	159	horizon_bottom--;
159	horizon_bottom--;	160	}
160	}	161	if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {
161	if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {	162	draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
162	draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);	163	} else {
163	} else {	164	draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
164	draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);	165	}
165	}	166	}
166	}	167	// motors are on, assume we were/are flying
167	// motors are on, assume we were/are flying	168	COSD_FLAGS_RUNTIME \|= COSD_WASFLYING;
168	COSD_FLAGS_RUNTIME \|= COSD_WASFLYING;	169	} else {
-		170	if ((old_MKFlags & FLAG_MOTOR_RUN)) { // motors just stopped
-		171	clear(); // clear whole screen in case there is horizon stuff left
-		172	// update flags to paint display again if needed
-		173	COSD_FLAGS_RUNTIME &= ~COSD_ICONS_WRITTEN;
-		174	}
169	} else {	175	// stats
170	// stats	176	if ((COSD_FLAGS_RUNTIME & COSD_WASFLYING) && (COSD_FLAGS_MODES & COSD_FLAG_STATS)) {
171	if ((COSD_FLAGS_RUNTIME & COSD_WASFLYING) && (COSD_FLAGS_MODES & COSD_FLAG_STATS)) {	177	uint8_t line = 3;
172	uint8_t line = 3;	178	write_ascii_string_pgm(1, line, (const char *)(pgm_read_word(&(stats_item_pointers[0])))); // max Altitude
173	write_ascii_string_pgm(1, line, (const char *) (pgm_read_word(&(stats_item_pointers[0])))); // max Altitude	179	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[1])))); // max Speed
174	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[1])))); // max Speed	180	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[2])))); // max Distance
175	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[2])))); // max Distance	181
176		182	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {
177	if (COSD_FLAGS_CONFIG & COSD_FLAG_FEET) {	183	write_ndigit_number_s(16, line - 2, max_Altimeter * 32 / 10, 4, 0);
178	write_ndigit_number_s(16, line, max_Altimeter * 32 / 10, 4, 0);	184	write_char_xy(20, line - 2, 0x7E); // small feet ft
179	write_char_xy(20, line - 2, 0x7E); // small feet ft	185	write_ndigit_number_u(17, line - 1, (uint16_t)(((uint32_t)max_GroundSpeed * (uint32_t)279) / (uint32_t)12500), 3, 0);
180	write_ndigit_number_u(17, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 279) / (uint32_t) 12500), 3, 0);	186	write_char_xy(20, line - 1, 0x7D); // mp/h
181	write_char_xy(20, line - 1, 0x7D); // mp/h	187	write_ndigit_number_u(17, line - 0, max_Distance / 10 * 32 / 10, 3, 0);
182	write_ndigit_number_u(17, line, max_Distance / 10 * 32 / 10, 3, 0);	188	write_char_xy(20, line - 0, 0x7E); // small feet ft
183	write_char_xy(20, line - 0, 0x7E); // small feet ft	189	} else {
184	} else {	190	write_ndigit_number_s(16, line - 2, max_Altimeter, 4, 0);
185	write_ndigit_number_s(16, line, max_Altimeter, 4, 0);	191	write_char_xy(20, line - 2, 204); // small meters m
186	write_char_xy(20, line - 2, 204); // small meters m	192	write_ndigit_number_u(17, line - 1, (uint16_t)(((uint32_t)max_GroundSpeed * (uint32_t)9) / (uint32_t)250), 3, 0);
187	write_ndigit_number_u(17, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);	193	write_char_xy(20, line - 1, 203); // km/h
188	write_char_xy(20, line - 1, 203); // km/h	194	write_ndigit_number_u(17, line - 0, max_Distance / 10, 3, 0);
189	write_ndigit_number_u(17, line, max_Distance / 10, 3, 0);	195	write_char_xy(20, line - 0, 204); // small meters m
190	write_char_xy(20, line - 0, 204); // small meters m	196	}
191	}	197
192		198	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[3])))); // min voltage
193	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[3])))); // min voltage	199	write_ndigit_number_u_10th(16, line, min_UBat, 3, 0);
194	write_ndigit_number_u_10th(16, line, min_UBat, 3, 0);	200	write_char_xy(20, line, 0x9E); // small V
195	write_char_xy(20, line, 0x9E); // small V	201	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
196	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	202	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[7])))); // ampere
197	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[7])))); // ampere	203	write_ndigit_number_u_10th(16, line, max_ampere / 10, 3, 0);
198	write_ndigit_number_u_10th(16, line, max_ampere / 10, 3, 0);	204	write_char_xy(20, line, 0x9F); // small A
199	write_char_xy(20, line, 0x9F); // small A	205
200		206	// wasted mampere in this flight (will count up after landing)
201	// wasted mampere in this flight (will count up after landing)	207	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
202	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	208	write_ndigit_number_u(21, line, (ampere_wasted / 10) - wasted_ampere_offset, 5, 0);
203	write_ndigit_number_u(21, line, (ampere_wasted / 10) - wasted_ampere_offset, 5, 0);	209	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
204	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {	210
205		211	write_ndigit_number_u(21, line, naviData.UsedCapacity - wasted_ampere_offset, 5, 0);
206	write_ndigit_number_u(21, line, naviData.UsedCapacity - wasted_ampere_offset, 5, 0);	212	}
207	}	213
208		214	write_char_xy(26, line, 0xB5); // mah
209	write_char_xy(26, line, 0xB5); // mah	215	}
210	}	216	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[4])))); // max time
211	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[4])))); // max time	217	write_time(14, line, max_FlyingTime);
212	write_time(14, line, max_FlyingTime);	218	write_char_xy(20, line, 210); // fly clock
213	write_char_xy(20, line, 210); // fly clock	219	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[5])))); // longitude
214	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[5])))); // longitude	220	write_gps_pos(14, line, naviData.CurrentPosition.Longitude);
215	write_gps_pos(14, line, naviData.CurrentPosition.Longitude);	221	write_ascii_string_pgm(1, ++line, (const char *)(pgm_read_word(&(stats_item_pointers[6])))); // latitude
216	write_ascii_string_pgm(1, ++line, (const char *) (pgm_read_word(&(stats_item_pointers[6])))); // latitude	222	write_gps_pos(14, line, naviData.CurrentPosition.Latitude);
217	write_gps_pos(14, line, naviData.CurrentPosition.Latitude);	223	} else if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon
218	} else if (COSD_FLAGS_MODES & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon	224	uint8_t horizon_bottom = bottom_line - 1;
219	uint8_t horizon_bottom = bottom_line - 1;	225	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
220	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) \|\| (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	226	horizon_bottom--;
221	horizon_bottom--;	227	}
222	}	228	if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {
223	if (COSD_FLAGS_MODES & COSD_FLAG_AGGRHORIZON) {	229	draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
224	draw_agressiva_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);	230	} else {
225	} else {	231	draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);
226	draw_artificial_horizon(top_line + 2, horizon_bottom, naviData.AngleNick, naviData.AngleRoll);	232	}
227	}	233	}
228	}	234	}
229	}	235	if (COSD_FLAGS_MODES & COSD_FLAG_BIGVARIO) {
230	if (COSD_FLAGS_MODES & COSD_FLAG_BIGVARIO) {	236	draw_big_variometer(27, 8, naviData.Variometer);
231	draw_big_variometer(27, 8, naviData.Variometer);	237	}
232	}	238
233		239	// pre-bottom line
234	// pre-bottom line	240	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
235	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	241	//write_ndigit_number_s(3, bottom_line - 1, ampere, 4, 0);
236	//write_ndigit_number_s(3, bottom_line - 1, ampere, 4, 0);	242	write_ndigit_number_u_10th(3, bottom_line - 1, ampere / 10, 3, 0);
237	write_ndigit_number_u_10th(3, bottom_line - 1, ampere / 10, 3, 0);	243	write_ndigit_number_s(10, bottom_line - 1, ampere_wasted / 10, 4, 0);
238	write_ndigit_number_s(10, bottom_line - 1, ampere_wasted / 10, 4, 0);	244	if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {
239	if (COSD_FLAGS_MODES & COSD_FLAG_STROMVOLT) {	245	write_ndigit_number_u_10th(17, bottom_line - 1, s_volt, 3, 0);
240	write_ndigit_number_u_10th(17, bottom_line - 1, s_volt, 3, 0);	246	}
241	}	247	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
242	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {	248	write_ndigit_number_u_10th(3, bottom_line - 1, naviData.Current, 3, 0);
243	write_ndigit_number_u_10th(3, bottom_line - 1, naviData.Current, 3, 0);	249	write_ndigit_number_u(10, bottom_line - 1, naviData.UsedCapacity, 4, 0);
244	write_ndigit_number_u(10, bottom_line - 1, naviData.UsedCapacity, 4, 0);	250	}
245	}	251
246		252	//DEBUGwrite_ndigit_number_u(1, 5, COSD_FLAGS_MODES, 3, 0);
247	//DEBUGwrite_ndigit_number_u(1, 5, COSD_FLAGS_MODES, 3, 0);	253
248		254	// bottom line
249	// bottom line	255	draw_battery(2, bottom_line, min_voltage, naviData.UBat, max_voltage);
250	draw_battery(2, bottom_line, min_voltage, naviData.UBat, max_voltage);	256	write_ndigit_number_u_10th(3, bottom_line, naviData.UBat, 3, 0);
251	write_ndigit_number_u_10th(3, bottom_line, naviData.UBat, 3, 0);	257	if (naviData.UBat <= min_voltage && last_UBat > min_voltage) {
252	if (naviData.UBat <= min_voltage && last_UBat > min_voltage) {	258	for (uint8_t x = 2; x < 8; x++)
253	for (uint8_t x = 2; x < 8; x++)	259	write_char_att_xy(x, bottom_line, BLINK);
254	write_char_att_xy(x, bottom_line, BLINK);	260	} else if (naviData.UBat > min_voltage && last_UBat < min_voltage) {
255	} else if (naviData.UBat > min_voltage && last_UBat < min_voltage) {	261	for (uint8_t x = 2; x < 8; x++)
256	for (uint8_t x = 2; x < 8; x++)	262	write_char_att_xy(x, bottom_line, 0);
257	write_char_att_xy(x, bottom_line, 0);	263	}
258	}	264
259		265	write_time(8, bottom_line, uptime);
260	write_time(8, bottom_line, uptime);	266	write_time(15, bottom_line, naviData.FlyingTime);
261	write_time(15, bottom_line, naviData.FlyingTime);	267
262		268	write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 2, 0);
263	write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 2, 0);	269
264		270	if (naviData.NCFlags & NC_FLAG_MANUAL_CONTROL) {
265	if (naviData.NCFlags & NC_FLAG_MANUAL_CONTROL) {	271	write_char_xy(23, bottom_line, 0xB3); // rc transmitter
266	write_char_xy(23, bottom_line, 0xB3); // rc transmitter	272	} else {
267	} else {	273	write_char_xy(23, bottom_line, 0); // clear
268	write_char_xy(23, bottom_line, 0); // clear	274	}
269	}	275
270		276	if (naviData.NCFlags & NC_FLAG_CH) {
271	if (naviData.NCFlags & NC_FLAG_CH) {	277	write_char_xy(27, bottom_line, 231); // gps ch
272	write_char_xy(27, bottom_line, 231); // gps ch	278	} else if (naviData.NCFlags & NC_FLAG_PH) {
273	} else if (naviData.NCFlags & NC_FLAG_PH) {	279	write_char_xy(27, bottom_line, 230); // gps ph
274	write_char_xy(27, bottom_line, 230); // gps ph	280	} else { // (naviData.NCFlags & NC_FLAG_FREE)
275	} else { // (naviData.NCFlags & NC_FLAG_FREE)	281	write_char_xy(27, bottom_line, 201); // sat2 (free)
276	write_char_xy(27, bottom_line, 201); // sat2 (free)	282	}
277	}	283	}
278	}	284
279		285	//write_number_s(8, 5, RxDataLen);
280	//write_number_s(8, 5, RxDataLen);	286	//write_number_s(16, 5, setsReceived++);
281	//write_number_s(16, 5, setsReceived++);	287
282		288	// remember statistics (only when engines running)
283	// remember statistics (only when engines running)	289	if (naviData.FCFlags & FLAG_MOTOR_RUN) {
284	if (naviData.FCFlags & FLAG_MOTOR_RUN) {	290	if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {
285	if (COSD_FLAGS_CONFIG & COSD_FLAG_GPSHEIGHT) {	291	if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > max_Altimeter) max_Altimeter = naviData.CurrentPosition.Altitude / 1000;
286	if (naviData.CurrentPosition.Altitude / 1000 - altimeter_offset > max_Altimeter) max_Altimeter = naviData.CurrentPosition.Altitude / 1000;	292	} else {
287	} else {	293	if (naviData.Altimeter / 30 > max_Altimeter) max_Altimeter = naviData.Altimeter / 30;
288	if (naviData.Altimeter / 30 > max_Altimeter) max_Altimeter = naviData.Altimeter / 30;	294	}
289	}	295	if (naviData.GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData.GroundSpeed;
290	if (naviData.GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData.GroundSpeed;	296	if (naviData.HomePositionDeviation.Distance > max_Distance) {
291	if (naviData.HomePositionDeviation.Distance > max_Distance) {	297	max_Distance = naviData.HomePositionDeviation.Distance;
292	max_Distance = naviData.HomePositionDeviation.Distance;	298	}
293	}	299	if (naviData.UBat < min_UBat) min_UBat = naviData.UBat;
294	if (naviData.UBat < min_UBat) min_UBat = naviData.UBat;	300	if (naviData.FlyingTime > max_FlyingTime) max_FlyingTime = naviData.FlyingTime;
295	if (naviData.FlyingTime > max_FlyingTime) max_FlyingTime = naviData.FlyingTime;	301	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {
296	if ((COSD_FLAGS_RUNTIME & COSD_FLAG_STROMREC) && !(COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT)) {	302	if (ampere > max_ampere) max_ampere = ampere;
297	if (ampere > max_ampere) max_ampere = ampere;	303	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {
298	} else if (COSD_FLAGS_MODES & COSD_FLAG_FCCURRENT) {	304	if (naviData.Current * 10 > max_ampere) max_ampere = naviData.Current * 10;
299	if (naviData.Current * 10 > max_ampere) max_ampere = naviData.Current * 10;	305	}
300	}	306	}
301	}	307
302		308	// remember last values
303	// remember last values	309	last_RC_Quality = rc_signal;
304	last_RC_Quality = rc_signal;	310	last_UBat = naviData.UBat;
305	last_UBat = naviData.UBat;	311	old_MKFlags = naviData.FCFlags;
306	old_MKFlags = naviData.FCFlags;	312	seconds_since_last_data = 0;
307	seconds_since_last_data = 0;	313
308		314	return 0;
309	return 0;	315	}
310	}	316
311		317	#endif
312	#endif	318
313		-

Subversion Repositories Projects

(root)/C-OSD/trunk/osd_ncmode_default.c - Rev 758 → 761