WebSVN - Projects - Diff - Rev 339 and 344


/****************************************************************************
 *   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 "max7456_software_spi.c"
#include "usart1.h"
 
/* TODO:
 * - verifiy correctness of values
 * - clean up code :)
 */
 
/* ##########################################################################
 * Debugging and general purpose definitions
 * ##########################################################################*/
#define ALLCHARSDEBUG 0         // set to 1 and flash firmware to see all chars
 
#ifndef WRITECHARS                      // if WRITECHARS not set via makefile
#define WRITECHARS -1           // set to 2XX and flash firmware to write new char
                                                        // enables the allchars as well to see results
#endif
 
#ifndef NTSC                            // if NTSC is not thet via makefile
#define NTSC 0                          // set to 1 for NTSC mode + lifts the bottom line
#endif
 
#define HUD 1                           // set to 0 to disable HUD by default
#define ARTHORIZON 0            // set to 1 to enable roll&nick artificial horizon by default
#define STATS 1                         // set to 1 to enable statistics during motor off by default
#define WARNINGS 1                      // set to 1 to display battery+rc warning even if HUD is disabled
 
#define UBAT_WRN 94                     // voltage for blinking warning, like FC settings
#define RCLVL_WRN 100           // make the RC level blink if below this number
 
// ### read datasheet before changing stuff below this line :)
#define BLINK   0b01001111      // attribute byte for blinking chars
 
/* ##########################################################################
 * FLAGS usable during runtime
 * ##########################################################################*/
#define COSD_FLAG_NTSC                   1
#define COSD_FLAG_HUD                    2
#define COSD_FLAG_ARTHORIZON     4
#define COSD_FLAG_STATS                  8
#define COSD_FLAG_WARNINGS              16
#define COSD_ICONS_WRITTEN              32
 
/* ##########################################################################
 * LED controll
 * ##########################################################################*/
#define LED1_ON                 PORTC |=  (1 << PC0);
#define LED1_OFF                PORTC &= ~(1 << PC0);
#define LED2_ON                 PORTC |=  (1 << PC1);
#define LED2_OFF                PORTC &= ~(1 << PC1);
#define LED3_ON                 PORTC |=  (1 << PC2);
#define LED3_OFF                PORTC &= ~(1 << PC2);
#define LED4_ON                 PORTC |=  (1 << PC3);
#define LED4_OFF                PORTC &= ~(1 << PC3);
 
/* ##########################################################################
 * switch controll
 * ##########################################################################*/
#define S1_PRESSED              !(PINC & (1<<PC5))
#define S2_PRESSED              !(PINC & (1<<PC4))
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
// data structs
#include "mk-data-structs.h"
 
/* ##########################################################################
 * global definitions and global vars
 * ##########################################################################*/
volatile uint8_t rxd_buffer_locked = 0;
volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
volatile uint8_t ReceivedBytes = 0;
volatile uint8_t *pRxData = 0;
volatile uint8_t RxDataLen = 0;
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;
 
#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;
}
 
/**
 * 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]);
    }
}
 
/* ##########################################################################
 * 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 + 4) % 5, " ");
    // draw current _cursor_
    write_ascii_string(3, chosen + 6, ">");
    if (COSD_FLAGS & COSD_FLAG_HUD) {
        write_ascii_string(23, 6, "ON ");
    } else {
        write_ascii_string(23, 6, "OFF");
    }
    if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
        write_ascii_string(23, 7, "ON ");
    } else {
        write_ascii_string(23, 7, "OFF");
    }
        if (COSD_FLAGS & COSD_FLAG_STATS) {
        write_ascii_string(23, 8, "ON ");
    } else {
        write_ascii_string(23, 8, "OFF");
    }
    if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
        write_ascii_string(23, 9, "ON ");
    } else {
        write_ascii_string(23, 9, "OFF");
    }
}
 
/**
 * a simple config menu tryout
 */
void config_menu(void) {
        // disable interrupts (makes the menu more smoothely)
        cli();
 
        // clear screen
        clear();
       
        char* menu[5] = {"Full HUD",
                                         "Art.Horizon in HUD",
                                         "Statistics",
                                         "Warnings",    // TODO: do it!
                                         "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]);
 
        config_menu_drawings(chosen);
 
        while (inmenu) {
                        if (s2_pressed()) {
                                write_ascii_string(3,  chosen+6, " ");
                                chosen = (chosen + 1) % 5;
                                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:         // 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
        //unsigned char ms = 10;
        //sendMKData('d', 0, &ms, 1);
 
        // request OSD Data from NC every 100ms
        unsigned char ms = 10;
    sendMKData('o', 1, &ms, 1);
    // and disable debug...
    //ms = 0;
    //sendMKData('d', 0, &ms, 1);
 
    // 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};
 
    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_3digit_number_u(2, top_line, (uint16_t) (((uint32_t) naviData.GroundSpeed * 36) / 1000));
 
                    write_3digit_number_u(7, top_line, naviData.RC_Quality);
                    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_3digit_number_u(13, top_line, naviData.CompassHeading);
 
                    write_ascii_string(17, top_line, directions[heading_conv(naviData.CompassHeading)]);
 
                    if (naviData.Variometer == 0) {
                        write_char_xy(20, top_line, 206); // plain line
                    } else if (naviData.Variometer > 0 && naviData.Variometer <= 10) {
                        write_char_xy(20, top_line, 234); // small arrow up
                    } else if (naviData.Variometer > 10) {
                        write_char_xy(20, top_line, 235); // big arrow up
                    } else if (naviData.Variometer < 0 && naviData.Variometer >= -10) {
                        write_char_xy(20, top_line, 232); // small arrow down
                    } else {
                        write_char_xy(20, top_line, 233); //big arrow down
                    }
 
                    //note:lephisto:according to several sources it's /30
                    if (naviData.Altimeter > 300) {
                        // above 10m only write full meters
                        write_number_s(22, top_line, naviData.Altimeter / 30);
                    } else {
                        // up to 10m write meters.dm
                        write_number_u_10th(21, top_line, naviData.Altimeter / 3);
                    }
 
                    // 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)]);
 
                    write_number_s(22, top_line + 1, naviData.HomePositionDeviation.Distance / 100);
 
                    // 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(2, 5, "max Altitude:");
                                write_number_s(17, 5, max_Altimeter / 30);
                                write_char_xy(22, 5, 204); // small meters m
                                write_ascii_string(2, 6, "max Speed   :");
                                write_3digit_number_u(19, 6, (uint16_t) (((uint32_t) max_GroundSpeed * 36) / 1000));
                                write_char_xy(22, 6, 203); // km/h
                                write_ascii_string(2, 7, "max Distance:");
                                write_number_s(17, 7, max_Distance / 100);
                                write_char_xy(22, 7, 204); // small meters m
                                write_ascii_string(2, 8, "min voltage :");
                                write_number_u_10th(16, 8, min_UBat);
                                write_ascii_string(22, 8, "V"); // voltage
                                write_ascii_string(2, 9, "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_number_u_10th(0, bottom_line, naviData.UBat);
                    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);
                    }
 
                    write_time(8, bottom_line, uptime);
                    write_time(16, bottom_line, naviData.FlyingTime);
 
                    write_3digit_number_u(23, bottom_line, naviData.SatsInUse);
 
                    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()) {
            //sendMKData('d', 1, (unsigned char*) 0, 1);
            // request OSD Data from NC every 100ms
            /*unsigned char ms = 10;
                        sendMKData('o', 1, &ms, 1);
                        _delay_ms(500);*/
            config_menu();
        }
        if (s2_pressed()) {
            uptime = 0;
            _delay_ms(100);
        }
        if (seconds_since_last_data > 2) {
            // re-request OSD Data from NC
 
            // re-enable TXD pin
            usart1_EnableTXD();
 
            // every 100ms
            unsigned char ms = 10;
            sendMKData('o', 1, &ms, 1);
 
            // disable TXD pin again
            usart1_DisableTXD();
 
            seconds_since_last_data = 0;
        }
    }
#endif
    return 0;
}
 

Rev 339	Rev 344
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 "max7456_software_spi.c"	31	#include "max7456_software_spi.c"
32	#include "usart1.h"	32	#include "usart1.h"
33		33
34	/* TODO:	34	/* TODO:
35	* - verifiy correctness of values	35	* - verifiy correctness of values
36	* - clean up code :)	36	* - clean up code :)
37	*/	37	*/
38		38
39	/* ##########################################################################	39	/* ##########################################################################
40	* Debugging and general purpose definitions	40	* Debugging and general purpose definitions
41	* ##########################################################################*/	41	* ##########################################################################*/
42	#define ALLCHARSDEBUG 0 // set to 1 and flash firmware to see all chars	42	#define ALLCHARSDEBUG 0 // set to 1 and flash firmware to see all chars
43		43
44	#ifndef WRITECHARS // if WRITECHARS not set via makefile	44	#ifndef WRITECHARS // if WRITECHARS not set via makefile
45	#define WRITECHARS -1 // set to 2XX and flash firmware to write new char	45	#define WRITECHARS -1 // set to 2XX and flash firmware to write new char
46	// enables the allchars as well to see results	46	// enables the allchars as well to see results
47	#endif	47	#endif
48		48
49	#ifndef NTSC // if NTSC is not thet via makefile	49	#ifndef NTSC // if NTSC is not thet via makefile
50	#define NTSC 1 // set to 1 for NTSC mode + lifts the bottom line	50	#define NTSC 0 // set to 1 for NTSC mode + lifts the bottom line
51	#endif	51	#endif
52		52
53	#define HUD 1 // set to 0 to disable HUD by default	53	#define HUD 1 // set to 0 to disable HUD by default
54	#define ARTHORIZON 0 // set to 1 to enable roll&nick artificial horizon by default	54	#define ARTHORIZON 0 // set to 1 to enable roll&nick artificial horizon by default
55	#define STATS 1 // set to 1 to enable statistics during motor off by default	55	#define STATS 1 // set to 1 to enable statistics during motor off by default
56	#define WARNINGS 1 // set to 1 to display battery+rc warning even if HUD is disabled	56	#define WARNINGS 1 // set to 1 to display battery+rc warning even if HUD is disabled
57		57
58	#define UBAT_WRN 94 // voltage for blinking warning, like FC settings	58	#define UBAT_WRN 94 // voltage for blinking warning, like FC settings
59	#define RCLVL_WRN 100 // make the RC level blink if below this number	59	#define RCLVL_WRN 100 // make the RC level blink if below this number
60		60
61	// ### read datasheet before changing stuff below this line :)	61	// ### read datasheet before changing stuff below this line :)
62	#define BLINK 0b01001111 // attribute byte for blinking chars	62	#define BLINK 0b01001111 // attribute byte for blinking chars
63		63
64	/* ##########################################################################	64	/* ##########################################################################
65	* FLAGS usable during runtime	65	* FLAGS usable during runtime
66	* ##########################################################################*/	66	* ##########################################################################*/
67	#define COSD_FLAG_NTSC 1	67	#define COSD_FLAG_NTSC 1
68	#define COSD_FLAG_HUD 2	68	#define COSD_FLAG_HUD 2
69	#define COSD_FLAG_ARTHORIZON 4	69	#define COSD_FLAG_ARTHORIZON 4
70	#define COSD_FLAG_STATS 8	70	#define COSD_FLAG_STATS 8
71	#define COSD_FLAG_WARNINGS 16	71	#define COSD_FLAG_WARNINGS 16
72	#define COSD_ICONS_WRITTEN 32	72	#define COSD_ICONS_WRITTEN 32
73		73
74	/* ##########################################################################	74	/* ##########################################################################
75	* LED controll	75	* LED controll
76	* ##########################################################################*/	76	* ##########################################################################*/
77	#define LED1_ON PORTC \|= (1 << PC0);	77	#define LED1_ON PORTC \|= (1 << PC0);
78	#define LED1_OFF PORTC &= ~(1 << PC0);	78	#define LED1_OFF PORTC &= ~(1 << PC0);
79	#define LED2_ON PORTC \|= (1 << PC1);	79	#define LED2_ON PORTC \|= (1 << PC1);
80	#define LED2_OFF PORTC &= ~(1 << PC1);	80	#define LED2_OFF PORTC &= ~(1 << PC1);
81	#define LED3_ON PORTC \|= (1 << PC2);	81	#define LED3_ON PORTC \|= (1 << PC2);
82	#define LED3_OFF PORTC &= ~(1 << PC2);	82	#define LED3_OFF PORTC &= ~(1 << PC2);
83	#define LED4_ON PORTC \|= (1 << PC3);	83	#define LED4_ON PORTC \|= (1 << PC3);
84	#define LED4_OFF PORTC &= ~(1 << PC3);	84	#define LED4_OFF PORTC &= ~(1 << PC3);
85		85
86	/* ##########################################################################	86	/* ##########################################################################
87	* switch controll	87	* switch controll
88	* ##########################################################################*/	88	* ##########################################################################*/
89	#define S1_PRESSED !(PINC & (1<<PC5))	89	#define S1_PRESSED !(PINC & (1<<PC5))
90	#define S2_PRESSED !(PINC & (1<<PC4))	90	#define S2_PRESSED !(PINC & (1<<PC4))
91		91
92	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))	92	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
93	// data structs	93	// data structs
94	#include "mk-data-structs.h"	94	#include "mk-data-structs.h"
95		95
96	/* ##########################################################################	96	/* ##########################################################################
97	* global definitions and global vars	97	* global definitions and global vars
98	* ##########################################################################*/	98	* ##########################################################################*/
99	volatile uint8_t rxd_buffer_locked = 0;	99	volatile uint8_t rxd_buffer_locked = 0;
100	volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];	100	volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
101	volatile uint8_t txd_buffer[TXD_BUFFER_LEN];	101	volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
102	volatile uint8_t ReceivedBytes = 0;	102	volatile uint8_t ReceivedBytes = 0;
103	volatile uint8_t *pRxData = 0;	103	volatile uint8_t *pRxData = 0;
104	volatile uint8_t RxDataLen = 0;	104	volatile uint8_t RxDataLen = 0;
105	volatile uint16_t setsReceived = 0;	105	volatile uint16_t setsReceived = 0;
106		106
107	volatile NaviData_t naviData;	107	volatile NaviData_t naviData;
108	volatile DebugOut_t debugData;	108	volatile DebugOut_t debugData;
109		109
110	// cache old vars for blinking attribute, checkup is faster than full	110	// cache old vars for blinking attribute, checkup is faster than full
111	// attribute write each time	111	// attribute write each time
112	volatile uint8_t last_UBat = 255;	112	volatile uint8_t last_UBat = 255;
113	volatile uint8_t last_RC_Quality = 255;	113	volatile uint8_t last_RC_Quality = 255;
114		114
115	// 16bit should be enough, normal LiPos don't last that long	115	// 16bit should be enough, normal LiPos don't last that long
116	volatile uint16_t uptime = 0;	116	volatile uint16_t uptime = 0;
117	volatile uint16_t timer = 0;	117	volatile uint16_t timer = 0;
118		118
119	// remember last time data was received	119	// remember last time data was received
120	volatile uint8_t seconds_since_last_data = 0;	120	volatile uint8_t seconds_since_last_data = 0;
121		121
122	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))	122	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))
123		123
124	// general PAL\|NTSC distingiusch stuff	124	// general PAL\|NTSC distingiusch stuff
125	uint8_t top_line = 1;	125	uint8_t top_line = 1;
126	uint8_t bottom_line = 14;	126	uint8_t bottom_line = 14;
127		127
128	// Flags	128	// Flags
129	uint8_t COSD_FLAGS = 0;	129	uint8_t COSD_FLAGS = 0;
130		130
131	/* ##########################################################################	131	/* ##########################################################################
132	* debounce buttons	132	* debounce buttons
133	* ##########################################################################*/	133	* ##########################################################################*/
134	int s1_pressed() {	134	int s1_pressed() {
135	if (S1_PRESSED) {	135	if (S1_PRESSED) {
136	_delay_ms(25);	136	_delay_ms(25);
137	if (S1_PRESSED) return 1;	137	if (S1_PRESSED) return 1;
138	}	138	}
139	return 0;	139	return 0;
140	}	140	}
141		141
142	int s2_pressed() {	142	int s2_pressed() {
143	if (S2_PRESSED) {	143	if (S2_PRESSED) {
144	_delay_ms(25);	144	_delay_ms(25);
145	if (S2_PRESSED) return 1;	145	if (S2_PRESSED) return 1;
146	}	146	}
147	return 0;	147	return 0;
148	}	148	}
149		149
150		150
151	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))	151	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
152		152
153	/**	153	/**
154	* serial support	154	* serial support
155	*/	155	*/
156	#include "usart1.c"	156	#include "usart1.c"
157		157
158		158
159	/* ##########################################################################	159	/* ##########################################################################
160	* timer stuff	160	* timer stuff
161	* ##########################################################################*/	161	* ##########################################################################*/
162		162
163	/**	163	/**
164	* timer kicks in every 1000uS ^= 1ms	164	* timer kicks in every 1000uS ^= 1ms
165	*/	165	*/
166	ISR(TIMER0_OVF_vect) {	166	ISR(TIMER0_OVF_vect) {
167	OCR0 = 6; // preload	167	OCR0 = 6; // preload
168	if (!timer--) {	168	if (!timer--) {
169	uptime++;	169	uptime++;
170	timer = 999;	170	timer = 999;
171	seconds_since_last_data++;	171	seconds_since_last_data++;
172	}	172	}
173	}	173	}
174		174
175	/* ##########################################################################	175	/* ##########################################################################
176	* compass stuff	176	* compass stuff
177	* ##########################################################################*/	177	* ##########################################################################*/
178		178
179	/**	179	/**
180	* convert the <heading> gotton from NC into an index	180	* convert the <heading> gotton from NC into an index
181	*/	181	*/
182	uint8_t heading_conv(uint16_t heading) {	182	uint8_t heading_conv(uint16_t heading) {
183	if (heading > 23 && heading < 68) {	183	if (heading > 23 && heading < 68) {
184	//direction = "NE";	184	//direction = "NE";
185	return 0;	185	return 0;
186	} else if (heading > 67 && heading < 113) {	186	} else if (heading > 67 && heading < 113) {
187	//direction = "E ";	187	//direction = "E ";
188	return 1;	188	return 1;
189	} else if (heading > 112 && heading < 158) {	189	} else if (heading > 112 && heading < 158) {
190	//direction = "SE";	190	//direction = "SE";
191	return 2;	191	return 2;
192	} else if (heading > 157 && heading < 203) {	192	} else if (heading > 157 && heading < 203) {
193	//direction = "S ";	193	//direction = "S ";
194	return 3;	194	return 3;
195	} else if (heading > 202 && heading < 248) {	195	} else if (heading > 202 && heading < 248) {
196	//direction = "SW";	196	//direction = "SW";
197	return 4;	197	return 4;
198	} else if (heading > 247 && heading < 293) {	198	} else if (heading > 247 && heading < 293) {
199	//direction = "W ";	199	//direction = "W ";
200	return 5;	200	return 5;
201	} else if (heading > 292 && heading < 338) {	201	} else if (heading > 292 && heading < 338) {
202	//direction = "NW";	202	//direction = "NW";
203	return 6;	203	return 6;
204	}	204	}
205	//direction = "N ";	205	//direction = "N ";
206	return 7;	206	return 7;
207	}	207	}
208		208
209	/**	209	/**
210	* draw a compass rose at <x>/<y> for <heading>	210	* draw a compass rose at <x>/<y> for <heading>
211	*/	211	*/
212	void draw_compass(uint8_t x, uint8_t y, uint16_t heading) {	212	void draw_compass(uint8_t x, uint8_t y, uint16_t heading) {
213	//char* rose = "---N---O---S---W---N---O---S---W---N---O---S---W";	213	//char* rose = "---N---O---S---W---N---O---S---W---N---O---S---W";
214	char rose[48] = {216, 215, 216, 211, 216, 215, 216, 213, 216, 215, 216, 212,	214	char rose[48] = {216, 215, 216, 211, 216, 215, 216, 213, 216, 215, 216, 212,
215	216, 215, 216, 214, 216, 215, 216, 211, 216, 215, 216, 213,	215	216, 215, 216, 214, 216, 215, 216, 211, 216, 215, 216, 213,
216	216, 215, 216, 212, 216, 215, 216, 214, 216, 215, 216, 211,	216	216, 215, 216, 212, 216, 215, 216, 214, 216, 215, 216, 211,
217	216, 215, 216, 213, 216, 215, 216, 212, 216, 215, 216, 214};	217	216, 215, 216, 213, 216, 215, 216, 212, 216, 215, 216, 214};
218	// the center is char 19 (north), we add the current heading in 8th	218	// the center is char 19 (north), we add the current heading in 8th
219	// which would be 22.5 degrees, but float would bloat up the code	219	// which would be 22.5 degrees, but float would bloat up the code
220	// and *10 / 225 would take ages... so we take the uncorrect way	220	// and *10 / 225 would take ages... so we take the uncorrect way
221	uint8_t front = 19 + (heading / 22);	221	uint8_t front = 19 + (heading / 22);
222	for (uint8_t i = 0; i < 9; i++) {	222	for (uint8_t i = 0; i < 9; i++) {
223	write_char_xy(x++, y, rose[front - 4 + i]);	223	write_char_xy(x++, y, rose[front - 4 + i]);
224	}	224	}
225	}	225	}
226		226
227	/* ##########################################################################	227	/* ##########################################################################
228	* artificial horizon	228	* artificial horizon
229	* ##########################################################################*/	229	* ##########################################################################*/
230	// remember last time displayed values	230	// remember last time displayed values
231	int8_t old_af_x = -1, old_af_y = -1;	231	int8_t old_af_x = -1, old_af_y = -1;
232		232
233	/**	233	/**
234	* draw roll und nick indicators (could be enhanced to full artificial horizon)	234	* draw roll und nick indicators (could be enhanced to full artificial horizon)
235	* from line <firstline> to <listlines> for given <nick> and <roll> values	235	* from line <firstline> to <listlines> for given <nick> and <roll> values
236	*/	236	*/
237	void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {	237	void draw_artificial_horizon(uint8_t firstline, uint8_t lastline, int16_t nick, int16_t roll) {
238	char noodle[5] = {225, 225, 226, 227, 227};	238	char noodle[5] = {225, 225, 226, 227, 227};
239	uint8_t center_x = 15;	239	uint8_t center_x = 15;
240	uint8_t center_y = lastline - firstline;	240	uint8_t center_y = lastline - firstline;
241	center_y = 7;	241	center_y = 7;
242	write_char_xy(center_x,center_y,228);	242	write_char_xy(center_x,center_y,228);
243	uint8_t cpos, nicky, rollx;	243	uint8_t cpos, nicky, rollx;
244		244
245	// which line	245	// which line
246	int8_t ypos = nick / 20;	246	int8_t ypos = nick / 20;
247	// which character from the array?	247	// which character from the array?
248	if (nick < 0) {	248	if (nick < 0) {
249	cpos = -1((nick - (ypos 20))/4);	249	cpos = -1((nick - (ypos 20))/4);
250	ypos--;	250	ypos--;
251	} else cpos = 4-((nick - (ypos * 20))/4);	251	} else cpos = 4-((nick - (ypos * 20))/4);
252	if (cpos > 4) cpos = 4;	252	if (cpos > 4) cpos = 4;
253		253
254	nicky = center_y - ypos;	254	nicky = center_y - ypos;
255	if (nicky > lastline) nicky = lastline;	255	if (nicky > lastline) nicky = lastline;
256	else if (nicky < firstline) nicky = firstline;	256	else if (nicky < firstline) nicky = firstline;
257		257
258	// ensure roll-borders	258	// ensure roll-borders
259	rollx = (roll / 8)+15;	259	rollx = (roll / 8)+15;
260	if (rollx < 2) rollx = 2;	260	if (rollx < 2) rollx = 2;
261	else if (rollx > 28) rollx = 28;	261	else if (rollx > 28) rollx = 28;
262		262
263		263
264	// clear roll	264	// clear roll
265	if (old_af_x != rollx && old_af_x >= 0) {	265	if (old_af_x != rollx && old_af_x >= 0) {
266	write_char_xy(old_af_x,13,0);	266	write_char_xy(old_af_x,13,0);
267	}	267	}
268		268
269	// clear nick	269	// clear nick
270	if (old_af_y != nicky && old_af_y >= 0) {	270	if (old_af_y != nicky && old_af_y >= 0) {
271	write_char_xy(center_x-1,old_af_y,0);	271	write_char_xy(center_x-1,old_af_y,0);
272	write_char_xy(center_x+1,old_af_y,0);	272	write_char_xy(center_x+1,old_af_y,0);
273	}	273	}
274		274
275		275
276	// draw nick	276	// draw nick
277	write_char_xy(center_x-1,nicky,noodle[cpos]);	277	write_char_xy(center_x-1,nicky,noodle[cpos]);
278	write_char_xy(center_x+1,nicky,noodle[cpos]);	278	write_char_xy(center_x+1,nicky,noodle[cpos]);
279		279
280	// draw roll	280	// draw roll
281	write_char_xy(rollx,lastline,229);	281	write_char_xy(rollx,lastline,229);
282		282
283	// update old vars	283	// update old vars
284	old_af_x = rollx;	284	old_af_x = rollx;
285	old_af_y = nicky;	285	old_af_y = nicky;
286		286
287	// debug numbers	287	// debug numbers
288	//write_3digit_number_u(20,6,cpos);	288	//write_3digit_number_u(20,6,cpos);
289	//write_number_s(20,7,ypos);	289	//write_number_s(20,7,ypos);
290	//write_number_s(0,7,nick);	290	//write_number_s(0,7,nick);
291	//write_number_s(18,11,roll);	291	//write_number_s(18,11,roll);
292	}	292	}
293		293
294	/* ##########################################################################	294	/* ##########################################################################
295	* A simple config menu for the flags	295	* A simple config menu for the flags
296	* ##########################################################################*/	296	* ##########################################################################*/
297		297
298	/**	298	/**
299	* helper function for menu updating	299	* helper function for menu updating
300	*/	300	*/
301	void config_menu_drawings(uint8_t chosen) {	301	void config_menu_drawings(uint8_t chosen) {
302	// clear prevoius _cursor_	302	// clear prevoius _cursor_
303	write_ascii_string(3, (chosen + 4) % 5, " ");	303	write_ascii_string(3, (chosen + 4) % 5, " ");
304	// draw current _cursor_	304	// draw current _cursor_
305	write_ascii_string(3, chosen + 6, ">");	305	write_ascii_string(3, chosen + 6, ">");
306	if (COSD_FLAGS & COSD_FLAG_HUD) {	306	if (COSD_FLAGS & COSD_FLAG_HUD) {
307	write_ascii_string(23, 6, "ON ");	307	write_ascii_string(23, 6, "ON ");
308	} else {	308	} else {
309	write_ascii_string(23, 6, "OFF");	309	write_ascii_string(23, 6, "OFF");
310	}	310	}
311	if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {	311	if (COSD_FLAGS & COSD_FLAG_ARTHORIZON) {
312	write_ascii_string(23, 7, "ON ");	312	write_ascii_string(23, 7, "ON ");
313	} else {	313	} else {
314	write_ascii_string(23, 7, "OFF");	314	write_ascii_string(23, 7, "OFF");
315	}	315	}
316	if (COSD_FLAGS & COSD_FLAG_STATS) {	316	if (COSD_FLAGS & COSD_FLAG_STATS) {
317	write_ascii_string(23, 8, "ON ");	317	write_ascii_string(23, 8, "ON ");
318	} else {	318	} else {
319	write_ascii_string(23, 8, "OFF");	319	write_ascii_string(23, 8, "OFF");
320	}	320	}
321	if (COSD_FLAGS & COSD_FLAG_WARNINGS) {	321	if (COSD_FLAGS & COSD_FLAG_WARNINGS) {
322	write_ascii_string(23, 9, "ON ");	322	write_ascii_string(23, 9, "ON ");
323	} else {	323	} else {
324	write_ascii_string(23, 9, "OFF");	324	write_ascii_string(23, 9, "OFF");
325	}	325	}
326	}	326	}
327		327
328	/**	328	/**
329	* a simple config menu tryout	329	* a simple config menu tryout
330	*/	330	*/
331	void config_menu(void) {	331	void config_menu(void) {
332	// disable interrupts (makes the menu more smoothely)	332	// disable interrupts (makes the menu more smoothely)
333	cli();	333	cli();
334		334
335	// clear screen	335	// clear screen
336	clear();	336	clear();
337		337
338	char* menu[5] = {"Full HUD",	338	char* menu[5] = {"Full HUD",
339	"Art.Horizon in HUD",	339	"Art.Horizon in HUD",
340	"Statistics",	340	"Statistics",
341	"Warnings", // TODO: do it!	341	"Warnings", // TODO: do it!
342	"EXIT"};	342	"EXIT"};
343		343
344	uint8_t inmenu = 1;	344	uint8_t inmenu = 1;
345	uint8_t chosen = 0;	345	uint8_t chosen = 0;
346	write_ascii_string(6, 2, "C-OSD Config Menu");	346	write_ascii_string(6, 2, "C-OSD Config Menu");
347		347
348	// wait a bit before doing stuff so user has chance to release button	348	// wait a bit before doing stuff so user has chance to release button
349	_delay_ms(250);	349	_delay_ms(250);
350		350
351	write_ascii_string(4, 6, menu[0]);	351	write_ascii_string(4, 6, menu[0]);
352	write_ascii_string(4, 7, menu[1]);	352	write_ascii_string(4, 7, menu[1]);
353	write_ascii_string(4, 8, menu[2]);	353	write_ascii_string(4, 8, menu[2]);
354	write_ascii_string(4, 9, menu[3]);	354	write_ascii_string(4, 9, menu[3]);
355	write_ascii_string(4, 10, menu[4]);	355	write_ascii_string(4, 10, menu[4]);
356		356
357	config_menu_drawings(chosen);	357	config_menu_drawings(chosen);
358		358
359	while (inmenu) {	359	while (inmenu) {
360	if (s2_pressed()) {	360	if (s2_pressed()) {
361	write_ascii_string(3, chosen+6, " ");	361	write_ascii_string(3, chosen+6, " ");
362	chosen = (chosen + 1) % 5;	362	chosen = (chosen + 1) % 5;
363	write_ascii_string(3, chosen+6, ">");	363	write_ascii_string(3, chosen+6, ">");
364	_delay_ms(500);	364	_delay_ms(500);
365	} else if (s1_pressed()) {	365	} else if (s1_pressed()) {
366	switch (chosen) {	366	switch (chosen) {
367	case 0: // full HUD	367	case 0: // full HUD
368	COSD_FLAGS ^= COSD_FLAG_HUD;	368	COSD_FLAGS ^= COSD_FLAG_HUD;
369	config_menu_drawings(chosen);	369	config_menu_drawings(chosen);
370	break;	370	break;
371	case 1: // art horizon	371	case 1: // art horizon
372	COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;	372	COSD_FLAGS ^= COSD_FLAG_ARTHORIZON;
373	config_menu_drawings(chosen);	373	config_menu_drawings(chosen);
374	break;	374	break;
375	case 2: // statistics	375	case 2: // statistics
376	COSD_FLAGS ^= COSD_FLAG_STATS;	376	COSD_FLAGS ^= COSD_FLAG_STATS;
377	config_menu_drawings(chosen);	377	config_menu_drawings(chosen);
378	break;	378	break;
379	case 3: // warnings	379	case 3: // warnings
380	COSD_FLAGS ^= COSD_FLAG_WARNINGS;	380	COSD_FLAGS ^= COSD_FLAG_WARNINGS;
381	config_menu_drawings(chosen);	381	config_menu_drawings(chosen);
382	break;	382	break;
383	case 4: // exit	383	case 4: // exit
384	inmenu = 0;	384	inmenu = 0;
385	break;	385	break;
386	}	386	}
387	_delay_ms(250);	387	_delay_ms(250);
388	}	388	}
389	}	389	}
390		390
391	// clear screen up again	391	// clear screen up again
392	clear();	392	clear();
393		393
394	// update flags to paint display again if needed	394	// update flags to paint display again if needed
395	COSD_FLAGS &= ~COSD_ICONS_WRITTEN;	395	COSD_FLAGS &= ~COSD_ICONS_WRITTEN;
396		396
397	// enable interrupts again	397	// enable interrupts again
398	sei();	398	sei();
399	}	399	}
400		400
401	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))	401	#endif // ends !(ALLCHARSDEBUG\|(WRITECHARS != -1))
402	/* ##########################################################################	402	/* ##########################################################################
403	* MAIN	403	* MAIN
404	* ##########################################################################*/	404	* ##########################################################################*/
405	int main(void) {	405	int main(void) {
406	// set up FLAGS, compiler should flatten this one	406	// set up FLAGS, compiler should flatten this one
407	COSD_FLAGS = (NTSC << 0);	407	COSD_FLAGS = (NTSC << 0);
408	COSD_FLAGS \|= (HUD << 1);	408	COSD_FLAGS \|= (HUD << 1);
409	COSD_FLAGS \|= (ARTHORIZON << 2);	409	COSD_FLAGS \|= (ARTHORIZON << 2);
410	COSD_FLAGS \|= (STATS << 3);	410	COSD_FLAGS \|= (STATS << 3);
411	COSD_FLAGS \|= (WARNINGS << 4);	411	COSD_FLAGS \|= (WARNINGS << 4);
412		412
413	// set up Atmega162 Ports	413	// set up Atmega162 Ports
414	DDRA \|= (1 << PA1); // PA1 output (/CS)	414	DDRA \|= (1 << PA1); // PA1 output (/CS)
415	MAX_CS_HIGH	415	MAX_CS_HIGH
416	DDRA \|= (1 << PA2); // PA2 output (SDIN)	416	DDRA \|= (1 << PA2); // PA2 output (SDIN)
417	MAX_SDIN_LOW	417	MAX_SDIN_LOW
418	DDRA \|= (1 << PA3); // PA3 output (SCLK)	418	DDRA \|= (1 << PA3); // PA3 output (SCLK)
419	MAX_SCLK_LOW	419	MAX_SCLK_LOW
420	DDRA \|= (1 << PA5); // PA5 output (RESET)	420	DDRA \|= (1 << PA5); // PA5 output (RESET)
421	MAX_RESET_HIGH	421	MAX_RESET_HIGH
422		422
423	DDRC \|= (1 << PC0); // PC0 output (LED1 gn)	423	DDRC \|= (1 << PC0); // PC0 output (LED1 gn)
424	LED1_OFF	424	LED1_OFF
425	DDRC \|= (1 << PC1); // PC1 output (LED2 rt)	425	DDRC \|= (1 << PC1); // PC1 output (LED2 rt)
426	LED2_OFF	426	LED2_OFF
427	DDRC \|= (1 << PC2); // PC2 output (LED3 gn)	427	DDRC \|= (1 << PC2); // PC2 output (LED3 gn)
428	LED3_OFF	428	LED3_OFF
429	DDRC \|= (1 << PC3); // PC3 output (LED4 rt)	429	DDRC \|= (1 << PC3); // PC3 output (LED4 rt)
430	LED4_OFF	430	LED4_OFF
431		431
432	DDRC &= ~(1 << PC4); // PC4 input (MODE)	432	DDRC &= ~(1 << PC4); // PC4 input (MODE)
433	PORTC \|= (1 << PC4); // pullup	433	PORTC \|= (1 << PC4); // pullup
434	DDRC &= ~(1 << PC5); // PC5 input (SET)	434	DDRC &= ~(1 << PC5); // PC5 input (SET)
435	PORTC \|= (1 << PC5); // pullup	435	PORTC \|= (1 << PC5); // pullup
436		436
437	// set up top and bottom lines	437	// set up top and bottom lines
438	if (COSD_FLAGS & COSD_FLAG_NTSC) {	438	if (COSD_FLAGS & COSD_FLAG_NTSC) {
439	bottom_line = 12;	439	bottom_line = 12;
440	} else {	440	} else {
441	bottom_line = 14;	441	bottom_line = 14;
442	}	442	}
443		443
444	// reset the MAX7456 to be sure any undefined states do no harm	444	// reset the MAX7456 to be sure any undefined states do no harm
445	MAX_RESET_LOW	445	MAX_RESET_LOW
446	MAX_RESET_HIGH	446	MAX_RESET_HIGH
447		447
448	// give the FC/NC and the maxim time to come up	448	// give the FC/NC and the maxim time to come up
449	LED4_ON	449	LED4_ON
450	_delay_ms(2000);	450	_delay_ms(2000);
451		451
452	LED4_OFF	452	LED4_OFF
453		453
454		454
455	//Pushing NEW chars to the MAX7456	455	//Pushing NEW chars to the MAX7456
456	#if (WRITECHARS != -1)	456	#if (WRITECHARS != -1)
457	// DISABLE display (VM0)	457	// DISABLE display (VM0)
458	spi_send_byte(0x00, 0b00000000);	458	spi_send_byte(0x00, 0b00000000);
459	#include "characters.c"	459	#include "characters.c"
460		460
461	#endif	461	#endif
462		462
463	// Setup Video Mode	463	// Setup Video Mode
464	if (COSD_FLAGS & COSD_FLAG_NTSC) {	464	if (COSD_FLAGS & COSD_FLAG_NTSC) {
465	// NTSC + enable display immediately (VM0)	465	// NTSC + enable display immediately (VM0)
466	spi_send_byte(0x00, 0b00001000);	466	spi_send_byte(0x00, 0b00001000);
467	} else {	467	} else {
468	// PAL + enable display immediately (VM0)	468	// PAL + enable display immediately (VM0)
469	spi_send_byte(0x00, 0b01001000);	469	spi_send_byte(0x00, 0b01001000);
470	}	470	}
471		471
472	// clear all display-mem (DMM)	472	// clear all display-mem (DMM)
473	spi_send_byte(0x04, 0b00000100);	473	spi_send_byte(0x04, 0b00000100);
474		474
475	// clearing takes 12uS according to maxim so lets wait longer	475	// clearing takes 12uS according to maxim so lets wait longer
476	_delay_us(120);	476	_delay_us(120);
477		477
478	// 8bit mode	478	// 8bit mode
479	spi_send_byte(0x04, 0b01000000);	479	spi_send_byte(0x04, 0b01000000);
480		480
481	// write blank chars to whole screen	481	// write blank chars to whole screen
482	clear();	482	clear();
483		483
484	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))	484	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
485	// init usart	485	// init usart
486	usart1_init();	486	usart1_init();
487		487
488	// set up timer	488	// set up timer
489	TCCR0 \|= (1 << CS00) \| (1 << CS01); // timer0 prescaler 64	489	TCCR0 \|= (1 << CS00) \| (1 << CS01); // timer0 prescaler 64
490	OCR0 = 6; // preload	490	OCR0 = 6; // preload
491	TIMSK \|= (1 << TOIE0); // enable overflow timer0	491	TIMSK \|= (1 << TOIE0); // enable overflow timer0
492		492
493	// enable interrupts	493	// enable interrupts
494	sei();	494	sei();
495	#endif	495	#endif
496		496
497	//write_ascii_string(2, 7, " CaScAdE ");	497	//write_ascii_string(2, 7, " CaScAdE ");
498	//write_ascii_string(2, 8, "is TESTING his open source");	498	//write_ascii_string(2, 8, "is TESTING his open source");
499	//write_ascii_string(2, 9, " EPi OSD Firmware");	499	//write_ascii_string(2, 9, " EPi OSD Firmware");
500		500

Subversion Repositories Projects

(root)/C-OSD/trunk/main.c @ 495 - Rev 339 → 344