Subversion Repositories Projects

Rev

Rev 386 | Rev 388 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 386 Rev 387
1 
/****************************************************************************
 1 
/****************************************************************************
2 
 *   Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje                    *
 2 
 *   Copyright (C) 2009 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 
 *   Credits to:                                                            *
 21 
 *   Credits to:                                                            *
22 
 *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project       *
 22 
 *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project       *
23 
 *   Gregor "killagreg" Stobrawa for making the MK code readable            *
 23 
 *   Gregor "killagreg" Stobrawa for making the MK code readable            *
24 
 *   Klaus "akku" Buettner for the hardware                                 *
 24 
 *   Klaus "akku" Buettner for the hardware                                 *
25 
 *   Manuel "KeyOz" Schrape for explaining the MK protocol to me            *
 25 
 *   Manuel "KeyOz" Schrape for explaining the MK protocol to me            *
26 
 ****************************************************************************/
 26 
 ****************************************************************************/
27 
 
 27 
 
28 
#include <avr/io.h>
 28 
#include <avr/io.h>
29 
#include <avr/interrupt.h>
 29 
#include <avr/interrupt.h>
30 
#include <util/delay.h>
 30 
#include <util/delay.h>
31 
#include <avr/pgmspace.h>
31 
#include <avr/pgmspace.h>
32 
#include "main.h"
 32 
#include "main.h"
33 
#include "max7456_software_spi.h"
 33 
#include "max7456_software_spi.h"
34 
#include "usart1.h"
 34 
#include "usart1.h"
35 
 
 35 
 
36 
/* TODO:
 36 
/* TODO:
37 
 * - verifiy correctness of values
 37 
 * - verifiy correctness of values
38 
 * - clean up code :)
 38 
 * - clean up code :)
39 
 */
 39 
 */
40 
 
 40 
 
41 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 41 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
42 
// data structs not needed for character flashin
 42 
// data structs not needed for character flashin
43 
#include "mk-data-structs.h"
 43 
#include "mk-data-structs.h"
44 
 
 44 
 
45 
/* ##########################################################################
 45 
/* ##########################################################################
46 
 * global definitions and global vars
 46 
 * global definitions and global vars
47 
 * ##########################################################################*/
 47 
 * ##########################################################################*/
48 
 
 48 
 
49 
volatile uint16_t setsReceived = 0;
 49 
volatile uint16_t setsReceived = 0;
50 
 
 50 
 
51 
volatile NaviData_t naviData;
 51 
volatile NaviData_t naviData;
52 
volatile DebugOut_t debugData;
 52 
volatile DebugOut_t debugData;
53 
 
 53 
 
54 
// cache old vars for blinking attribute, checkup is faster than full
 54 
// cache old vars for blinking attribute, checkup is faster than full
55 
// attribute write each time
 55 
// attribute write each time
56 
volatile uint8_t last_UBat = 255;
 56 
volatile uint8_t last_UBat = 255;
57 
volatile uint8_t last_RC_Quality = 255;
 57 
volatile uint8_t last_RC_Quality = 255;
58 
 
 58 
 
59 
// 16bit should be enough, normal LiPos don't last that long
 59 
// 16bit should be enough, normal LiPos don't last that long
60 
volatile uint16_t uptime = 0;
 60 
volatile uint16_t uptime = 0;
61 
volatile uint16_t timer = 0;
 61 
volatile uint16_t timer = 0;
62 
 
 62 
 
63 
// remember last time data was received
 63 
// remember last time data was received
64 
volatile uint8_t seconds_since_last_data = 0;
 64 
volatile uint8_t seconds_since_last_data = 0;
65 
 
 65 
 
66 
// store stats description in progmem to save space
 66 
// store stats description in progmem to save space
67 
char stats_item_0[] PROGMEM = "max Altitude:";
 67 
char stats_item_0[] PROGMEM = "max Altitude:";
68 
char stats_item_1[] PROGMEM = "max Speed   :";
 68 
char stats_item_1[] PROGMEM = "max Speed   :";
69 
char stats_item_2[] PROGMEM = "max Distance:";
 69 
char stats_item_2[] PROGMEM = "max Distance:";
70 
char stats_item_3[] PROGMEM = "min voltage :";
 70 
char stats_item_3[] PROGMEM = "min voltage :";
71 
char stats_item_4[] PROGMEM = "max time    :";
 71 
char stats_item_4[] PROGMEM = "max time    :";
72 
char* stats_item_pointers[] PROGMEM = {stats_item_0, stats_item_1, stats_item_2,
 72 
char* stats_item_pointers[] PROGMEM = {stats_item_0, stats_item_1, stats_item_2,
73 
                                        stats_item_3, stats_item_4};
 73 
                                        stats_item_3, stats_item_4};
74 
 
 74 
 
75 
// store more fixed strings in progmen
 75 
// store more fixed strings in progmen
76 
char ON[] PROGMEM = "ON ";
 76 
char ON[] PROGMEM = "ON ";
77 
char OFF[] PROGMEM = "OFF";
 77 
char OFF[] PROGMEM = "OFF";
78 
 
 78 
 
79 
// big vario arrays
79 
// big vario arrays
80 
char vario_00[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xff};
 80 
char vario_00[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xff};
81 
char vario_01[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc0};
 81 
char vario_01[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc0};
82 
char vario_02[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc1};
 82 
char vario_02[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc1};
83 
char vario_03[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0x00};
 83 
char vario_03[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0x00};
84 
char vario_04[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc0, 0x00};
 84 
char vario_04[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc0, 0x00};
85 
char vario_05[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc1, 0x00};
 85 
char vario_05[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc1, 0x00};
86 
char vario_06[5] PROGMEM = {0x00, 0x00, 0xc2, 0x00, 0x00};
 86 
char vario_06[5] PROGMEM = {0x00, 0x00, 0xc2, 0x00, 0x00};
87 
char vario_07[5] PROGMEM = {0x00, 0x00, 0xbb, 0x00, 0x00};
 87 
char vario_07[5] PROGMEM = {0x00, 0x00, 0xbb, 0x00, 0x00};
88 
char vario_08[5] PROGMEM = {0x00, 0x00, 0xc3, 0x00, 0x00};
 88 
char vario_08[5] PROGMEM = {0x00, 0x00, 0xc3, 0x00, 0x00};
89 
char vario_09[5] PROGMEM = {0x00, 0xc4, 0xc3, 0x00, 0x00};
 89 
char vario_09[5] PROGMEM = {0x00, 0xc4, 0xc3, 0x00, 0x00};
90 
char vario_10[5] PROGMEM = {0x00, 0xc5, 0xc3, 0x00, 0x00};
 90 
char vario_10[5] PROGMEM = {0x00, 0xc5, 0xc3, 0x00, 0x00};
91 
char vario_11[5] PROGMEM = {0x00, 0xff, 0xc3, 0x00, 0x00};
 91 
char vario_11[5] PROGMEM = {0x00, 0xff, 0xc3, 0x00, 0x00};
92 
char vario_12[5] PROGMEM = {0xc4, 0xff, 0xc3, 0x00, 0x00};
 92 
char vario_12[5] PROGMEM = {0xc4, 0xff, 0xc3, 0x00, 0x00};
93 
char vario_13[5] PROGMEM = {0xc5, 0xff, 0xc3, 0x00, 0x00};
 93 
char vario_13[5] PROGMEM = {0xc5, 0xff, 0xc3, 0x00, 0x00};
94 
char vario_14[5] PROGMEM = {0xff, 0xff, 0xc3, 0x00, 0x00};
 94 
char vario_14[5] PROGMEM = {0xff, 0xff, 0xc3, 0x00, 0x00};
95 
char* vario_pnt[15] PROGMEM = {vario_00, vario_01, vario_02, vario_03, vario_04,
 95 
char* vario_pnt[15] PROGMEM = {vario_00, vario_01, vario_02, vario_03, vario_04,
96 
                                vario_05, vario_06, vario_07, vario_08,
 96 
                                vario_05, vario_06, vario_07, vario_08,
97 
                                vario_09, vario_10, vario_11, vario_12,
 97 
                                vario_09, vario_10, vario_11, vario_12,
98 
                                vario_13, vario_14};
 98 
                                vario_13, vario_14};
99 
 
 99 
 
100 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
 100 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
101 
 
 101 
 
102 
// general PAL|NTSC distingiusch stuff
 102 
// general PAL|NTSC distingiusch stuff
103 
uint8_t top_line = 1;
 103 
uint8_t top_line = 1;
104 
uint8_t bottom_line = 14;
 104 
uint8_t bottom_line = 14;
105 
 
 105 
 
106 
// Flags
 106 
// Flags
107 
uint8_t COSD_FLAGS = 0;
 107 
uint8_t COSD_FLAGS = 0;
108 
 
 108 
 
109 
/* ##########################################################################
 109 
/* ##########################################################################
110 
 * debounce buttons
 110 
 * debounce buttons
111 
 * ##########################################################################*/
 111 
 * ##########################################################################*/
112 
int s1_pressed() {
 112 
int s1_pressed() {
113 
        if (S1_PRESSED) {
 113 
        if (S1_PRESSED) {
114 
                _delay_ms(25);
 114 
                _delay_ms(25);
115 
                if (S1_PRESSED) return 1;
 115 
                if (S1_PRESSED) return 1;
116 
        }
 116 
        }
117 
        return 0;
 117 
        return 0;
118 
}
 118 
}
119 
 
 119 
 
120 
int s2_pressed() {
 120 
int s2_pressed() {
121 
        if (S2_PRESSED) {
 121 
        if (S2_PRESSED) {
122 
                _delay_ms(25);
 122 
                _delay_ms(25);
123 
                if (S2_PRESSED) return 1;
 123 
                if (S2_PRESSED) return 1;
124 
        }
 124 
        }
125 
        return 0;
 125 
        return 0;
126 
}
 126 
}
127 
 
 127 
 
128 
 
 128 
 
129 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 129 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
130 
 
 130 
 
131 
/**
 131 
/**
132 
 * serial support
 132 
 * serial support
133 
 */
 133 
 */
134 
//#include "usart1.c"
 134 
//#include "usart1.c"
135 
 
 135 
 
136 
 
 136 
 
137 
/* ##########################################################################
 137 
/* ##########################################################################
138 
 * timer stuff
 138 
 * timer stuff
139 
 * ##########################################################################*/
 139 
 * ##########################################################################*/
140 
 
 140 
 
141 
/**
 141 
/**
142 
 * timer kicks in every 1000uS ^= 1ms
 142 
 * timer kicks in every 1000uS ^= 1ms
143 
 */
 143 
 */
144 
ISR(TIMER0_OVF_vect) {
 144 
ISR(TIMER0_OVF_vect) {
145 
    OCR0 = 15; // preload
 145 
    OCR0 = 15; // preload
146 
    if (!timer--) {
 146 
    if (!timer--) {
147 
        uptime++;
 147 
        uptime++;
148 
        timer = 999;
 148 
        timer = 999;
149 
                seconds_since_last_data++;
 149 
                seconds_since_last_data++;
150 
    }
 150 
    }
151 
}
 151 
}
152 
 
 152 
 
153 
/* ##########################################################################
 153 
/* ##########################################################################
154 
 * compass stuff
 154 
 * compass stuff
155 
 * ##########################################################################*/
 155 
 * ##########################################################################*/
156 
 
 156 
 
157 
/**
 157 
/**
158 
 * convert the <heading> gotton from NC into an index
 158 
 * convert the <heading> gotton from NC into an index
159 
 */
 159 
 */
160 
uint8_t heading_conv(uint16_t heading) {
 160 
uint8_t heading_conv(uint16_t heading) {
161 
    if (heading > 23 && heading < 68) {
 161 
    if (heading > 23 && heading < 68) {
162 
        //direction = "NE";
 162 
        //direction = "NE";
163 
        return 0;
 163 
        return 0;
164 
    } else if (heading > 67 && heading < 113) {
 164 
    } else if (heading > 67 && heading < 113) {
165 
        //direction = "E ";
 165 
        //direction = "E ";
166 
        return 1;
 166 
        return 1;
167 
    } else if (heading > 112 && heading < 158) {
 167 
    } else if (heading > 112 && heading < 158) {
168 
        //direction = "SE";
 168 
        //direction = "SE";
169 
        return 2;
 169 
        return 2;
170 
    } else if (heading > 157 && heading < 203) {
 170 
    } else if (heading > 157 && heading < 203) {
171 
        //direction = "S ";
 171 
        //direction = "S ";
172 
        return 3;
 172 
        return 3;
173 
    } else if (heading > 202 && heading < 248) {
 173 
    } else if (heading > 202 && heading < 248) {
174 
        //direction = "SW";
 174 
        //direction = "SW";
175 
        return 4;
 175 
        return 4;
176 
    } else if (heading > 247 && heading < 293) {
 176 
    } else if (heading > 247 && heading < 293) {
177 
        //direction = "W ";
 177 
        //direction = "W ";
178 
        return 5;
 178 
        return 5;
179 
    } else if (heading > 292 && heading < 338) {
 179 
    } else if (heading > 292 && heading < 338) {
180 
        //direction = "NW";
 180 
        //direction = "NW";
181 
        return 6;
 181 
        return 6;
182 
    }
 182 
    }
183 
    //direction = "N ";
 183 
    //direction = "N ";
184 
    return 7;
 184 
    return 7;
185 
}
 185 
}
186 
 
 186 
 
187 
/**
 187 
/**
188 
 * convert the <heading> gotton from NC into a more
 188 
 * convert the <heading> gotton from NC into a more
189 
 * precise index
 189 
 * precise index
190 
 */
 190 
 */
191 
uint8_t heading_fine_conv(uint16_t heading) {
 191 
uint8_t heading_fine_conv(uint16_t heading) {
192 
        heading = ((heading * 10) + 113) % 3600;
 192 
        heading = ((heading * 10) + 113) % 3600;
193 
        return (heading / 225);
 193 
        return (heading / 225);
194 
}
 194 
}
195 
 
 195 
 
196 
/**
 196 
/**
197 
 * draw a compass rose at <x>/<y> for <heading>
 197 
 * draw a compass rose at <x>/<y> for <heading>
198 
 */
 198 
 */
199 
void draw_compass(uint8_t x, uint8_t y, uint16_t heading) {
 199 
void draw_compass(uint8_t x, uint8_t y, uint16_t heading) {
200 
    //char* rose = "---N---O---S---W---N---O---S---W---N---O---S---W";
 200 
    //char* rose = "---N---O---S---W---N---O---S---W---N---O---S---W";
201 
    char rose[48] = {216, 215, 216, 211, 216, 215, 216, 213, 216, 215, 216, 212,
 201 
    char rose[48] = {216, 215, 216, 211, 216, 215, 216, 213, 216, 215, 216, 212,
202 
                    216, 215, 216, 214, 216, 215, 216, 211, 216, 215, 216, 213,
 202 
                    216, 215, 216, 214, 216, 215, 216, 211, 216, 215, 216, 213,
203 
                    216, 215, 216, 212, 216, 215, 216, 214, 216, 215, 216, 211,
 203 
                    216, 215, 216, 212, 216, 215, 216, 214, 216, 215, 216, 211,
204 
                    216, 215, 216, 213, 216, 215, 216, 212, 216, 215, 216, 214};
 204 
                    216, 215, 216, 213, 216, 215, 216, 212, 216, 215, 216, 214};
205 
        // the center is char 19 (north), we add the current heading in 8th
 205 
        // the center is char 19 (north), we add the current heading in 8th
206 
        // which would be 22.5 degrees, but float would bloat up the code
 206 
        // which would be 22.5 degrees, but float would bloat up the code
207 
        // and *10 / 225 would take ages... so we take the uncorrect way
 207 
        // and *10 / 225 would take ages... so we take the uncorrect way
208 
    uint8_t front = 19 + (heading / 22);
 208 
    uint8_t front = 19 + (heading / 22);
209 
    for (uint8_t i = 0; i < 9; i++) {
 209 
    for (uint8_t i = 0; i < 9; i++) {
210 
                write_char_xy(x++, y, rose[front - 4 + i]);
 210 
                write_char_xy(x++, y, rose[front - 4 + i]);
211 
    }
 211 
    }
212 
}
 212 
}
213 
 
 213 
 
214 
/* ##########################################################################
 214 
/* ##########################################################################
215 
 * battery index
 215 
 * battery index
216 
 * ##########################################################################*/
 216 
 * ##########################################################################*/
217 
/**
 217 
/**
218 
 * draw a battery symbol at <x>/<y> according to <voltage>
 218 
 * draw a battery symbol at <x>/<y> according to <voltage>
219 
 */
 219 
 */
220 
void draw_battery(uint8_t x, uint8_t y, uint16_t voltage) {
 220 
void draw_battery(uint8_t x, uint8_t y, uint16_t voltage) {
221 
        uint8_t percent = (100* (voltage - UBAT_WRN) / (UBAT_MAX - UBAT_WRN));
 221 
        uint8_t percent = (100* (voltage - UBAT_WRN) / (UBAT_MAX - UBAT_WRN));
222 
        if (percent > 100) percent = 100;
 222 
        if (percent > 100) percent = 100;
223 
        if (voltage < UBAT_WRN) percent = 0;
 223 
        if (voltage < UBAT_WRN) percent = 0;
224 
        write_char_xy(x, y, 0x9d - (percent * 13 / 100));
 224 
        write_char_xy(x, y, 0x9d - (percent * 13 / 100));
225 
        //write_ndigit_number_u(x, y-1, percent * 13 / 100, 100, 0);
 225 
        //write_ndigit_number_u(x, y-1, percent * 13 / 100, 100, 0);
226 
}
 226 
}
227 
 
 227 
 
228 
/* ##########################################################################
 228 
/* ##########################################################################
229 
 * variometer
 229 
 * variometer
230 
 * ##########################################################################*/
 230 
 * ##########################################################################*/
231 
/**
 231 
/**
232 
 * draw variometer arrows at <x>/<y> according to <variometer>
 232 
 * draw variometer arrows at <x>/<y> according to <variometer>
233 
 */
 233 
 */
234 
void draw_variometer(uint8_t x, uint8_t y, int16_t variometer) {
 234 
void draw_variometer(uint8_t x, uint8_t y, int16_t variometer) {
235 
        if (variometer == 0) {
 235 
        if (variometer == 0) {
236 
                write_char_xy(x, y, 0xbb); // plain line
 236 
                write_char_xy(x, y, 0xbb); // plain line
237 
        } else if (variometer > 0) { // gain height
 237 
        } else if (variometer > 0) { // gain height
238 
                switch (variometer / 5){
 238 
                switch (variometer / 5){
239 
                        case 0:
 239 
                        case 0:
240 
                                //write_char_xy(x, y, 0xba); // smallest arrow up
 240 
                                //write_char_xy(x, y, 0xba); // smallest arrow up
241 
                                write_char_xy(x, y, 0x70); // one arrow up
 241 
                                write_char_xy(x, y, 0x70); // one arrow up
242 
                                break;
 242 
                                break;
243 
                        case 1:
 243 
                        case 1:
244 
                                //write_char_xy(x, y, 0xb9); // small arrow up
 244 
                                //write_char_xy(x, y, 0xb9); // small arrow up
245 
                                write_char_xy(x, y, 0x71); // two arrows up
 245 
                                write_char_xy(x, y, 0x71); // two arrows up
246 
                                break;
 246 
                                break;
247 
                        case 2:
 247 
                        case 2:
248 
                                //write_char_xy(x, y, 0xb8); // large arrow up
 248 
                                //write_char_xy(x, y, 0xb8); // large arrow up
249 
                                write_char_xy(x, y, 0x72); // three arrows up
 249 
                                write_char_xy(x, y, 0x72); // three arrows up
250 
                                break;
 250 
                                break;
251 
                        default:
 251 
                        default:
252 
                                //write_char_xy(x, y, 0xb7); // largest arrow up
 252 
                                //write_char_xy(x, y, 0xb7); // largest arrow up
253 
                                write_char_xy(x, y, 0x73); // three black arrows up
 253 
                                write_char_xy(x, y, 0x73); // three black arrows up
254 
                }
 254 
                }
255 
        } else { // sink
 255 
        } else { // sink
256 
                switch (variometer / -5){
 256 
                switch (variometer / -5){
257 
                        case 0:
 257 
                        case 0:
258 
                                //write_char_xy(x, y, 0xbc); // smallest arrow down
 258 
                                //write_char_xy(x, y, 0xbc); // smallest arrow down
259 
                                write_char_xy(x, y, 0x77); // one arrow down
 259 
                                write_char_xy(x, y, 0x77); // one arrow down
260 
                                break;
 260 
                                break;
261 
                        case 1:
 261 
                        case 1:
262 
                                //write_char_xy(x, y, 0xbd); // small arrow down
 262 
                                //write_char_xy(x, y, 0xbd); // small arrow down
263 
                                write_char_xy(x, y, 0x76); // two arrows down
 263 
                                write_char_xy(x, y, 0x76); // two arrows down
264 
                                break;
 264 
                                break;
265 
                        case 2:
 265 
                        case 2:
266 
                                //write_char_xy(x, y, 0xbe); // large arrow down
 266 
                                //write_char_xy(x, y, 0xbe); // large arrow down
267 
                                write_char_xy(x, y, 0x75); // three arrows down
 267 
                                write_char_xy(x, y, 0x75); // three arrows down
268 
                                break;
 268 
                                break;
269 
                        default:
 269 
                        default:
270 
                                //write_char_xy(x, y, 0xbf); // largest arrow down
 270 
                                //write_char_xy(x, y, 0xbf); // largest arrow down
271 
                                write_char_xy(x, y, 0x74); // three black arrows down
 271 
                                write_char_xy(x, y, 0x74); // three black arrows down
272 
                }
 272 
                }
273 
        }
 273 
        }
274 
}
 274 
}
275 
 
 275 
 
276 
/**
 276 
/**
277 
 * draw a bigger vario with middle at <x>/<y> acording to <variometer>
 277 
 * draw a bigger vario with middle at <x>/<y> acording to <variometer>
278 
 */
 278 
 */
279 
void draw_big_variometer(uint8_t x, uint8_t y, int16_t variometer) {   
 279 
void draw_big_variometer(uint8_t x, uint8_t y, int16_t variometer) {   
280 
        int16_t index = 7 + variometer;
 280 
        int16_t index = 7 + variometer;
281 
        if (index > 14) index = 14;
 281 
        if (index > 14) index = 14;
282 
        else if (index < 0) index = 0;
 282 
        else if (index < 0) index = 0;
283 
       
 283 
       
284 
        // TODO: why does write_string_pgm_down(x, y-2, vario_pnt[index], 5);
 284 
        // TODO: why does write_string_pgm_down(x, y-2, vario_pnt[index], 5);
285 
        // not work??? WTF?!
 285 
        // not work??? WTF?!
286 
        switch (index) {
 286 
        switch (index) {
287 
                case 0: write_string_pgm_down(x, y-2, vario_pnt[0], 5);
 287 
                case 0: write_string_pgm_down(x, y-2, vario_pnt[0], 5);
288 
                        break;
 288 
                        break;
289 
                case 1: write_string_pgm_down(x, y-2, vario_pnt[1], 5);
 289 
                case 1: write_string_pgm_down(x, y-2, vario_pnt[1], 5);
290 
                        break;
 290 
                        break;
291 
                case 2: write_string_pgm_down(x, y-2, vario_pnt[2], 5);
 291 
                case 2: write_string_pgm_down(x, y-2, vario_pnt[2], 5);
292 
                        break;
 292 
                        break;
293 
                case 3: write_string_pgm_down(x, y-2, vario_pnt[3], 5);
 293 
                case 3: write_string_pgm_down(x, y-2, vario_pnt[3], 5);
294 
                        break;
 294 
                        break;
295 
                case 4: write_string_pgm_down(x, y-2, vario_pnt[4], 5);
 295 
                case 4: write_string_pgm_down(x, y-2, vario_pnt[4], 5);
296 
                        break;
 296 
                        break;
297 
                case 5: write_string_pgm_down(x, y-2, vario_pnt[5], 5);
 297 
                case 5: write_string_pgm_down(x, y-2, vario_pnt[5], 5);
298 
                        break;
 298 
                        break;
299 
                case 6: write_string_pgm_down(x, y-2, vario_pnt[6], 5);
 299 
                case 6: write_string_pgm_down(x, y-2, vario_pnt[6], 5);
300 
                        break;
 300 
                        break;
301 
                case 7: write_string_pgm_down(x, y-2, vario_pnt[7], 5);
 301 
                case 7: write_string_pgm_down(x, y-2, vario_pnt[7], 5);
302 
                        break;
 302 
                        break;
303 
                case 8: write_string_pgm_down(x, y-2, vario_pnt[8], 5);
 303 
                case 8: write_string_pgm_down(x, y-2, vario_pnt[8], 5);
304 
                        break;
 304 
                        break;
305 
                case 9: write_string_pgm_down(x, y-2, vario_pnt[9], 5);
 305 
                case 9: write_string_pgm_down(x, y-2, vario_pnt[9], 5);
306 
                        break;
 306 
                        break;
307 
                case 10: write_string_pgm_down(x, y-2, vario_pnt[10], 5);
 307 
                case 10: write_string_pgm_down(x, y-2, vario_pnt[10], 5);
308 
                        break;
 308 
                        break;
309 
                case 11: write_string_pgm_down(x, y-2, vario_pnt[11], 5);
 309 
                case 11: write_string_pgm_down(x, y-2, vario_pnt[11], 5);
310 
                        break;
 310 
                        break;
311 
                case 12: write_string_pgm_down(x, y-2, vario_pnt[12], 5);
 311 
                case 12: write_string_pgm_down(x, y-2, vario_pnt[12], 5);
312 
                        break;
 312 
                        break;
313 
                case 13: write_string_pgm_down(x, y-2, vario_pnt[13], 5);
 313 
                case 13: write_string_pgm_down(x, y-2, vario_pnt[13], 5);
314 
                        break;
 314 
                        break;
315 
                default: write_string_pgm_down(x, y-2, vario_pnt[14], 5);
 315 
                default: write_string_pgm_down(x, y-2, vario_pnt[14], 5);
316 
        }              
 316 
        }              
317 
}
 317 
}
318 
 
 318 
 
319 
/* ##########################################################################
 319 
/* ##########################################################################
320 
 * artificial horizon
 320 
 * artificial horizon
321 
 * ##########################################################################*/
 321 
 * ##########################################################################*/
322 
// remember last time displayed values
 322 
// remember last time displayed values
323 
int8_t old_af_x = -1, old_af_y = -1;
 323 
int8_t old_af_x = -1, old_af_y = -1;
324 
 
 324 
 
325 
/**
 325 
/**
326 
 * draw roll und nick indicators (could be enhanced to full artificial horizon)
 326 
 * draw roll und nick indicators (could be enhanced to full artificial horizon)
327 
 * from line <firstline> to <listlines> for given <nick> and <roll> values
 327 
 * from line <firstline> to <listlines> for given <nick> and <roll> values
328 
 */
 328 
 */
329 
void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {
 329 
void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {
330 
        char noodle[5] = {225, 225, 226, 227, 227};
 330 
        char noodle[5] = {225, 225, 226, 227, 227};
331 
        uint8_t center_x = 15;
 331 
        uint8_t center_x = 15;
332 
        uint8_t center_y = lastline - firstline;
 332 
        uint8_t center_y = lastline - firstline;
333 
        center_y = 7;
 333 
        center_y = 7;
334 
        write_char_xy(center_x,center_y,228);
 334 
        write_char_xy(center_x,center_y,228);
335 
        uint8_t cpos, nicky, rollx;
 335 
        uint8_t cpos, nicky, rollx;
336 
       
 336 
       
337 
        // which line
 337 
        // which line
338 
        int8_t ypos =  nick / 20;
 338 
        int8_t ypos =  nick / 20;
339 
        // which character from the array?
 339 
        // which character from the array?
340 
        if (nick < 0) {
 340 
        if (nick < 0) {
341 
                cpos = -1*((nick - (ypos * 20))/4);
 341 
                cpos = -1*((nick - (ypos * 20))/4);
342 
                ypos--;
 342 
                ypos--;
343 
        } else cpos = 4-((nick - (ypos * 20))/4);
 343 
        } else cpos = 4-((nick - (ypos * 20))/4);
344 
        if (cpos > 4) cpos = 4;
 344 
        if (cpos > 4) cpos = 4;
345 
 
 345 
 
346 
        nicky = center_y - ypos;
 346 
        nicky = center_y - ypos;
347 
        if (nicky > lastline) nicky = lastline;
 347 
        if (nicky > lastline) nicky = lastline;
348 
        else if (nicky < firstline) nicky = firstline;
 348 
        else if (nicky < firstline) nicky = firstline;
349 
 
 349 
 
350 
        // ensure roll-borders
 350 
        // ensure roll-borders
351 
        rollx = (roll / 8)+15;
 351 
        rollx = (roll / 8)+15;
352 
        if (rollx < 2) rollx = 2;
 352 
        if (rollx < 2) rollx = 2;
353 
        else if (rollx > 28) rollx = 28;
 353 
        else if (rollx > 28) rollx = 28;
354 
 
 354 
 
355 
 
 355 
 
356 
        // clear roll
 356 
        // clear roll
357 
        if (old_af_x != rollx && old_af_x >= 0) {
 357 
        if (old_af_x != rollx && old_af_x >= 0) {
358 
                write_char_xy(old_af_x,13,0);
 358 
                write_char_xy(old_af_x,13,0);
359 
        }
 359 
        }
360 
 
 360 
 
361 
        // clear nick
 361 
        // clear nick
362 
        if (old_af_y != nicky && old_af_y >= 0) {
 362 
        if (old_af_y != nicky && old_af_y >= 0) {
363 
                write_char_xy(center_x-1,old_af_y,0);
 363 
                write_char_xy(center_x-1,old_af_y,0);
364 
                write_char_xy(center_x+1,old_af_y,0);
 364 
                write_char_xy(center_x+1,old_af_y,0);
365 
        }
 365 
        }
366 
 
 366 
 
367 
 
 367 
 
368 
        // draw nick
 368 
        // draw nick
369 
        write_char_xy(center_x-1,nicky,noodle[cpos]);
 369 
        write_char_xy(center_x-1,nicky,noodle[cpos]);
370 
        write_char_xy(center_x+1,nicky,noodle[cpos]);
 370 
        write_char_xy(center_x+1,nicky,noodle[cpos]);
371 
 
 371 
 
372 
        // draw roll
 372 
        // draw roll
373 
        write_char_xy(rollx,lastline,229);
 373 
        write_char_xy(rollx,lastline,229);
374 
 
 374 
 
375 
        // update old vars
 375 
        // update old vars
376 
        old_af_x = rollx;
 376 
        old_af_x = rollx;
377 
        old_af_y = nicky;
 377 
        old_af_y = nicky;
378 
 
 378 
 
379 
        // debug numbers
 379 
        // debug numbers
380 
        //write_3digit_number_u(20,6,cpos);
 380 
        //write_3digit_number_u(20,6,cpos);
381 
        //write_number_s(20,7,ypos);   
381 
        //write_number_s(20,7,ypos);   
382 
        //write_number_s(0,7,nick);            
382 
        //write_number_s(0,7,nick);            
383 
        //write_number_s(18,11,roll);  
383 
        //write_number_s(18,11,roll);  
384 
}
 384 
}
385 
 
 385 
 
386 
/* ##########################################################################
 386 
/* ##########################################################################
387 
 * A simple config menu for the flags
 387 
 * A simple config menu for the flags
388 
 * ##########################################################################*/
 388 
 * ##########################################################################*/
389 
 
 389 
 
390 
/**
 390 
/**
391 
 * helper function for menu updating
 391 
 * helper function for menu updating
392 
 */
 392 
 */
393 
void config_menu_drawings(uint8_t chosen) {
 393 
void config_menu_drawings(uint8_t chosen) {
394 
    // clear prevoius _cursor_
 394 
    // clear prevoius _cursor_
395 
    write_ascii_string(3, (chosen + 5) % 8, " ");
 395 
    write_ascii_string(3, (chosen + 5) % 8, " ");
396 
    // draw current _cursor_
 396 
    // draw current _cursor_
397 
    write_ascii_string(3, chosen + 5, ">");
 397 
    write_ascii_string(3, chosen + 5, ">");
398 
    if (COSD_FLAGS & COSD_FLAG_HUD) {
 398 
    if (COSD_FLAGS & COSD_FLAG_HUD) {
399 
        write_ascii_string_pgm(23, 5, ON);
 399 
        write_ascii_string_pgm(23, 5, ON);
400 
    } else {
 400 
    } else {
401 
                write_ascii_string_pgm(23, 5, OFF);
 401 
                write_ascii_string_pgm(23, 5, OFF);
402 
    }
 402 
    }
403 
    if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
 403 
    if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
404 
        write_ascii_string_pgm(23, 6, ON);
 404 
        write_ascii_string_pgm(23, 6, ON);
405 
    } else {
 405 
    } else {
406 
        write_ascii_string_pgm(23, 6, OFF);
 406 
        write_ascii_string_pgm(23, 6, OFF);
407 
    }
 407 
    }
408 
        if (COSD_FLAGS & COSD_FLAG_BIGVARIO) {
 408 
        if (COSD_FLAGS & COSD_FLAG_BIGVARIO) {
409 
        write_ascii_string_pgm(23, 7, ON);
 409 
        write_ascii_string_pgm(23, 7, ON);
410 
    } else {
 410 
    } else {
411 
                write_ascii_string_pgm(23, 7, OFF);
 411 
                write_ascii_string_pgm(23, 7, OFF);
412 
    }
 412 
    }
413 
        if (COSD_FLAGS & COSD_FLAG_STATS) {
 413 
        if (COSD_FLAGS & COSD_FLAG_STATS) {
414 
        write_ascii_string_pgm(23, 8, ON);
 414 
        write_ascii_string_pgm(23, 8, ON);
415 
    } else {
 415 
    } else {
416 
        write_ascii_string_pgm(23, 8, OFF);
 416 
        write_ascii_string_pgm(23, 8, OFF);
417 
    }
 417 
    }
418 
    if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
 418 
    if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
419 
        write_ascii_string_pgm(23, 9, ON);
 419 
        write_ascii_string_pgm(23, 9, ON);
420 
    } else {
 420 
    } else {
421 
        write_ascii_string_pgm(23, 9, OFF);
 421 
        write_ascii_string_pgm(23, 9, OFF);
422 
    }
 422 
    }
423 
}
 423 
}
424 
 
 424 
 
425 
/**
 425 
/**
426 
 * some sort of clicking response in the menu
 426 
 * some sort of clicking response in the menu
427 
 */
 427 
 */
428 
void config_menu_doclick(uint8_t chosen, char** menu) {
 428 
void config_menu_doclick(uint8_t chosen, char** menu) {
429 
        write_ascii_string(4, chosen + 5, "DONE              ");
 429 
        write_ascii_string(4, chosen + 5, "DONE              ");
430 
        _delay_ms(1000);
 430 
        _delay_ms(1000);
431 
        write_ascii_string(4, chosen + 5, menu[chosen]);
 431 
        write_ascii_string(4, chosen + 5, menu[chosen]);
432 
}
 432 
}
433 
 
 433 
 
434 
/**
 434 
/**
435 
 * a simple config menu tryout
 435 
 * a simple config menu tryout
436 
 */
 436 
 */
437 
void config_menu(void) {
 437 
void config_menu(void) {
438 
        // disable interrupts (makes the menu more smoothely)
 438 
        // disable interrupts (makes the menu more smoothely)
439 
        cli();
 439 
        cli();
440 
 
 440 
 
441 
        // clear screen
 441 
        // clear screen
442 
        clear();
 442 
        clear();
443 
       
 443 
       
444 
        char* menu[9] = {"Full HUD",
 444 
        char* menu[9] = {"Full HUD",
445 
                                         "Art.Horizon in HUD",
 445 
                                         "Art.Horizon in HUD",
446 
                                         "Big Vario bar",
 446 
                                         "Big Vario bar",
447 
                                         "Statistics",
 447 
                                         "Statistics",
448 
                                         "Warnings",    // TODO: do it!
 448 
                                         "Warnings",    // TODO: do it!
449 
                                         "Reset uptime",
 449 
                                         "Reset uptime",
450 
                                         "Request OSD-data",
 450 
                                         "Request OSD-data",
451 
                                         "Disable Debug-data",
 451 
                                         "Disable Debug-data",
452 
                                         "EXIT"};
 452 
                                         "EXIT"};
453 
 
 453 
 
454 
        uint8_t inmenu = 1;
 454 
        uint8_t inmenu = 1;
455 
        uint8_t chosen = 0;
 455 
        uint8_t chosen = 0;
456 
        write_ascii_string(6,  2, "C-OSD Config Menu");
 456 
        write_ascii_string(6,  2, "C-OSD Config Menu");
457 
 
 457 
 
458 
        // wait a bit before doing stuff so user has chance to release button
 458 
        // wait a bit before doing stuff so user has chance to release button
459 
        _delay_ms(250);
 459 
        _delay_ms(250);
460 
 
 460 
 
461 
        write_ascii_string(4,  5, menu[0]);
 461 
        write_ascii_string(4,  5, menu[0]);
462 
        write_ascii_string(4,  6, menu[1]);
 462 
        write_ascii_string(4,  6, menu[1]);
463 
        write_ascii_string(4,  7, menu[2]);
 463 
        write_ascii_string(4,  7, menu[2]);
464 
        write_ascii_string(4,  8, menu[3]);
 464 
        write_ascii_string(4,  8, menu[3]);
465 
        write_ascii_string(4,  9, menu[4]);
 465 
        write_ascii_string(4,  9, menu[4]);
466 
        write_ascii_string(4, 10, menu[5]);
 466 
        write_ascii_string(4, 10, menu[5]);
467 
        write_ascii_string(4, 11, menu[6]);
 467 
        write_ascii_string(4, 11, menu[6]);
468 
        write_ascii_string(4, 12, menu[7]);
 468 
        write_ascii_string(4, 12, menu[7]);
469 
        write_ascii_string(4, 13, menu[8]);
 469 
        write_ascii_string(4, 13, menu[8]);
470 
 
 470 
 
471 
        config_menu_drawings(chosen);
 471 
        config_menu_drawings(chosen);
472 
 
 472 
 
473 
        while (inmenu) {
 473 
        while (inmenu) {
474 
                        if (s2_pressed()) {
 474 
                        if (s2_pressed()) {
475 
                                write_ascii_string(3,  chosen+5, " ");
 475 
                                write_ascii_string(3,  chosen+5, " ");
476 
                                chosen = (chosen + 1) % 9;
 476 
                                chosen = (chosen + 1) % 9;
477 
                                write_ascii_string(3,  chosen+5, ">");
 477 
                                write_ascii_string(3,  chosen+5, ">");
478 
                                _delay_ms(500);
 478 
                                _delay_ms(500);
479 
                        } else if (s1_pressed()) {
 479 
                        } else if (s1_pressed()) {
480 
                                switch (chosen) {
 480 
                                switch (chosen) {
481 
                                        case 0:         // full HUD
 481 
                                        case 0:         // full HUD
482 
                                                COSD_FLAGS ^= COSD_FLAG_HUD;
 482 
                                                COSD_FLAGS ^= COSD_FLAG_HUD;
483 
                                                config_menu_drawings(chosen);
 483 
                                                config_menu_drawings(chosen);
484 
                                                break;
 484 
                                                break;
485 
                                        case 1:         // art horizon
 485 
                                        case 1:         // art horizon
486 
                                                COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;
 486 
                                                COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;
487 
                                                config_menu_drawings(chosen);
 487 
                                                config_menu_drawings(chosen);
488 
                                                break;
 488 
                                                break;
489 
                                        case 2:         // big vario
 489 
                                        case 2:         // big vario
490 
                                                COSD_FLAGS ^= COSD_FLAG_BIGVARIO;
 490 
                                                COSD_FLAGS ^= COSD_FLAG_BIGVARIO;
491 
                                                config_menu_drawings(chosen);
 491 
                                                config_menu_drawings(chosen);
492 
                                                break;
 492 
                                                break;
493 
                                        case 3:         // statistics
 493 
                                        case 3:         // statistics
494 
                                                COSD_FLAGS ^= COSD_FLAG_STATS;
 494 
                                                COSD_FLAGS ^= COSD_FLAG_STATS;
495 
                                                config_menu_drawings(chosen);
 495 
                                                config_menu_drawings(chosen);
496 
                                                break;
 496 
                                                break;
497 
                                        case 4:         // warnings
 497 
                                        case 4:         // warnings
498 
                                                COSD_FLAGS ^= COSD_FLAG_WARNINGS;
 498 
                                                COSD_FLAGS ^= COSD_FLAG_WARNINGS;
499 
                                                config_menu_drawings(chosen);
 499 
                                                config_menu_drawings(chosen);
500 
                                                break;
 500 
                                                break;
501 
                                        case 5:         // reset uptime
 501 
                                        case 5:         // reset uptime
502 
                                                uptime = 0;
 502 
                                                uptime = 0;
503 
                                                config_menu_doclick(chosen, menu);
 503 
                                                config_menu_doclick(chosen, menu);
504 
                                                break;
 504 
                                                break;
505 
                                        case 6:         // re-request OSD data
 505 
                                        case 6:         // re-request OSD data
506 
                                                // request OSD Data from NC every 100ms
 506 
                                                // request OSD Data from NC every 100ms
507 
                                                usart1_request_mk_data(1, 'o', 100);
 507 
                                                usart1_request_mk_data(1, 'o', 100);
508 
                                                config_menu_doclick(chosen, menu);
 508 
                                                config_menu_doclick(chosen, menu);
509 
                                                break;
 509 
                                                break;
510 
                                        case 7:         // disable debug data
 510 
                                        case 7:         // disable debug data
511 
                                                // disable sending of debug data
 511 
                                                // disable sending of debug data
512 
                                                // may result in smoother ddata display
 512 
                                                // may result in smoother ddata display
513 
                                                usart1_request_mk_data(0, 'd', 0);
 513 
                                                usart1_request_mk_data(0, 'd', 0);
514 
                                                config_menu_doclick(chosen, menu);
 514 
                                                config_menu_doclick(chosen, menu);
515 
                                                break;
 515 
                                                break;
516 
                                        case 8:         // exit
 516 
                                        case 8:         // exit
517 
                                                inmenu = 0;
 517 
                                                inmenu = 0;
518 
                                                break;
 518 
                                                break;
519 
                                }
 519 
                                }
520 
                                _delay_ms(250);
 520 
                                _delay_ms(250);
521 
                        }
 521 
                        }
522 
        }
 522 
        }
523 
 
 523 
 
524 
        // clear screen up again
 524 
        // clear screen up again
525 
        clear();
 525 
        clear();
526 
 
 526 
 
527 
        // update flags to paint display again if needed
 527 
        // update flags to paint display again if needed
528 
        COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
 528 
        COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
529 
 
 529 
 
530 
        // enable interrupts again
 530 
        // enable interrupts again
531 
        sei();
 531 
        sei();
532 
}
 532 
}
533 
 
 533 
 
534 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
 534 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
535 
/* ##########################################################################
 535 
/* ##########################################################################
536 
 * MAIN
 536 
 * MAIN
537 
 * ##########################################################################*/
 537 
 * ##########################################################################*/
538 
int main(void) {
 538 
int main(void) {
539 
    // set up FLAGS, compiler should flatten this one
 539 
    // set up FLAGS, compiler should flatten this one
540 
    COSD_FLAGS = (NTSC << 0);
 540 
    COSD_FLAGS = (NTSC << 0);
541 
    COSD_FLAGS |= (HUD << 1);
 541 
    COSD_FLAGS |= (HUD << 1);
542 
    COSD_FLAGS |= (ARTHORIZON << 2);
 542 
    COSD_FLAGS |= (ARTHORIZON << 2);
543 
        COSD_FLAGS |= (BIGVARIO << 3);
 543 
        COSD_FLAGS |= (BIGVARIO << 3);
544 
        COSD_FLAGS |= (STATS << 4);
 544 
        COSD_FLAGS |= (STATS << 4);
545 
    COSD_FLAGS |= (WARNINGS << 5);
 545 
    COSD_FLAGS |= (WARNINGS << 5);
546 
 
 546 
 
547 
    // set up Atmega162 Ports
 547 
    // set up Atmega162 Ports
548 
    DDRA |= (1 << PA1); // PA1 output (/CS)
 548 
    DDRA |= (1 << PA1); // PA1 output (/CS)
549 
    MAX_CS_HIGH
 549 
    MAX_CS_HIGH
550 
    DDRA |= (1 << PA2); // PA2 output (SDIN)
 550 
    DDRA |= (1 << PA2); // PA2 output (SDIN)
551 
    MAX_SDIN_LOW
 551 
    MAX_SDIN_LOW
552 
    DDRA |= (1 << PA3); // PA3 output (SCLK)
 552 
    DDRA |= (1 << PA3); // PA3 output (SCLK)
553 
    MAX_SCLK_LOW
 553 
    MAX_SCLK_LOW
554 
    DDRA |= (1 << PA5); // PA5 output (RESET)
 554 
    DDRA |= (1 << PA5); // PA5 output (RESET)
555 
    MAX_RESET_HIGH
 555 
    MAX_RESET_HIGH
556 
 
 556 
 
557 
    DDRC |= (1 << PC0); // PC0 output (LED1 gn)
 557 
    DDRC |= (1 << PC0); // PC0 output (LED1 gn)
558 
    LED1_OFF
 558 
    LED1_OFF
559 
    DDRC |= (1 << PC1); // PC1 output (LED2 rt)
 559 
    DDRC |= (1 << PC1); // PC1 output (LED2 rt)
560 
    LED2_OFF
 560 
    LED2_OFF
561 
    DDRC |= (1 << PC2); // PC2 output (LED3 gn)
 561 
    DDRC |= (1 << PC2); // PC2 output (LED3 gn)
562 
    LED3_OFF
 562 
    LED3_OFF
563 
    DDRC |= (1 << PC3); // PC3 output (LED4 rt)
 563 
    DDRC |= (1 << PC3); // PC3 output (LED4 rt)
564 
    LED4_OFF
 564 
    LED4_OFF
565 
 
 565 
 
566 
    DDRC &= ~(1 << PC4); // PC4 input  (MODE)
 566 
    DDRC &= ~(1 << PC4); // PC4 input  (MODE)
567 
    PORTC |= (1 << PC4); // pullup
 567 
    PORTC |= (1 << PC4); // pullup
568 
    DDRC &= ~(1 << PC5); // PC5 input  (SET)
 568 
    DDRC &= ~(1 << PC5); // PC5 input  (SET)
569 
    PORTC |= (1 << PC5); // pullup
 569 
    PORTC |= (1 << PC5); // pullup
570 
 
 570 
 
571 
    // set up top and bottom lines
 571 
    // set up top and bottom lines
572 
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
 572 
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
573 
        bottom_line = 12;
 573 
        bottom_line = 12;
574 
    } else {
 574 
    } else {
575 
        bottom_line = 14;
 575 
        bottom_line = 14;
576 
    }
 576 
    }
577 
 
 577 
 
578 
    // reset the MAX7456 to be sure any undefined states do no harm
 578 
    // reset the MAX7456 to be sure any undefined states do no harm
579 
    MAX_RESET_LOW
 579 
    MAX_RESET_LOW
580 
    MAX_RESET_HIGH
 580 
    MAX_RESET_HIGH
581 
 
 581 
 
582 
    // give the FC/NC and the maxim time to come up
 582 
    // give the FC/NC and the maxim time to come up
583 
    LED4_ON
 583 
    LED4_ON
584 
    _delay_ms(2000);
 584 
    _delay_ms(2000);
585 
 
 585 
 
586 
    LED4_OFF
 586 
    LED4_OFF
587 
 
 587 
 
588 
 
 588 
 
589 
    //Pushing NEW chars to the MAX7456
 589 
    //Pushing NEW chars to the MAX7456
590 
#if (WRITECHARS != -1)
 590 
#if (WRITECHARS != -1)
591 
    // DISABLE display (VM0)
 591 
    // DISABLE display (VM0)
592 
    spi_send_byte(0x00, 0b00000000);
 592 
    spi_send_byte(0x00, 0b00000000);
593 
#include "characters.c"
 593 
#include "characters.c"
594 
 
 594 
 
595 
#endif
595 
#endif
596 
 
 596 
 
597 
    // Setup Video Mode
 597 
    // Setup Video Mode
598 
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
 598 
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
599 
        // NTSC + enable display immediately (VM0)
 599 
        // NTSC + enable display immediately (VM0)
600 
        spi_send_byte(0x00, 0b00001000);
 600 
        spi_send_byte(0x00, 0b00001000);
601 
    } else {
 601 
    } else {
602 
        // PAL + enable display immediately (VM0)
 602 
        // PAL + enable display immediately (VM0)
603 
        spi_send_byte(0x00, 0b01001000);
 603 
        spi_send_byte(0x00, 0b01001000);
604 
    }
 604 
    }
605 
 
 605 
 
606 
    // clear all display-mem (DMM)
 606 
    // clear all display-mem (DMM)
607 
    spi_send_byte(0x04, 0b00000100);
 607 
    spi_send_byte(0x04, 0b00000100);
608 
 
 608 
 
609 
    // clearing takes 12uS according to maxim so lets wait longer
 609 
    // clearing takes 12uS according to maxim so lets wait longer
610 
    _delay_us(120);
 610 
    _delay_us(120);
611 
 
 611 
 
612 
    // 8bit mode
 612 
    // 8bit mode
613 
    spi_send_byte(0x04, 0b01000000);
 613 
    spi_send_byte(0x04, 0b01000000);
614 
 
 614 
 
615 
    // write blank chars to whole screen
 615 
    // write blank chars to whole screen
616 
    clear();
 616 
    clear();
617 
 
 617 
 
618 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 618 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
619 
    // init usart
 619 
    // init usart
620 
    usart1_init();
 620 
    usart1_init();
621 
 
 621 
 
622 
    // set up timer
 622 
    // set up timer
623 
    TCCR0 |= (1 << CS00) | (1 << CS01); // timer0 prescaler 64
 623 
    TCCR0 |= (1 << CS00) | (1 << CS01); // timer0 prescaler 64
624 
    OCR0 = 15; // preload
 624 
    OCR0 = 15; // preload
625 
    TIMSK |= (1 << TOIE0); // enable overflow timer0
 625 
    TIMSK |= (1 << TOIE0); // enable overflow timer0
626 
 
 626 
 
627 
    // enable interrupts
 627 
    // enable interrupts
628 
    sei();
 628 
    sei();
629 
#endif
 629 
#endif
630 
 
 630 
 
631 
    //write_ascii_string(2,  7, "         CaScAdE          ");
 631 
    //write_ascii_string(2,  7, "         CaScAdE          ");
632 
    //write_ascii_string(2,  8, "is TESTING his open source");
 632 
    //write_ascii_string(2,  8, "is TESTING his open source");
633 
    //write_ascii_string(2,  9, "    EPi OSD Firmware");
 633 
    //write_ascii_string(2,  9, "    EPi OSD Firmware");
634 
 
 634 
 
635 
    // custom char preview
 635 
    // custom char preview
636 
    /*write_char_xy( 2, 7, 200);
 636 
    /*write_char_xy( 2, 7, 200);
637 
    write_char_xy( 3, 7, 201);
 637 
    write_char_xy( 3, 7, 201);
638 
    write_char_xy( 4, 7, 202);
 638 
    write_char_xy( 4, 7, 202);
639 
    write_char_xy( 5, 7, 203);
 639 
    write_char_xy( 5, 7, 203);
640 
    write_char_xy( 6, 7, 204);
 640 
    write_char_xy( 6, 7, 204);
641 
    write_char_xy( 7, 7, 205);
 641 
    write_char_xy( 7, 7, 205);
642 
    write_char_xy( 8, 7, 206);
 642 
    write_char_xy( 8, 7, 206);
643 
    write_char_xy( 9, 7, 207);
 643 
    write_char_xy( 9, 7, 207);
644 
    write_char_xy(10, 7, 208);
 644 
    write_char_xy(10, 7, 208);
645 
    write_char_xy(11, 7, 209);
 645 
    write_char_xy(11, 7, 209);
646 
    write_char_xy(12, 7, 210);
 646 
    write_char_xy(12, 7, 210);
647 
    write_char_xy(13, 7, 211);
 647 
    write_char_xy(13, 7, 211);
648 
    write_char_xy(14, 7, 212);
 648 
    write_char_xy(14, 7, 212);
649 
    write_char_xy(15, 7, 213);
 649 
    write_char_xy(15, 7, 213);
650 
    write_char_xy(16, 7, 214);
 650 
    write_char_xy(16, 7, 214);
651 
    write_char_xy(17, 7, 215);*/
 651 
    write_char_xy(17, 7, 215);*/
652 
 
 652 
 
653 
    // we are ready
 653 
    // we are ready
654 
    LED3_ON
 654 
    LED3_ON
655 
 
 655 
 
656 
 
 656 
 
657 
 
 657 
 
658 
#if ALLCHARSDEBUG | (WRITECHARS != -1)
 658 
#if ALLCHARSDEBUG | (WRITECHARS != -1)
659 
        clear();
 659 
        clear();
660 
    write_all_chars();
 660 
    write_all_chars();
661 
#else
 661 
#else
662 
        // clear serial screen
 662 
        // clear serial screen
663 
        //usart1_puts("\x1B[2J\x1B[H");
 663 
        //usart1_puts("\x1B[2J\x1B[H");
664 
        //usart1_puts("hello world!\r\n");
 664 
        //usart1_puts("hello world!\r\n");
665 
 
 665 
 
666 
 
 666 
 
667 
        // request data ever 100ms from FC;
 667 
        // request data ever 100ms from FC;
668 
        //usart1_request_mk_data(0, 'd', 100);
 668 
        //usart1_request_mk_data(0, 'd', 100);
669 
 
 669 
 
670 
        // request OSD Data from NC every 100ms
 670 
        // request OSD Data from NC every 100ms
671 
        usart1_request_mk_data(1, 'o', 100);
 671 
        usart1_request_mk_data(1, 'o', 100);
672 
 
 672 
 
673 
    // and disable debug...
 673 
    // and disable debug...
674 
        usart1_request_mk_data(0, 'd', 0);
 674 
        usart1_request_mk_data(0, 'd', 0);
675 
 
 675 
 
676 
    // disable TXD-pin
 676 
    // disable TXD-pin
677 
    usart1_DisableTXD();
 677 
    //usart1_DisableTXD();
678 
 
 678 
 
679 
    // stats for after flight
 679 
    // stats for after flight
680 
    int16_t max_Altimeter = 0;
 680 
    int16_t max_Altimeter = 0;
681 
    uint16_t max_GroundSpeed = 0;
 681 
    uint16_t max_GroundSpeed = 0;
682 
    int16_t max_Distance = 0;
 682 
    int16_t max_Distance = 0;
683 
    uint8_t min_UBat = 255;
 683 
    uint8_t min_UBat = 255;
684 
    uint16_t max_FlyingTime = 0;
 684 
    uint16_t max_FlyingTime = 0;
685 
 
 685 
 
686 
    // flags from last round to check for changes
 686 
    // flags from last round to check for changes
687 
    uint8_t old_MKFlags = 0;
 687 
    uint8_t old_MKFlags = 0;
688 
 
 688 
 
689 
    char* directions[8] = {"NE", "E ", "SE", "S ", "SW", "W ", "NW", "N "};
 689 
    char* directions[8] = {"NE", "E ", "SE", "S ", "SW", "W ", "NW", "N "};
690 
    //char arrowdir[8] = {218, 217, 224, 223, 222, 221, 220, 219};
 690 
    //char arrowdir[8] = {218, 217, 224, 223, 222, 221, 220, 219};
691 
 
 691 
 
692 
        /*write_ndigit_number_s_10th(5, 10, 1, 100, 0);
 692 
        /*write_ndigit_number_s_10th(5, 10, 1, 100, 0);
693 
        write_ndigit_number_s_10th(5, 11, -1, 100, 0);
 693 
        write_ndigit_number_s_10th(5, 11, -1, 100, 0);
694 
        write_ndigit_number_s_10th(5, 12, -11, 100, 0);*/
 694 
        write_ndigit_number_s_10th(5, 12, -11, 100, 0);*/
695 
 
 695 
 
696 
        //write_ndigit_number_u(2,2, heading_fine_conv(34), 100, 0);
 696 
        //write_ndigit_number_u(2,2, heading_fine_conv(34), 100, 0);
697 
        //write_char_xy(1, 2, 0xa0 + heading_fine_conv(34));
 697 
        //write_char_xy(1, 2, 0xa0 + heading_fine_conv(34));
698 
 
 698 
 
699 
    while (1) {
 699 
    while (1) {
700 
        // write icons at init or after menu/mode-switch
 700 
        // write icons at init or after menu/mode-switch
701 
        if (!(COSD_FLAGS & COSD_ICONS_WRITTEN) && (COSD_FLAGS & COSD_FLAG_HUD)) {
 701 
        if (!(COSD_FLAGS & COSD_ICONS_WRITTEN) && (COSD_FLAGS & COSD_FLAG_HUD)) {
702 
            write_char_xy(5, top_line, 0xCB); // km/h
 702 
            write_char_xy(5, top_line, 0xCB); // km/h
703 
            write_char_xy(10, top_line, 0xCA); // RC-transmitter
 703 
            write_char_xy(10, top_line, 0xCA); // RC-transmitter
704 
            write_char_xy(16, top_line, 0xD0); // degree symbol
 704 
            write_char_xy(16, top_line, 0xD0); // degree symbol
705 
            write_char_xy(27, top_line, 0xCC); // small meters m height
 705 
            write_char_xy(27, top_line, 0xCC); // small meters m height
706 
                        write_char_xy(20, top_line+1, 0xB0); // left circle
 706 
                        write_char_xy(20, top_line+1, 0xB0); // left circle
707 
                        write_char_xy(22, top_line+1, 0xB2); // right circle
 707 
                        write_char_xy(22, top_line+1, 0xB2); // right circle
708 
                        write_char_xy(27, top_line+1, 0xCC); // small meters m home
 708 
                        write_char_xy(27, top_line+1, 0xCC); // small meters m home
709 
                        write_char_xy(7, bottom_line, 0x9E); // small v
 709 
                        write_char_xy(7, bottom_line, 0x9E); // small v
710 
            write_char_xy(14, bottom_line, 0xD1); // on clock
 710 
            write_char_xy(14, bottom_line, 0xD1); // on clock
711 
            write_char_xy(22, bottom_line, 0xD2); // fly clock
 711 
            write_char_xy(22, bottom_line, 0xD2); // fly clock
712 
            write_char_xy(26, bottom_line, 0xC8); // sat1
 712 
            write_char_xy(26, bottom_line, 0xC8); // sat1
713 
            write_char_xy(27, bottom_line, 0xC9); // sat2
 713 
            write_char_xy(27, bottom_line, 0xC9); // sat2
714 
            COSD_FLAGS |= COSD_ICONS_WRITTEN;
 714 
            COSD_FLAGS |= COSD_ICONS_WRITTEN;
715 
        }
 715 
        }
716 
        if (rxd_buffer_locked) {
 716 
        if (rxd_buffer_locked) {
717 
            if (COSD_FLAGS & COSD_FLAG_HUD) {
 717 
            if (COSD_FLAGS & COSD_FLAG_HUD) {
718 
                if (rxd_buffer[2] == 'D') { // FC Data
 718 
                if (rxd_buffer[2] == 'D') { // FC Data
719 
                    /*Decode64();
 719 
                    /*Decode64();
720 
                    debugData = *((DebugOut_t*) pRxData);
 720 
                    debugData = *((DebugOut_t*) pRxData);
721 
                    write_number_s(12, 2, RxDataLen);
 721 
                    write_number_s(12, 2, RxDataLen);
722 
                    write_number_s(20, 2, setsReceived++);
 722 
                    write_number_s(20, 2, setsReceived++);
723 
                    write_number_s(12, 3, debugData.Analog[0]); // AngleNick
 723 
                    write_number_s(12, 3, debugData.Analog[0]); // AngleNick
724 
                    write_number_s(12, 4, debugData.Analog[1]); // AngleRoll
 724 
                    write_number_s(12, 4, debugData.Analog[1]); // AngleRoll
725 
                                        write_number_s(12, 5, debugData.Analog[5]); // Height
 725 
                                        write_number_s(12, 5, debugData.Analog[5]); // Height
726 
                    write_number_s(12, 6, debugData.Analog[9]); // Voltage
 726 
                    write_number_s(12, 6, debugData.Analog[9]); // Voltage
727 
                    write_number_s(12, 7, debugData.Analog[10]);// RC Signal
 727 
                    write_number_s(12, 7, debugData.Analog[10]);// RC Signal
728 
                                        write_number_s(12, 8, debugData.Analog[11]);// Gyro compass*/
 728 
                                        write_number_s(12, 8, debugData.Analog[11]);// Gyro compass*/
729 
                } else if (rxd_buffer[2] == 'O') { // NC OSD Data
 729 
                } else if (rxd_buffer[2] == 'O') { // NC OSD Data
730 
                    Decode64();
 730 
                    Decode64();
731 
                    naviData = *((NaviData_t*) pRxData);
 731 
                    naviData = *((NaviData_t*) pRxData);
732 
                                       
 732 
                                       
733 
                    // first line
 733 
                    // first line
734 
                    write_ndigit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * (uint32_t)9) / (uint32_t)250), 100, 0);
 734 
                    write_ndigit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * (uint32_t)9) / (uint32_t)250), 100, 0);
735 
 
 735 
 
736 
                    write_ndigit_number_u(7, top_line, naviData.RC_Quality, 100, 0);
 736 
                    write_ndigit_number_u(7, top_line, naviData.RC_Quality, 100, 0);
737 
                    if (naviData.RC_Quality <= RCLVL_WRN && last_RC_Quality > RCLVL_WRN) {
 737 
                    if (naviData.RC_Quality <= RCLVL_WRN && last_RC_Quality > RCLVL_WRN) {
738 
                        for (uint8_t x = 0; x < 4; x++)
 738 
                        for (uint8_t x = 0; x < 4; x++)
739 
                            write_char_att_xy(7 + x, top_line, BLINK);
 739 
                            write_char_att_xy(7 + x, top_line, BLINK);
740 
                    } else if (naviData.RC_Quality > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {
 740 
                    } else if (naviData.RC_Quality > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {
741 
                        for (uint8_t x = 0; x < 4; x++)
 741 
                        for (uint8_t x = 0; x < 4; x++)
742 
                            write_char_att_xy(7 + x, top_line, 0);
 742 
                            write_char_att_xy(7 + x, top_line, 0);
743 
                    }
 743 
                    }
744 
                    last_RC_Quality = naviData.RC_Quality;
 744 
                    last_RC_Quality = naviData.RC_Quality;
745 
 
 745 
 
746 
                    write_ndigit_number_u(13, top_line, naviData.CompassHeading, 100, 0);
 746 
                    write_ndigit_number_u(13, top_line, naviData.CompassHeading, 100, 0);
747 
 
 747 
 
748 
                    write_ascii_string(17, top_line, directions[heading_conv(naviData.CompassHeading)]);
 748 
                    write_ascii_string(17, top_line, directions[heading_conv(naviData.CompassHeading)]);
749 
                                       
 749 
                                       
750 
                                        draw_variometer(21, top_line, naviData.Variometer);
 750 
                                        draw_variometer(21, top_line, naviData.Variometer);
751 
 
 751 
 
752 
                    //note:lephisto:according to several sources it's /30
 752 
                    //note:lephisto:according to several sources it's /30
753 
                    if (naviData.Altimeter > 300 || naviData.Altimeter < -300) {
 753 
                    if (naviData.Altimeter > 300 || naviData.Altimeter < -300) {
754 
                        // above 10m only write full meters
 754 
                        // above 10m only write full meters
755 
                        write_ndigit_number_s(23, top_line, naviData.Altimeter / 30, 1000, 0);
 755 
                        write_ndigit_number_s(23, top_line, naviData.Altimeter / 30, 1000, 0);
756 
                    } else {
 756 
                    } else {
757 
                        // up to 10m write meters.dm
 757 
                        // up to 10m write meters.dm
758 
                        //write_number_u_10th(21, top_line, naviData.Altimeter / 3);
 758 
                        //write_number_u_10th(21, top_line, naviData.Altimeter / 3);
759 
                                                write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 100, 0);
 759 
                                                write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 100, 0);
760 
                    }
 760 
                    }
761 
 
 761 
 
762 
                    // seccond line
 762 
                    // seccond line
763 
                    draw_compass(11, top_line + 1, naviData.CompassHeading);
 763 
                    draw_compass(11, top_line + 1, naviData.CompassHeading);
764 
 
 764 
 
765 
                    // TODO: verify correctness
 765 
                    // TODO: verify correctness
766 
                    uint16_t heading_home = (naviData.HomePositionDeviation.Bearing + 360 - naviData.CompassHeading) % 360;
 766 
                    uint16_t heading_home = (naviData.HomePositionDeviation.Bearing + 360 - naviData.CompassHeading) % 360;
767 
                    //write_char_xy(21, top_line + 1, arrowdir[heading_conv(heading_home)]);
 767 
                    //write_char_xy(21, top_line + 1, arrowdir[heading_conv(heading_home)]);
768 
                                        // finer resolution, 0xa0 is first character and we add the index 0 <= index < 16
 768 
                                        // finer resolution, 0xa0 is first character and we add the index 0 <= index < 16
769 
                                        write_char_xy(21, top_line + 1, 0xa0 + heading_fine_conv(heading_home));
 769 
                                        write_char_xy(21, top_line + 1, 0xa0 + heading_fine_conv(heading_home));
770 
 
 770 
 
771 
                    write_ndigit_number_u(24, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 100, 0);
 771 
                    write_ndigit_number_u(24, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 100, 0);
772 
 
 772 
 
773 
                    // center
 773 
                    // center
774 
                    if (naviData.MKFlags & FLAG_MOTOR_RUN) { // should be engines running
 774 
                    if (naviData.MKFlags & FLAG_MOTOR_RUN) { // should be engines running
775 
                        if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle
 775 
                        if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle
776 
                            clear();
 776 
                            clear();
777 
                            // update flags to paint display again if needed
 777 
                            // update flags to paint display again if needed
778 
                            COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
 778 
                            COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
779 
                        }
 779 
                        }
780 
                        if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
 780 
                        if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
781 
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
 781 
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
782 
                        }
 782 
                        }
783 
                    } else {
 783 
                    } else {
784 
                                                // stats
 784 
                                                // stats
785 
                                                if (COSD_FLAGS & COSD_FLAG_STATS) {
 785 
                                                if (COSD_FLAGS & COSD_FLAG_STATS) {
786 
                                                        write_ascii_string_pgm(2, 5, stats_item_pointers[0]); // max Altitude
 786 
                                                        write_ascii_string_pgm(2, 5, stats_item_pointers[0]); // max Altitude
787 
                                write_ndigit_number_s(18, 5, max_Altimeter / 30, 1000, 0);
 787 
                                write_ndigit_number_s(18, 5, max_Altimeter / 30, 1000, 0);
788 
                                write_char_xy(22, 5, 204); // small meters m
 788 
                                write_char_xy(22, 5, 204); // small meters m
789 
                                                        write_ascii_string_pgm(2, 6, stats_item_pointers[1]); // max Speed
 789 
                                                        write_ascii_string_pgm(2, 6, stats_item_pointers[1]); // max Speed
790 
                                write_ndigit_number_u(19, 6, (uint16_t) (((uint32_t) max_GroundSpeed * 36) / 1000), 100, 0);
 790 
                                write_ndigit_number_u(19, 6, (uint16_t) (((uint32_t) max_GroundSpeed * 36) / 1000), 100, 0);
791 
                                write_char_xy(22, 6, 203); // km/h
 791 
                                write_char_xy(22, 6, 203); // km/h
792 
                                                        write_ascii_string_pgm(2, 7, stats_item_pointers[2]); // max Distance
 792 
                                                        write_ascii_string_pgm(2, 7, stats_item_pointers[2]); // max Distance
793 
                                write_ndigit_number_u(19, 7, max_Distance / 100, 100, 0);
 793 
                                write_ndigit_number_u(19, 7, max_Distance / 100, 100, 0);
794 
                                write_char_xy(22, 7, 204); // small meters m
 794 
                                write_char_xy(22, 7, 204); // small meters m
795 
                                                        write_ascii_string_pgm(2, 8, stats_item_pointers[3]); // min voltage
 795 
                                                        write_ascii_string_pgm(2, 8, stats_item_pointers[3]); // min voltage
796 
                                                        write_ndigit_number_u_10th(18, 8, min_UBat, 100, 0);
 796 
                                                        write_ndigit_number_u_10th(18, 8, min_UBat, 100, 0);
797 
                                write_ascii_string(22, 8, "V"); // voltage
 797 
                                                        write_char_xy(22, 8, 0x9E); // small v
798 
                                                        write_ascii_string_pgm(2, 9, stats_item_pointers[4]); // max time
 798 
                                                        write_ascii_string_pgm(2, 9, stats_item_pointers[4]); // max time
799 
                                write_time(16, 9, max_FlyingTime);
 799 
                                write_time(16, 9, max_FlyingTime);
800 
                                write_char_xy(22, 9, 210); // fly clock
 800 
                                write_char_xy(22, 9, 210); // fly clock
801 
                                                } else if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon
 801 
                                                } else if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon
802 
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
 802 
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
803 
                        }
 803 
                        }
804 
                    }
 804 
                    }
805 
                                        if (COSD_FLAGS & COSD_FLAG_BIGVARIO) {
 805 
                                        if (COSD_FLAGS & COSD_FLAG_BIGVARIO) {
806 
                                                draw_big_variometer(27, 8, naviData.Variometer);
 806 
                                                draw_big_variometer(27, 8, naviData.Variometer);
807 
                                        }
 807 
                                        }
808 
 
 808 
 
809 
                    // bottom line
 809 
                    // bottom line
810 
                                        draw_battery(2, bottom_line, naviData.UBat);
 810 
                                        draw_battery(2, bottom_line, naviData.UBat);
811 
                                        write_ndigit_number_u_10th(3, bottom_line, naviData.UBat, 100, 0);
 811 
                                        write_ndigit_number_u_10th(3, bottom_line, naviData.UBat, 100, 0);
812 
                    if (naviData.UBat <= UBAT_WRN && last_UBat > UBAT_WRN) {
 812 
                    if (naviData.UBat <= UBAT_WRN && last_UBat > UBAT_WRN) {
813 
                        for (uint8_t x = 2; x < 8; x++)
 813 
                        for (uint8_t x = 2; x < 8; x++)
814 
                            write_char_att_xy(x, bottom_line, BLINK);
 814 
                            write_char_att_xy(x, bottom_line, BLINK);
815 
                    } else {
 815 
                    } else {
816 
                        for (uint8_t x = 2; x < 8; x++)
 816 
                        for (uint8_t x = 2; x < 8; x++)
817 
                            write_char_att_xy(x, bottom_line, 0);
 817 
                            write_char_att_xy(x, bottom_line, 0);
818 
                    }
 818 
                    }
819 
                                       
 819 
                                       
820 
 
 820 
 
821 
                    write_time(8, bottom_line, uptime);
 821 
                    write_time(8, bottom_line, uptime);
822 
                    write_time(16, bottom_line, naviData.FlyingTime);
 822 
                    write_time(16, bottom_line, naviData.FlyingTime);
823 
 
 823 
 
824 
                    write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 10, 0);
 824 
                    write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 10, 0);
825 
 
 825 
 
826 
                    if (naviData.NCFlags & NC_FLAG_CH) {
 826 
                    if (naviData.NCFlags & NC_FLAG_CH) {
827 
                        write_char_xy(27, bottom_line, 231); // gps ch
 827 
                        write_char_xy(27, bottom_line, 231); // gps ch
828 
                    } else if (naviData.NCFlags & NC_FLAG_PH) {
 828 
                    } else if (naviData.NCFlags & NC_FLAG_PH) {
829 
                        write_char_xy(27, bottom_line, 230); // gps ph
 829 
                        write_char_xy(27, bottom_line, 230); // gps ph
830 
                    } else { // (naviData.NCFlags & NC_FLAG_FREE)
 830 
                    } else { // (naviData.NCFlags & NC_FLAG_FREE)
831 
                        write_char_xy(27, bottom_line, 201); // sat2 (free)
 831 
                        write_char_xy(27, bottom_line, 201); // sat2 (free)
832 
                    }
 832 
                    }
833 
 
 833 
 
834 
                    //write_number_s(8, 5, RxDataLen);
 834 
                    //write_number_s(8, 5, RxDataLen);
835 
                    //write_number_s(16, 5, setsReceived++);
 835 
                    //write_number_s(16, 5, setsReceived++);
836 
 
 836 
 
837 
                    // remember statistics
 837 
                    // remember statistics
838 
                    if (naviData.Altimeter > max_Altimeter) max_Altimeter = naviData.Altimeter;
 838 
                    if (naviData.Altimeter > max_Altimeter) max_Altimeter = naviData.Altimeter;
839 
                    if (naviData.GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData.GroundSpeed;
 839 
                    if (naviData.GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData.GroundSpeed;
840 
                    if (naviData.HomePositionDeviation.Distance > max_Distance) {
 840 
                    if (naviData.HomePositionDeviation.Distance > max_Distance) {
841 
                        max_Distance = naviData.HomePositionDeviation.Distance;
 841 
                        max_Distance = naviData.HomePositionDeviation.Distance;
842 
                    }
 842 
                    }
843 
                    if (naviData.UBat < min_UBat) min_UBat = naviData.UBat;
 843 
                    if (naviData.UBat < min_UBat) min_UBat = naviData.UBat;
844 
                    if (naviData.FlyingTime > max_FlyingTime) max_FlyingTime = naviData.FlyingTime;
 844 
                    if (naviData.FlyingTime > max_FlyingTime) max_FlyingTime = naviData.FlyingTime;
845 
 
 845 
 
846 
                    old_MKFlags = naviData.MKFlags;
 846 
                    old_MKFlags = naviData.MKFlags;
847 
                }
 847 
                }
848 
            }
 848 
            }
849 
            seconds_since_last_data = 0;
 849 
            seconds_since_last_data = 0;
850 
            rxd_buffer_locked = 0;
 850 
            rxd_buffer_locked = 0;
851 
        }
 851 
        }
852 
        // handle keypress
 852 
        // handle keypress
853 
        if (s1_pressed()) {
 853 
        if (s1_pressed()) {
854 
            config_menu();
 854 
            config_menu();
855 
        }
 855 
        }
856 
        if (seconds_since_last_data > 2) {
 856 
        if (seconds_since_last_data > 2) {
- 
 
 857 
                        /*if (COSD_FLAGS & COSD_FLAG_HUD) {
- 
 
 858 
                                write_ascii_string(2, 3, "ERROR: NO DATA for");
- 
 
 859 
                                write_time(21, 3, seconds_since_last_data);
- 
 
 860 
                        }*/
857 
                        // request OSD Data from NC every 100ms
 861 
                        // request OSD Data from NC every 100ms
858 
                        usart1_request_mk_data(1, 'o', 100);
 862 
                        usart1_request_mk_data(1, 'o', 100);
- 
 
 863 
                        _delay_ms(200);
859 
                        seconds_since_last_data = 0;
 864 
                        //seconds_since_last_data = 0;
860 
        }
 865 
        }
861 
    }
 866 
    }
862 
#endif
 867 
#endif
863 
    return 0;
 868 
    return 0;
864 
}
 869 
}
865 
 
 870