WebSVN - Projects - Diff - Rev 373 and 377


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

Subversion Repositories Projects

(root)/C-OSD/trunk/main.c @ 406 - Rev 373 → 377