WebSVN - Projects - Diff - Rev 378 and 379


/****************************************************************************
 *   Copyright (C) 2009 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.              *
 *                                                                          *
 *                                                                          *
 *   Credits to:                                                            *
 *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project       *
 *   Gregor "killagreg" Stobrawa for making the MK code readable            *
 *   Klaus "akku" Buettner for the hardware                                 *
 *   Manuel "KeyOz" Schrape for explaining the MK protocol to me            *
 ****************************************************************************/
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/pgmspace.h> 
#include "main.h"
#include "max7456_software_spi.h"
#include "usart1.h"
 
/* TODO:
 * - verifiy correctness of values
 * - clean up code :)
 */
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
// data structs not needed for character flashin
#include "mk-data-structs.h"
 
/* ##########################################################################
 * global definitions and global vars
 * ##########################################################################*/
 
volatile uint16_t setsReceived = 0;
 
volatile NaviData_t naviData;
volatile DebugOut_t debugData;
 
// cache old vars for blinking attribute, checkup is faster than full
// attribute write each time
volatile uint8_t last_UBat = 255;
volatile uint8_t last_RC_Quality = 255;
 
// 16bit should be enough, normal LiPos don't last that long
volatile uint16_t uptime = 0;
volatile uint16_t timer = 0;
 
// remember last time data was received
volatile uint8_t seconds_since_last_data = 0;
 
// store stats description in progmem to save space
char stats_item_0[] PROGMEM = "max Altitude:";
char stats_item_1[] PROGMEM = "max Speed   :";
char stats_item_2[] PROGMEM = "max Distance:";
char stats_item_3[] PROGMEM = "min voltage :";
char stats_item_4[] PROGMEM = "max time    :";
char* stats_item_pointers[] PROGMEM = {stats_item_0, stats_item_1, stats_item_2,
                                        stats_item_3, stats_item_4};
 
// store more fixed strings in progmen
char ON[] PROGMEM = "ON ";
char OFF[] PROGMEM = "OFF";
 
// big vario arrays 
char vario_00[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xff};
char vario_01[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc0};
char vario_02[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc1};
char vario_03[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0x00};
char vario_04[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc0, 0x00};
char vario_05[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc1, 0x00};
char vario_06[5] PROGMEM = {0x00, 0x00, 0xc2, 0x00, 0x00};
char vario_07[5] PROGMEM = {0x00, 0x00, 0xbb, 0x00, 0x00};
char vario_08[5] PROGMEM = {0x00, 0x00, 0xc3, 0x00, 0x00};
char vario_09[5] PROGMEM = {0x00, 0xc4, 0xc3, 0x00, 0x00};
char vario_10[5] PROGMEM = {0x00, 0xc5, 0xc3, 0x00, 0x00};
char vario_11[5] PROGMEM = {0x00, 0xff, 0xc3, 0x00, 0x00};
char vario_12[5] PROGMEM = {0xc4, 0xff, 0xc3, 0x00, 0x00};
char vario_13[5] PROGMEM = {0xc5, 0xff, 0xc3, 0x00, 0x00};
char vario_14[5] PROGMEM = {0xff, 0xff, 0xc3, 0x00, 0x00};
char* vario_pnt[15] PROGMEM = {vario_00, vario_01, vario_02, vario_03, vario_04,
                                vario_05, vario_06, vario_07, vario_08,
                                vario_09, vario_10, vario_11, vario_12,
                                vario_13, vario_14};
 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
 
// general PAL|NTSC distingiusch stuff
uint8_t top_line = 1;
uint8_t bottom_line = 14;
 
// Flags
uint8_t COSD_FLAGS = 0;
 
/* ##########################################################################
 * debounce buttons
 * ##########################################################################*/
int s1_pressed() {
        if (S1_PRESSED) {
                _delay_ms(25);
                if (S1_PRESSED) return 1;
        }
        return 0;
}
 
int s2_pressed() {
        if (S2_PRESSED) {
                _delay_ms(25);
                if (S2_PRESSED) return 1;
        }
        return 0;
}
 
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 
/**
 * serial support
 */
//#include "usart1.c"
 
 
/* ##########################################################################
 * timer stuff
 * ##########################################################################*/
 
/**
 * timer kicks in every 1000uS ^= 1ms
 */
ISR(TIMER0_OVF_vect) {
    OCR0 = 6; // preload
    if (!timer--) {
        uptime++;
        timer = 999;
                seconds_since_last_data++;
    }
}
 
/* ##########################################################################
 * compass stuff
 * ##########################################################################*/
 
/**
 * convert the <heading> gotton from NC into an index
 */
uint8_t heading_conv(uint16_t heading) {
    if (heading > 23 && heading < 68) {
        //direction = "NE";
        return 0;
    } else if (heading > 67 && heading < 113) {
        //direction = "E ";
        return 1;
    } else if (heading > 112 && heading < 158) {
        //direction = "SE";
        return 2;
    } else if (heading > 157 && heading < 203) {
        //direction = "S ";
        return 3;
    } else if (heading > 202 && heading < 248) {
        //direction = "SW";
        return 4;
    } else if (heading > 247 && heading < 293) {
        //direction = "W ";
        return 5;
    } else if (heading > 292 && heading < 338) {
        //direction = "NW";
        return 6;
    }
    //direction = "N ";
    return 7;
}
 
/**
 * convert the <heading> gotton from NC into a more
 * precise index
 */
uint8_t heading_fine_conv(uint16_t heading) {
        if (heading > 337) return 0;
        return (heading * 10) / 225;
}
 
/**
 * draw a compass rose at <x>/<y> for <heading>
 */
void draw_compass(uint8_t x, uint8_t y, uint16_t heading) {
    //char* rose = "---N---O---S---W---N---O---S---W---N---O---S---W";
    char rose[48] = {216, 215, 216, 211, 216, 215, 216, 213, 216, 215, 216, 212,
                    216, 215, 216, 214, 216, 215, 216, 211, 216, 215, 216, 213,
                    216, 215, 216, 212, 216, 215, 216, 214, 216, 215, 216, 211,
                    216, 215, 216, 213, 216, 215, 216, 212, 216, 215, 216, 214};
        // the center is char 19 (north), we add the current heading in 8th
        // which would be 22.5 degrees, but float would bloat up the code
        // and *10 / 225 would take ages... so we take the uncorrect way
    uint8_t front = 19 + (heading / 22);
    for (uint8_t i = 0; i < 9; i++) {
                write_char_xy(x++, y, rose[front - 4 + i]);
    }
}
 
/* ##########################################################################
 * battery index
 * ##########################################################################*/
/**
 * draw a battery symbol at <x>/<y> according to <voltage>
 */
void draw_battery(uint8_t x, uint8_t y, uint16_t voltage) {
        uint8_t percent = (100* (voltage - UBAT_WRN) / (UBAT_MAX - UBAT_WRN));
        if (percent > 100) percent = 100;
        if (voltage < UBAT_WRN) percent = 0;
        write_char_xy(x, y, 0x9d - (percent * 13 / 100));
        //write_ndigit_number_u(x, y-1, percent * 13 / 100, 100, 0);
}
 
/* ##########################################################################
 * variometer
 * ##########################################################################*/
/**
 * draw variometer arrows at <x>/<y> according to <variometer>
 */
void draw_variometer(uint8_t x, uint8_t y, int16_t variometer) {
        if (variometer == 0) {
                write_char_xy(x, y, 0xbb); // plain line
        } else if (variometer > 0) { // gain height
                switch (variometer / 5){
                        case 0:
                                write_char_xy(x, y, 0xba); // smallest arrow up
                                break;
                        case 1:
                                write_char_xy(x, y, 0xb9); // small arrow up
                                break;
                        case 2:
                                write_char_xy(x, y, 0xb8); // large arrow up
                                break;
                        default:
                                write_char_xy(x, y, 0xb7); // largest arrow up
                }
        } else { // sink
                switch (variometer / -5){
                        case 0:
                                write_char_xy(x, y, 0xbc); // smallest arrow down
                                break;
                        case 1:
                                write_char_xy(x, y, 0xbd); // small arrow down
                                break;
                        case 2:
                                write_char_xy(x, y, 0xbe); // large arrow down
                                break;
                        default:
                                write_char_xy(x, y, 0xbf); // largest arrow down
                }
        }
}
 
/**
 * draw a bigger vario with middle at <x>/<y> acording to <variometer>
 */
void draw_big_variometer(uint8_t x, uint8_t y, int16_t variometer) {   
        int16_t index = 7 + variometer;
        if (index > 14) index = 14;
        else if (index < 0) index = 0;
       
        // TODO: why does write_string_pgm_down(x, y-2, vario_pnt[index], 5);
        // not work??? WTF?!
        switch (index) {
                case 0: write_string_pgm_down(x, y-2, vario_pnt[0], 5);
                        break;
                case 1: write_string_pgm_down(x, y-2, vario_pnt[1], 5);
                        break;
                case 2: write_string_pgm_down(x, y-2, vario_pnt[2], 5);
                        break;
                case 3: write_string_pgm_down(x, y-2, vario_pnt[3], 5);
                        break;
                case 4: write_string_pgm_down(x, y-2, vario_pnt[4], 5);
                        break;
                case 5: write_string_pgm_down(x, y-2, vario_pnt[5], 5);
                        break;
                case 6: write_string_pgm_down(x, y-2, vario_pnt[6], 5);
                        break;
                case 7: write_string_pgm_down(x, y-2, vario_pnt[7], 5);
                        break;
                case 8: write_string_pgm_down(x, y-2, vario_pnt[8], 5);
                        break;
                case 9: write_string_pgm_down(x, y-2, vario_pnt[9], 5);
                        break;
                case 10: write_string_pgm_down(x, y-2, vario_pnt[10], 5);
                        break;
                case 11: write_string_pgm_down(x, y-2, vario_pnt[11], 5);
                        break;
                case 12: write_string_pgm_down(x, y-2, vario_pnt[12], 5);
                        break;
                case 13: write_string_pgm_down(x, y-2, vario_pnt[13], 5);
                        break;
                default: write_string_pgm_down(x, y-2, vario_pnt[14], 5);
        }              
}
 
/* ##########################################################################
 * artificial horizon
 * ##########################################################################*/
// remember last time displayed values
int8_t old_af_x = -1, old_af_y = -1;
 
/**
 * draw roll und nick indicators (could be enhanced to full artificial horizon)
 * from line <firstline> to <listlines> for given <nick> and <roll> values
 */
void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {
        char noodle[5] = {225, 225, 226, 227, 227};
        uint8_t center_x = 15;
        uint8_t center_y = lastline - firstline;
        center_y = 7;
        write_char_xy(center_x,center_y,228);
        uint8_t cpos, nicky, rollx;
       
        // which line
        int8_t ypos =  nick / 20;
        // which character from the array?
        if (nick < 0) {
                cpos = -1*((nick - (ypos * 20))/4);
                ypos--;
        } else cpos = 4-((nick - (ypos * 20))/4);
        if (cpos > 4) cpos = 4;
 
        nicky = center_y - ypos;
        if (nicky > lastline) nicky = lastline;
        else if (nicky < firstline) nicky = firstline;
 
        // ensure roll-borders
        rollx = (roll / 8)+15;
        if (rollx < 2) rollx = 2;
        else if (rollx > 28) rollx = 28;
 
 
        // clear roll
        if (old_af_x != rollx && old_af_x >= 0) {
                write_char_xy(old_af_x,13,0);
        }
 
        // clear nick
        if (old_af_y != nicky && old_af_y >= 0) {
                write_char_xy(center_x-1,old_af_y,0);
                write_char_xy(center_x+1,old_af_y,0);
        }
 
 
        // draw nick
        write_char_xy(center_x-1,nicky,noodle[cpos]);
        write_char_xy(center_x+1,nicky,noodle[cpos]);
 
        // draw roll
        write_char_xy(rollx,lastline,229);
 
        // update old vars
        old_af_x = rollx;
        old_af_y = nicky;
 
        // debug numbers
        //write_3digit_number_u(20,6,cpos);
        //write_number_s(20,7,ypos);    
        //write_number_s(0,7,nick);             
        //write_number_s(18,11,roll);   
}
 
/* ##########################################################################
 * A simple config menu for the flags
 * ##########################################################################*/
 
/**
 * helper function for menu updating
 */
void config_menu_drawings(uint8_t chosen) {
    // clear prevoius _cursor_
    write_ascii_string(3, (chosen + 6) % 7, " ");
    // draw current _cursor_
    write_ascii_string(3, chosen + 6, ">");
    if (COSD_FLAGS & COSD_FLAG_HUD) {
        write_ascii_string_pgm(23, 6, ON);
    } else {
                write_ascii_string_pgm(23, 6, OFF);
    }
    if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
        write_ascii_string_pgm(23, 7, ON);
    } else {
        write_ascii_string_pgm(23, 7, OFF);
    }
        if (COSD_FLAGS & COSD_FLAG_STATS) {
        write_ascii_string_pgm(23, 8, ON);
    } else {
        write_ascii_string_pgm(23, 8, OFF);
    }
    if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
        write_ascii_string_pgm(23, 9, ON);
    } else {
        write_ascii_string_pgm(23, 9, OFF);
    }
}
 
/**
 * some sort of clicking response in the menu
 */
void config_menu_doclick(uint8_t chosen, char** menu) {
        write_ascii_string(4, chosen + 6, "DONE              ");
        _delay_ms(1000);
        write_ascii_string(4, chosen + 6, menu[chosen]);
}
 
/**
 * a simple config menu tryout
 */
void config_menu(void) {
        // disable interrupts (makes the menu more smoothely)
        cli();
 
        // clear screen
        clear();
       
        char* menu[8] = {"Full HUD",
                                         "Art.Horizon in HUD",
                                         "Statistics",
                                         "Warnings",    // TODO: do it!
                                         "Reset uptime",
                                         "Request OSD-data",
                                         "Disable Debug-data",
                                         "EXIT"};
 
        uint8_t inmenu = 1;
        uint8_t chosen = 0;
        write_ascii_string(6,  2, "C-OSD Config Menu");
 
        // wait a bit before doing stuff so user has chance to release button
        _delay_ms(250);
 
        write_ascii_string(4,  6, menu[0]);
        write_ascii_string(4,  7, menu[1]);
        write_ascii_string(4,  8, menu[2]);
        write_ascii_string(4,  9, menu[3]);
        write_ascii_string(4, 10, menu[4]);
        write_ascii_string(4, 11, menu[5]);
        write_ascii_string(4, 12, menu[6]);
        write_ascii_string(4, 13, menu[7]);
 
        config_menu_drawings(chosen);
 
        while (inmenu) {
                        if (s2_pressed()) {
                                write_ascii_string(3,  chosen+6, " ");
                                chosen = (chosen + 1) % 8;
                                write_ascii_string(3,  chosen+6, ">");
                                _delay_ms(500);
                        } else if (s1_pressed()) {
                                switch (chosen) {
                                        case 0:         // full HUD
                                                COSD_FLAGS ^= COSD_FLAG_HUD;
                                                config_menu_drawings(chosen);
                                                break;
                                        case 1:         // art horizon
                                                COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;
                                                config_menu_drawings(chosen);
                                                break;
                                        case 2:         // statistics
                                                COSD_FLAGS ^= COSD_FLAG_STATS;
                                                config_menu_drawings(chosen);
                                                break;
                                        case 3:         // warnings
                                                COSD_FLAGS ^= COSD_FLAG_WARNINGS;
                                                config_menu_drawings(chosen);
                                                break;
                                        case 4:         // reset uptime
                                                uptime = 0;
                                                config_menu_doclick(chosen, menu);
                                                break;
                                        case 5:         // re-request OSD data
                                                // request OSD Data from NC every 100ms
                                                usart1_request_mk_data(1, 'o', 100);
                                                config_menu_doclick(chosen, menu);
                                                break;
                                        case 6:         // disable debug data
                                                // disable sending of debug data
                                                // may result in smoother ddata display
                                                usart1_request_mk_data(0, 'd', 0);
                                                config_menu_doclick(chosen, menu);
                                                break;
                                        case 7:         // exit
                                                inmenu = 0;
                                                break;
                                }
                                _delay_ms(250);
                        }
        }
 
        // clear screen up again
        clear();
 
        // update flags to paint display again if needed
        COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
 
        // enable interrupts again
        sei();
}
 
#endif // ends !(ALLCHARSDEBUG|(WRITECHARS != -1))
/* ##########################################################################
 * MAIN
 * ##########################################################################*/
int main(void) {
    // set up FLAGS, compiler should flatten this one
    COSD_FLAGS = (NTSC << 0);
    COSD_FLAGS |= (HUD << 1);
    COSD_FLAGS |= (ARTHORIZON << 2);
        COSD_FLAGS |= (STATS << 3);
    COSD_FLAGS |= (WARNINGS << 4);
 
    // set up Atmega162 Ports
    DDRA |= (1 << PA1); // PA1 output (/CS)
    MAX_CS_HIGH
    DDRA |= (1 << PA2); // PA2 output (SDIN)
    MAX_SDIN_LOW
    DDRA |= (1 << PA3); // PA3 output (SCLK)
    MAX_SCLK_LOW
    DDRA |= (1 << PA5); // PA5 output (RESET)
    MAX_RESET_HIGH
 
    DDRC |= (1 << PC0); // PC0 output (LED1 gn)
    LED1_OFF
    DDRC |= (1 << PC1); // PC1 output (LED2 rt)
    LED2_OFF
    DDRC |= (1 << PC2); // PC2 output (LED3 gn)
    LED3_OFF
    DDRC |= (1 << PC3); // PC3 output (LED4 rt)
    LED4_OFF
 
    DDRC &= ~(1 << PC4); // PC4 input  (MODE)
    PORTC |= (1 << PC4); // pullup
    DDRC &= ~(1 << PC5); // PC5 input  (SET)
    PORTC |= (1 << PC5); // pullup
 
    // set up top and bottom lines
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
        bottom_line = 12;
    } else {
        bottom_line = 14;
    }
 
    // reset the MAX7456 to be sure any undefined states do no harm
    MAX_RESET_LOW
    MAX_RESET_HIGH
 
    // give the FC/NC and the maxim time to come up
    LED4_ON
    _delay_ms(2000);
 
    LED4_OFF
 
 
    //Pushing NEW chars to the MAX7456
#if (WRITECHARS != -1)
    // DISABLE display (VM0)
    spi_send_byte(0x00, 0b00000000);
#include "characters.c"
 
#endif 
 
    // Setup Video Mode
    if (COSD_FLAGS & COSD_FLAG_NTSC) {
        // NTSC + enable display immediately (VM0)
        spi_send_byte(0x00, 0b00001000);
    } else {
        // PAL + enable display immediately (VM0)
        spi_send_byte(0x00, 0b01001000);
    }
 
    // clear all display-mem (DMM)
    spi_send_byte(0x04, 0b00000100);
 
    // clearing takes 12uS according to maxim so lets wait longer
    _delay_us(120);
 
    // 8bit mode
    spi_send_byte(0x04, 0b01000000);
 
    // write blank chars to whole screen
    clear();
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
    // init usart
    usart1_init();
 
    // set up timer
    TCCR0 |= (1 << CS00) | (1 << CS01); // timer0 prescaler 64
    OCR0 = 6; // preload
    TIMSK |= (1 << TOIE0); // enable overflow timer0
 
    // enable interrupts
    sei();
#endif
 
    //write_ascii_string(2,  7, "         CaScAdE          ");
    //write_ascii_string(2,  8, "is TESTING his open source");
    //write_ascii_string(2,  9, "    EPi OSD Firmware");
 
    // custom char preview
    /*write_char_xy( 2, 7, 200);
    write_char_xy( 3, 7, 201);
    write_char_xy( 4, 7, 202);
    write_char_xy( 5, 7, 203);
    write_char_xy( 6, 7, 204);
    write_char_xy( 7, 7, 205);
    write_char_xy( 8, 7, 206);
    write_char_xy( 9, 7, 207);
    write_char_xy(10, 7, 208);
    write_char_xy(11, 7, 209);
    write_char_xy(12, 7, 210);
    write_char_xy(13, 7, 211);
    write_char_xy(14, 7, 212);
    write_char_xy(15, 7, 213);
    write_char_xy(16, 7, 214);
    write_char_xy(17, 7, 215);*/
 
    // we are ready
    LED3_ON
 
 
 
#if ALLCHARSDEBUG | (WRITECHARS != -1)
        clear();
    write_all_chars();
#else
        // clear serial screen
        //usart1_puts("\x1B[2J\x1B[H");
        //usart1_puts("hello world!\r\n");
 
 
        // request data ever 100ms from FC;
        //usart1_request_mk_data(0, 'd', 100);
 
        // request OSD Data from NC every 100ms
        usart1_request_mk_data(1, 'o', 100);
 
    // and disable debug...
        //usart1_request_mk_data(0, 'd', 0);
 
    // disable TXD-pin
    usart1_DisableTXD();
 
    // stats for after flight
    int16_t max_Altimeter = 0;
    uint16_t max_GroundSpeed = 0;
    int16_t max_Distance = 0;
    uint8_t min_UBat = 255;
    uint16_t max_FlyingTime = 0;
 
    // flags from last round to check for changes
    uint8_t old_MKFlags = 0;
 
    char* directions[8] = {"NE", "E ", "SE", "S ", "SW", "W ", "NW", "N "};
    //char arrowdir[8] = {218, 217, 224, 223, 222, 221, 220, 219};
 
        /*write_ndigit_number_s_10th(5, 10, 1, 100, 0);
        write_ndigit_number_s_10th(5, 11, -1, 100, 0);
        write_ndigit_number_s_10th(5, 12, -11, 100, 0);*/
 
        //write_ndigit_number_u(2,2, heading_fine_conv(45), 100, 0);
 
    while (1) {
        // write icons at init or after menu/mode-switch
        if (!(COSD_FLAGS & COSD_ICONS_WRITTEN) && (COSD_FLAGS & COSD_FLAG_HUD)) {
            write_char_xy(5, top_line, 203); // km/h
            write_char_xy(10, top_line, 202); // RC-transmitter
            write_char_xy(16, top_line, 208); // degree symbol
            write_char_xy(27, top_line, 204); // small meters m
            //write_ascii_string(6, bottom_line, "V"); // voltage
            write_char_xy(14, bottom_line, 209); // on clock
            write_char_xy(22, bottom_line, 210); // fly clock
            write_char_xy(26, bottom_line, 200); // sat1
            write_char_xy(27, bottom_line, 201); // sat2
            COSD_FLAGS |= COSD_ICONS_WRITTEN;
        }
        if (rxd_buffer_locked) {
            if (COSD_FLAGS & COSD_FLAG_HUD) {
                if (rxd_buffer[2] == 'D') { // FC Data
                    /*Decode64();
                    debugData = *((DebugOut_t*) pRxData);
                    write_number_s(12, 2, RxDataLen);
                    write_number_s(20, 2, setsReceived++);
                    write_number_s(12, 3, debugData.Analog[0]); // AngleNick
                    write_number_s(12, 4, debugData.Analog[1]); // AngleRoll
                                        write_number_s(12, 5, debugData.Analog[5]); // Height
                    write_number_s(12, 6, debugData.Analog[9]); // Voltage
                    write_number_s(12, 7, debugData.Analog[10]);// RC Signal
                                        write_number_s(12, 8, debugData.Analog[11]);// Gyro compass*/
                } else if (rxd_buffer[2] == 'O') { // NC OSD Data
                    Decode64();
                    naviData = *((NaviData_t*) pRxData);
 
                                        draw_big_variometer(27, 8, naviData.Variometer);
 
                    // first line
                    write_ndigit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * (uint32_t)9) / (uint32_t)250), 100, 0);
 
                    write_ndigit_number_u(7, top_line, naviData.RC_Quality, 100, 0);
                    if (naviData.RC_Quality <= 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 (naviData.RC_Quality > RCLVL_WRN && last_RC_Quality <= RCLVL_WRN) {
                        for (uint8_t x = 0; x < 4; x++)
                            write_char_att_xy(7 + x, top_line, 0);
                    }
                    last_RC_Quality = naviData.RC_Quality;
 
                    write_ndigit_number_u(13, top_line, naviData.CompassHeading, 100, 0);
 
                    write_ascii_string(17, top_line, directions[heading_conv(naviData.CompassHeading)]);
                                       
                                        draw_variometer(20, top_line, naviData.Variometer);
 
                    //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, 1000, 0);
                    } else {
                        // up to 10m write meters.dm
                        //write_number_u_10th(21, top_line, naviData.Altimeter / 3);
                                                write_ndigit_number_s_10th(23, top_line, naviData.Altimeter / 3, 100, 0);
                    }
 
                    // 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(27, 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(27, top_line + 1, 0xa0 + heading_fine_conv(heading_home));
 
                    write_ndigit_number_u(24, top_line + 1, naviData.HomePositionDeviation.Distance / 10, 100, 0);
 
                    // center
                    if (naviData.MKFlags & FLAG_MOTOR_RUN) { // should be engines running
                        if (!(old_MKFlags & FLAG_MOTOR_RUN)) { // motors just started, clear middle
                            clear();
                            // update flags to paint display again if needed
                            COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
                        }
                        if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
                        }
                    } else {
                                                // stats
                                                if (COSD_FLAGS & COSD_FLAG_STATS) {
                                                        write_ascii_string_pgm(2, 5, stats_item_pointers[0]); // max Altitude
                                write_ndigit_number_s(18, 5, max_Altimeter / 30, 1000, 0);
                                write_char_xy(22, 5, 204); // small meters m
                                                        write_ascii_string_pgm(2, 6, stats_item_pointers[1]); // max Speed
                                write_ndigit_number_u(19, 6, (uint16_t) (((uint32_t) max_GroundSpeed * 36) / 1000), 100, 0);
                                write_char_xy(22, 6, 203); // km/h
                                                        write_ascii_string_pgm(2, 7, stats_item_pointers[2]); // max Distance
                                write_ndigit_number_u(19, 7, max_Distance / 100, 100, 0);
                                write_char_xy(22, 7, 204); // small meters m
                                                        write_ascii_string_pgm(2, 8, stats_item_pointers[3]); // min voltage
                                                        write_ndigit_number_u_10th(18, 8, min_UBat, 100, 0);
                                write_ascii_string(22, 8, "V"); // voltage
                                                        write_ascii_string_pgm(2, 9, stats_item_pointers[4]); // max time
                                write_time(16, 9, max_FlyingTime);
                                write_char_xy(22, 9, 210); // fly clock
                                                } else if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) { // if no stats there is space horizon
                            draw_artificial_horizon(top_line + 2, bottom_line - 1, naviData.AngleNick, naviData.AngleRoll);
                        }
                    }
 
                    // bottom line
                                        write_ndigit_number_u_10th(2, bottom_line, naviData.UBat, 100, 0);
                    if (naviData.UBat <= UBAT_WRN && last_UBat > UBAT_WRN) {
                        for (uint8_t x = 0; x < 7; x++)
                            write_char_att_xy(x, bottom_line, BLINK);
                    } else {
                        for (uint8_t x = 0; x < 7; x++)
                            write_char_att_xy(x, bottom_line, 0);
                    }
                                        draw_battery(6, bottom_line, naviData.UBat);
 
                    write_time(8, bottom_line, uptime);
                    write_time(16, bottom_line, naviData.FlyingTime);
 
                    write_ndigit_number_u(24, bottom_line, naviData.SatsInUse, 10, 0);
 
                    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
                    if (naviData.Altimeter > max_Altimeter) max_Altimeter = naviData.Altimeter;
                    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;
 
                    old_MKFlags = naviData.MKFlags;
                }
            }
            seconds_since_last_data = 0;
            rxd_buffer_locked = 0;
        }
        // handle keypress
        if (s1_pressed()) {
            config_menu();
        }
        if (seconds_since_last_data > 2) {
                        // request OSD Data from NC every 100ms
                        usart1_request_mk_data(1, 'o', 100);
                        seconds_since_last_data = 0;
        }
    }
#endif
    return 0;
}
 

Rev 378	Rev 379
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, stats_item_3, stats_item_4};	72	char* stats_item_pointers[] PROGMEM = {stats_item_0, stats_item_1, stats_item_2,
-		73	stats_item_3, stats_item_4};
73		74
74	// store more fixed strings in progmen	75	// store more fixed strings in progmen
75	char ON[] PROGMEM = "ON ";	76	char ON[] PROGMEM = "ON ";
76	char OFF[] PROGMEM = "OFF";	77	char OFF[] PROGMEM = "OFF";
-		78
-		79	// big vario arrays
-		80	char vario_00[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xff};
-		81	char vario_01[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc0};
-		82	char vario_02[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0xc1};
-		83	char vario_03[5] PROGMEM = {0x00, 0x00, 0xc2, 0xff, 0x00};
-		84	char vario_04[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc0, 0x00};
-		85	char vario_05[5] PROGMEM = {0x00, 0x00, 0xc2, 0xc1, 0x00};
-		86	char vario_06[5] PROGMEM = {0x00, 0x00, 0xc2, 0x00, 0x00};
-		87	char vario_07[5] PROGMEM = {0x00, 0x00, 0xbb, 0x00, 0x00};
-		88	char vario_08[5] PROGMEM = {0x00, 0x00, 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};
-		91	char vario_11[5] PROGMEM = {0x00, 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};
-		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,
-		96	vario_05, vario_06, vario_07, vario_08,
-		97	vario_09, vario_10, vario_11, vario_12,
-		98	vario_13, vario_14};
77		99
78	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))	100	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))
79		101
80	// general PAL\|NTSC distingiusch stuff	102	// general PAL\|NTSC distingiusch stuff
81	uint8_t top_line = 1;	103	uint8_t top_line = 1;
82	uint8_t bottom_line = 14;	104	uint8_t bottom_line = 14;
83		105
84	// Flags	106	// Flags
85	uint8_t COSD_FLAGS = 0;	107	uint8_t COSD_FLAGS = 0;
86		108
87	/* ##########################################################################	109	/* ##########################################################################
88	* debounce buttons	110	* debounce buttons
89	* ##########################################################################*/	111	* ##########################################################################*/
90	int s1_pressed() {	112	int s1_pressed() {
91	if (S1_PRESSED) {	113	if (S1_PRESSED) {
92	_delay_ms(25);	114	_delay_ms(25);
93	if (S1_PRESSED) return 1;	115	if (S1_PRESSED) return 1;
94	}	116	}
95	return 0;	117	return 0;
96	}	118	}
97		119
98	int s2_pressed() {	120	int s2_pressed() {
99	if (S2_PRESSED) {	121	if (S2_PRESSED) {
100	_delay_ms(25);	122	_delay_ms(25);
101	if (S2_PRESSED) return 1;	123	if (S2_PRESSED) return 1;
102	}	124	}
103	return 0;	125	return 0;
104	}	126	}
105		127
106		128
107	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))	129	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
108		130
109	/**	131	/**
110	* serial support	132	* serial support
111	*/	133	*/
112	//#include "usart1.c"	134	//#include "usart1.c"
113		135
114		136
115	/* ##########################################################################	137	/* ##########################################################################
116	* timer stuff	138	* timer stuff
117	* ##########################################################################*/	139	* ##########################################################################*/
118		140
119	/**	141	/**
120	* timer kicks in every 1000uS ^= 1ms	142	* timer kicks in every 1000uS ^= 1ms
121	*/	143	*/
122	ISR(TIMER0_OVF_vect) {	144	ISR(TIMER0_OVF_vect) {
123	OCR0 = 6; // preload	145	OCR0 = 6; // preload
124	if (!timer--) {	146	if (!timer--) {
125	uptime++;	147	uptime++;
126	timer = 999;	148	timer = 999;
127	seconds_since_last_data++;	149	seconds_since_last_data++;
128	}	150	}
129	}	151	}
130		152
131	/* ##########################################################################	153	/* ##########################################################################
132	* compass stuff	154	* compass stuff
133	* ##########################################################################*/	155	* ##########################################################################*/
134		156
135	/**	157	/**
136	* convert the <heading> gotton from NC into an index	158	* convert the <heading> gotton from NC into an index
137	*/	159	*/
138	uint8_t heading_conv(uint16_t heading) {	160	uint8_t heading_conv(uint16_t heading) {
139	if (heading > 23 && heading < 68) {	161	if (heading > 23 && heading < 68) {
140	//direction = "NE";	162	//direction = "NE";
141	return 0;	163	return 0;
142	} else if (heading > 67 && heading < 113) {	164	} else if (heading > 67 && heading < 113) {
143	//direction = "E ";	165	//direction = "E ";
144	return 1;	166	return 1;
145	} else if (heading > 112 && heading < 158) {	167	} else if (heading > 112 && heading < 158) {
146	//direction = "SE";	168	//direction = "SE";
147	return 2;	169	return 2;
148	} else if (heading > 157 && heading < 203) {	170	} else if (heading > 157 && heading < 203) {
149	//direction = "S ";	171	//direction = "S ";
150	return 3;	172	return 3;
151	} else if (heading > 202 && heading < 248) {	173	} else if (heading > 202 && heading < 248) {
152	//direction = "SW";	174	//direction = "SW";
153	return 4;	175	return 4;
154	} else if (heading > 247 && heading < 293) {	176	} else if (heading > 247 && heading < 293) {
155	//direction = "W ";	177	//direction = "W ";
156	return 5;	178	return 5;
157	} else if (heading > 292 && heading < 338) {	179	} else if (heading > 292 && heading < 338) {
158	//direction = "NW";	180	//direction = "NW";
159	return 6;	181	return 6;
160	}	182	}
161	//direction = "N ";	183	//direction = "N ";
162	return 7;	184	return 7;
163	}	185	}
164		186
165	/**	187	/**
166	* convert the <heading> gotton from NC into a more	188	* convert the <heading> gotton from NC into a more
167	* precise index	189	* precise index
168	*/	190	*/
169	uint8_t heading_fine_conv(uint16_t heading) {	191	uint8_t heading_fine_conv(uint16_t heading) {
170	if (heading > 337) return 0;	192	if (heading > 337) return 0;
171	return (heading * 10) / 225;	193	return (heading * 10) / 225;
172	}	194	}
173		195
174	/**	196	/**
175	* draw a compass rose at <x>/<y> for <heading>	197	* draw a compass rose at <x>/<y> for <heading>
176	*/	198	*/
177	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) {
178	//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";
179	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,
180	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,
181	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,
182	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};
183	// 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
184	// 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
185	// 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
186	uint8_t front = 19 + (heading / 22);	208	uint8_t front = 19 + (heading / 22);
187	for (uint8_t i = 0; i < 9; i++) {	209	for (uint8_t i = 0; i < 9; i++) {
188	write_char_xy(x++, y, rose[front - 4 + i]);	210	write_char_xy(x++, y, rose[front - 4 + i]);
189	}	211	}
190	}	212	}
191		213
192	/* ##########################################################################	214	/* ##########################################################################
193	* battery index	215	* battery index
194	* ##########################################################################*/	216	* ##########################################################################*/
195	/**	217	/**
196	* draw a battery symbol at <x>/<y> according to <voltage>	218	* draw a battery symbol at <x>/<y> according to <voltage>
197	*/	219	*/
198	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) {
199	uint8_t percent = (100* (voltage - UBAT_WRN) / (UBAT_MAX - UBAT_WRN));	221	uint8_t percent = (100* (voltage - UBAT_WRN) / (UBAT_MAX - UBAT_WRN));
200	if (percent > 100) percent = 100;	222	if (percent > 100) percent = 100;
201	if (voltage < UBAT_WRN) percent = 0;	223	if (voltage < UBAT_WRN) percent = 0;
202	write_char_xy(x, y, 0x9d - (percent * 13 / 100));	224	write_char_xy(x, y, 0x9d - (percent * 13 / 100));
203	//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);
204	}	226	}
-		227
-		228	/* ##########################################################################
-		229	* variometer
205		230	* ##########################################################################*/
206	/**	231	/**
207	* draw variometer arrows at <x>/<y> according to <variometer>	232	* draw variometer arrows at <x>/<y> according to <variometer>
208	*/	233	*/
209	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) {
210	if (variometer == 0) {	235	if (variometer == 0) {
211	write_char_xy(x, y, 0xbb); // plain line	236	write_char_xy(x, y, 0xbb); // plain line
212	} else if (variometer > 0) { // gain height	237	} else if (variometer > 0) { // gain height
213	switch (variometer / 5){	238	switch (variometer / 5){
214	case 0:	239	case 0:
215	write_char_xy(x, y, 0xba); // smallest arrow up	240	write_char_xy(x, y, 0xba); // smallest arrow up
216	break;	241	break;
217	case 1:	242	case 1:
218	write_char_xy(x, y, 0xb9); // small arrow up	243	write_char_xy(x, y, 0xb9); // small arrow up
219	break;	244	break;
220	case 2:	245	case 2:
221	write_char_xy(x, y, 0xb8); // large arrow up	246	write_char_xy(x, y, 0xb8); // large arrow up
222	break;	247	break;
223	default:	248	default:
224	write_char_xy(x, y, 0xb7); // largest arrow up	249	write_char_xy(x, y, 0xb7); // largest arrow up
225	}	250	}
226	} else { // sink	251	} else { // sink
227	switch (variometer / -5){	252	switch (variometer / -5){
228	case 0:	253	case 0:
229	write_char_xy(x, y, 0xbc); // smallest arrow down	254	write_char_xy(x, y, 0xbc); // smallest arrow down
230	break;	255	break;
231	case 1:	256	case 1:
232	write_char_xy(x, y, 0xbd); // small arrow down	257	write_char_xy(x, y, 0xbd); // small arrow down
233	break;	258	break;
234	case 2:	259	case 2:
235	write_char_xy(x, y, 0xbe); // large arrow down	260	write_char_xy(x, y, 0xbe); // large arrow down
236	break;	261	break;
237	default:	262	default:
238	write_char_xy(x, y, 0xbf); // largest arrow down	263	write_char_xy(x, y, 0xbf); // largest arrow down
239	}	264	}
240	}	265	}
241	}	266	}
-		267
-		268	/**
-		269	* draw a bigger vario with middle at <x>/<y> acording to <variometer>
-		270	*/
-		271	void draw_big_variometer(uint8_t x, uint8_t y, int16_t variometer) {
-		272	int16_t index = 7 + variometer;
-		273	if (index > 14) index = 14;
-		274	else if (index < 0) index = 0;
-		275
-		276	// TODO: why does write_string_pgm_down(x, y-2, vario_pnt[index], 5);
-		277	// not work??? WTF?!
-		278	switch (index) {
-		279	case 0: write_string_pgm_down(x, y-2, vario_pnt[0], 5);
-		280	break;
-		281	case 1: write_string_pgm_down(x, y-2, vario_pnt[1], 5);
-		282	break;
-		283	case 2: write_string_pgm_down(x, y-2, vario_pnt[2], 5);
-		284	break;
-		285	case 3: write_string_pgm_down(x, y-2, vario_pnt[3], 5);
-		286	break;
-		287	case 4: write_string_pgm_down(x, y-2, vario_pnt[4], 5);
-		288	break;
-		289	case 5: write_string_pgm_down(x, y-2, vario_pnt[5], 5);
-		290	break;
-		291	case 6: write_string_pgm_down(x, y-2, vario_pnt[6], 5);
-		292	break;
-		293	case 7: write_string_pgm_down(x, y-2, vario_pnt[7], 5);
-		294	break;
-		295	case 8: write_string_pgm_down(x, y-2, vario_pnt[8], 5);
-		296	break;
-		297	case 9: write_string_pgm_down(x, y-2, vario_pnt[9], 5);
-		298	break;
-		299	case 10: write_string_pgm_down(x, y-2, vario_pnt[10], 5);
-		300	break;
-		301	case 11: write_string_pgm_down(x, y-2, vario_pnt[11], 5);
-		302	break;
-		303	case 12: write_string_pgm_down(x, y-2, vario_pnt[12], 5);
-		304	break;
-		305	case 13: write_string_pgm_down(x, y-2, vario_pnt[13], 5);
-		306	break;
-		307	default: write_string_pgm_down(x, y-2, vario_pnt[14], 5);
-		308	}
-		309	}
242		310
243	/* ##########################################################################	311	/* ##########################################################################
244	* artificial horizon	312	* artificial horizon
245	* ##########################################################################*/	313	* ##########################################################################*/
246	// remember last time displayed values	314	// remember last time displayed values
247	int8_t old_af_x = -1, old_af_y = -1;	315	int8_t old_af_x = -1, old_af_y = -1;
248		316
249	/**	317	/**
250	* draw roll und nick indicators (could be enhanced to full artificial horizon)	318	* draw roll und nick indicators (could be enhanced to full artificial horizon)
251	* from line <firstline> to <listlines> for given <nick> and <roll> values	319	* from line <firstline> to <listlines> for given <nick> and <roll> values
252	*/	320	*/
253	void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {	321	void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {
254	char noodle[5] = {225, 225, 226, 227, 227};	322	char noodle[5] = {225, 225, 226, 227, 227};
255	uint8_t center_x = 15;	323	uint8_t center_x = 15;
256	uint8_t center_y = lastline - firstline;	324	uint8_t center_y = lastline - firstline;
257	center_y = 7;	325	center_y = 7;
258	write_char_xy(center_x,center_y,228);	326	write_char_xy(center_x,center_y,228);
259	uint8_t cpos, nicky, rollx;	327	uint8_t cpos, nicky, rollx;
260		328
261	// which line	329	// which line
262	int8_t ypos = nick / 20;	330	int8_t ypos = nick / 20;
263	// which character from the array?	331	// which character from the array?
264	if (nick < 0) {	332	if (nick < 0) {
265	cpos = -1((nick - (ypos 20))/4);	333	cpos = -1((nick - (ypos 20))/4);
266	ypos--;	334	ypos--;
267	} else cpos = 4-((nick - (ypos * 20))/4);	335	} else cpos = 4-((nick - (ypos * 20))/4);
268	if (cpos > 4) cpos = 4;	336	if (cpos > 4) cpos = 4;
269		337
270	nicky = center_y - ypos;	338	nicky = center_y - ypos;
271	if (nicky > lastline) nicky = lastline;	339	if (nicky > lastline) nicky = lastline;
272	else if (nicky < firstline) nicky = firstline;	340	else if (nicky < firstline) nicky = firstline;
273		341
274	// ensure roll-borders	342	// ensure roll-borders
275	rollx = (roll / 8)+15;	343	rollx = (roll / 8)+15;
276	if (rollx < 2) rollx = 2;	344	if (rollx < 2) rollx = 2;
277	else if (rollx > 28) rollx = 28;	345	else if (rollx > 28) rollx = 28;
278		346
279		347
280	// clear roll	348	// clear roll
281	if (old_af_x != rollx && old_af_x >= 0) {	349	if (old_af_x != rollx && old_af_x >= 0) {
282	write_char_xy(old_af_x,13,0);	350	write_char_xy(old_af_x,13,0);
283	}	351	}
284		352
285	// clear nick	353	// clear nick
286	if (old_af_y != nicky && old_af_y >= 0) {	354	if (old_af_y != nicky && old_af_y >= 0) {
287	write_char_xy(center_x-1,old_af_y,0);	355	write_char_xy(center_x-1,old_af_y,0);
288	write_char_xy(center_x+1,old_af_y,0);	356	write_char_xy(center_x+1,old_af_y,0);
289	}	357	}
290		358
291		359
292	// draw nick	360	// draw nick
293	write_char_xy(center_x-1,nicky,noodle[cpos]);	361	write_char_xy(center_x-1,nicky,noodle[cpos]);
294	write_char_xy(center_x+1,nicky,noodle[cpos]);	362	write_char_xy(center_x+1,nicky,noodle[cpos]);
295		363
296	// draw roll	364	// draw roll
297	write_char_xy(rollx,lastline,229);	365	write_char_xy(rollx,lastline,229);
298		366
299	// update old vars	367	// update old vars
300	old_af_x = rollx;	368	old_af_x = rollx;
301	old_af_y = nicky;	369	old_af_y = nicky;
302		370
303	// debug numbers	371	// debug numbers
304	//write_3digit_number_u(20,6,cpos);	372	//write_3digit_number_u(20,6,cpos);
305	//write_number_s(20,7,ypos);	373	//write_number_s(20,7,ypos);
306	//write_number_s(0,7,nick);	374	//write_number_s(0,7,nick);
307	//write_number_s(18,11,roll);	375	//write_number_s(18,11,roll);
308	}	376	}
309		377
310	/* ##########################################################################	378	/* ##########################################################################
311	* A simple config menu for the flags	379	* A simple config menu for the flags
312	* ##########################################################################*/	380	* ##########################################################################*/
313		381
314	/**	382	/**
315	* helper function for menu updating	383	* helper function for menu updating
316	*/	384	*/
317	void config_menu_drawings(uint8_t chosen) {	385	void config_menu_drawings(uint8_t chosen) {
318	// clear prevoius _cursor_	386	// clear prevoius _cursor_
319	write_ascii_string(3, (chosen + 6) % 7, " ");	387	write_ascii_string(3, (chosen + 6) % 7, " ");
320	// draw current _cursor_	388	// draw current _cursor_
321	write_ascii_string(3, chosen + 6, ">");	389	write_ascii_string(3, chosen + 6, ">");
322	if (COSD_FLAGS & COSD_FLAG_HUD) {	390	if (COSD_FLAGS & COSD_FLAG_HUD) {
323	write_ascii_string_pgm(23, 6, ON);	391	write_ascii_string_pgm(23, 6, ON);
324	} else {	392	} else {
325	write_ascii_string_pgm(23, 6, OFF);	393	write_ascii_string_pgm(23, 6, OFF);
326	}	394	}
327	if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {	395	if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
328	write_ascii_string_pgm(23, 7, ON);	396	write_ascii_string_pgm(23, 7, ON);
329	} else {	397	} else {
330	write_ascii_string_pgm(23, 7, OFF);	398	write_ascii_string_pgm(23, 7, OFF);
331	}	399	}
332	if (COSD_FLAGS & COSD_FLAG_STATS) {	400	if (COSD_FLAGS & COSD_FLAG_STATS) {
333	write_ascii_string_pgm(23, 8, ON);	401	write_ascii_string_pgm(23, 8, ON);
334	} else {	402	} else {
335	write_ascii_string_pgm(23, 8, OFF);	403	write_ascii_string_pgm(23, 8, OFF);
336	}	404	}
337	if (COSD_FLAGS & COSD_FLAG_WARNINGS) {	405	if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
338	write_ascii_string_pgm(23, 9, ON);	406	write_ascii_string_pgm(23, 9, ON);
339	} else {	407	} else {
340	write_ascii_string_pgm(23, 9, OFF);	408	write_ascii_string_pgm(23, 9, OFF);
341	}	409	}
342	}	410	}
343		411
344	/**	412	/**
345	* some sort of clicking response in the menu	413	* some sort of clicking response in the menu
346	*/	414	*/
347	void config_menu_doclick(uint8_t chosen, char** menu) {	415	void config_menu_doclick(uint8_t chosen, char** menu) {
348	write_ascii_string(4, chosen + 6, "DONE ");	416	write_ascii_string(4, chosen + 6, "DONE ");
349	_delay_ms(1000);	417	_delay_ms(1000);
350	write_ascii_string(4, chosen + 6, menu[chosen]);	418	write_ascii_string(4, chosen + 6, menu[chosen]);
351	}	419	}
352		420
353	/**	421	/**
354	* a simple config menu tryout	422	* a simple config menu tryout
355	*/	423	*/
356	void config_menu(void) {	424	void config_menu(void) {
357	// disable interrupts (makes the menu more smoothely)	425	// disable interrupts (makes the menu more smoothely)
358	cli();	426	cli();
359		427
360	// clear screen	428	// clear screen
361	clear();	429	clear();
362		430
363	char* menu[8] = {"Full HUD",	431	char* menu[8] = {"Full HUD",
364	"Art.Horizon in HUD",	432	"Art.Horizon in HUD",
365	"Statistics",	433	"Statistics",
366	"Warnings", // TODO: do it!	434	"Warnings", // TODO: do it!
367	"Reset uptime",	435	"Reset uptime",
368	"Request OSD-data",	436	"Request OSD-data",
369	"Disable Debug-data",	437	"Disable Debug-data",
370	"EXIT"};	438	"EXIT"};
371		439
372	uint8_t inmenu = 1;	440	uint8_t inmenu = 1;
373	uint8_t chosen = 0;	441	uint8_t chosen = 0;
374	write_ascii_string(6, 2, "C-OSD Config Menu");	442	write_ascii_string(6, 2, "C-OSD Config Menu");
375		443
376	// wait a bit before doing stuff so user has chance to release button	444	// wait a bit before doing stuff so user has chance to release button
377	_delay_ms(250);	445	_delay_ms(250);
378		446
379	write_ascii_string(4, 6, menu[0]);	447	write_ascii_string(4, 6, menu[0]);
380	write_ascii_string(4, 7, menu[1]);	448	write_ascii_string(4, 7, menu[1]);
381	write_ascii_string(4, 8, menu[2]);	449	write_ascii_string(4, 8, menu[2]);
382	write_ascii_string(4, 9, menu[3]);	450	write_ascii_string(4, 9, menu[3]);
383	write_ascii_string(4, 10, menu[4]);	451	write_ascii_string(4, 10, menu[4]);
384	write_ascii_string(4, 11, menu[5]);	452	write_ascii_string(4, 11, menu[5]);
385	write_ascii_string(4, 12, menu[6]);	453	write_ascii_string(4, 12, menu[6]);
386	write_ascii_string(4, 13, menu[7]);	454	write_ascii_string(4, 13, menu[7]);
387		455
388	config_menu_drawings(chosen);	456	config_menu_drawings(chosen);
389		457
390	while (inmenu) {	458	while (inmenu) {
391	if (s2_pressed()) {	459	if (s2_pressed()) {
392	write_ascii_string(3, chosen+6, " ");	460	write_ascii_string(3, chosen+6, " ");
393	chosen = (chosen + 1) % 8;	461	chosen = (chosen + 1) % 8;
394	write_ascii_string(3, chosen+6, ">");	462	write_ascii_string(3, chosen+6, ">");
395	_delay_ms(500);	463	_delay_ms(500);
396	} else if (s1_pressed()) {	464	} else if (s1_pressed()) {
397	switch (chosen) {	465	switch (chosen) {
398	case 0: // full HUD	466	case 0: // full HUD
399	COSD_FLAGS ^= COSD_FLAG_HUD;	467	COSD_FLAGS ^= COSD_FLAG_HUD;
400	config_menu_drawings(chosen);	468	config_menu_drawings(chosen);
401	break;	469	break;
402	case 1: // art horizon	470	case 1: // art horizon
403	COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;	471	COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;
404	config_menu_drawings(chosen);	472	config_menu_drawings(chosen);
405	break;	473	break;
406	case 2: // statistics	474	case 2: // statistics
407	COSD_FLAGS ^= COSD_FLAG_STATS;	475	COSD_FLAGS ^= COSD_FLAG_STATS;
408	config_menu_drawings(chosen);	476	config_menu_drawings(chosen);
409	break;	477	break;
410	case 3: // warnings	478	case 3: // warnings
411	COSD_FLAGS ^= COSD_FLAG_WARNINGS;	479	COSD_FLAGS ^= COSD_FLAG_WARNINGS;
412	config_menu_drawings(chosen);	480	config_menu_drawings(chosen);
413	break;	481	break;
414	case 4: // reset uptime	482	case 4: // reset uptime
415	uptime = 0;	483	uptime = 0;
416	config_menu_doclick(chosen, menu);	484	config_menu_doclick(chosen, menu);
417	break;	485	break;
418	case 5: // re-request OSD data	486	case 5: // re-request OSD data
419	// request OSD Data from NC every 100ms	487	// request OSD Data from NC every 100ms
420	usart1_request_mk_data(1, 'o', 100);	488	usart1_request_mk_data(1, 'o', 100);
421	config_menu_doclick(chosen, menu);	489	config_menu_doclick(chosen, menu);
422	break;	490	break;
423	case 6: // disable debug data	491	case 6: // disable debug data
424	// disable sending of debug data	492	// disable sending of debug data
425	// may result in smoother ddata display	493	// may result in smoother ddata display
426	usart1_request_mk_data(0, 'd', 0);	494	usart1_request_mk_data(0, 'd', 0);
427	config_menu_doclick(chosen, menu);	495	config_menu_doclick(chosen, menu);
428	break;	496	break;
429	case 7: // exit	497	case 7: // exit
430	inmenu = 0;	498	inmenu = 0;
431	break;	499	break;
432	}	500	}

Subversion Repositories Projects

(root)/C-OSD/trunk/main.c - Rev 378 → 379