WebSVN - Projects - Diff - Rev 1518 and 1525 - /Transportables_Koptertool/branch/GPL_PKT_V3_5_8b


/*****************************************************************************
 *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
 *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
 *   Copyright (C) 2011 Christian "Cebra" Brandtner, brandtner@brandtner.net *
 *   Copyright (C) 2011 Harald Bongartz                                      *
 *                                                                           *
 *   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 + SVN  *
 *                          http://www.mikrokopter.de                        *
 *   Gregor "killagreg" Stobrawa for his version of the MK code              *
 *   Thomas Kaiser "thkais" for the original project. See                    *
 *                          http://www.ft-fanpage.de/mikrokopter/            *
 *                          http://forum.mikrokopter.de/topic-4061-1.html    *
 *   Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
 *                          http://www.mylifesucks.de/oss/c-osd/             *
 *   Harald Bongartz "HaraldB" for providing his Ideas and Code for usibility*
 *****************************************************************************/
 
 
#include "cpu.h"
#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
 
#include "main.h"
#include "osd.h"
#include "lcd.h"
#include "timer.h"
#include "usart.h"
#include "eeprom.h"
#include "messages.h"
 
#include "mk-data-structs.h"
 
#define COSD_WASFLYING 4
#define TIMEOUT 200     // 2 sec
 
// global definitions and global vars
NaviData_t *naviData;
 
// löschen und alle mit "naviData->Variometer" ersetzen
//int8_t Variometer = 0;
 
// Hier Höhenanzeigefehler Korrigieren
#define AltimeterAdjust 1.5
 
// 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;
uint16_t max_Current = 0;
uint16_t max_Capacity = 0;
 
// 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;
 
volatile uint16_t ftimer = 0;
 
// store stats description in progmem to save space
const char stats_item_0[] PROGMEM = "max Altitude:";
const char stats_item_1[] PROGMEM = "max Speed   :";
const char stats_item_2[] PROGMEM = "max Distance:";
const char stats_item_3[] PROGMEM = "min Voltage :";
const char stats_item_4[] PROGMEM = "max Time    :";
#if 1
const char stats_item_5[] PROGMEM = "max Current :";
const char stats_item_6[] PROGMEM = "UsedCapacity:";
#else
const char stats_item_5[] PROGMEM = "Long. :";
const char stats_item_6[] PROGMEM = "Lat.  :";
#endif
 
 
const char *stats_item_pointers[] PROGMEM = {
        stats_item_0,
        stats_item_1,
        stats_item_2,
        stats_item_3,
        stats_item_4,
        stats_item_5,
        stats_item_6
};
 
//char* rose = "-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W";
const char rose[48] PROGMEM = {
        0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S',
        0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O',
        0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N',
        0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W',
};
 
// 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
 
const char str_NE[] PROGMEM = "NE";
const char str_E[] PROGMEM  = "E ";
const char str_SE[] PROGMEM = "SE";
const char str_S[] PROGMEM  = "S ";
const char str_SW[] PROGMEM = "SW";
const char str_W[] PROGMEM  = "W ";
const char str_NW[] PROGMEM = "NW";
const char str_N[] PROGMEM  = "N ";
const char *directions_p[8] PROGMEM = {
        str_NE,
        str_E,
        str_SE,
        str_S,
        str_SW,
        str_W,
        str_NW,
        str_N
};
 
// Flags
uint8_t COSD_FLAGS2 = 0;
 
GPS_Pos_t last5pos[7];
uint8_t error = 0;
 
 
//--------------------------------------------------------------
// convert the <heading> gotton from NC into an index
uint8_t heading_conv (uint16_t heading)
{
        if (heading > 23 && heading < 68)
                return 0;               //direction = "NE";
        else if (heading > 67 && heading < 113)
                return 1;               //direction = "E ";
        else if (heading > 112 && heading < 158)
                return 2;               //direction = "SE";
        else if (heading > 157 && heading < 203)
                return 3;               //direction = "S ";
        else if (heading > 202 && heading < 248)
                return 4;               //direction = "SW";
        else if (heading > 247 && heading < 293)
                return 5;               //direction = "W ";
        else if (heading > 292 && heading < 338)
                return 6;               //direction = "NW";
 
        return 7;       //direction = "N ";
}
 
//--------------------------------------------------------------
// draw a compass rose at <x>/<y> for <heading>
void draw_compass (uint8_t x, uint8_t y, uint16_t heading)
{
        uint8_t front = 19 + (heading / 22);
        for (uint8_t i = 0; i < 9; i++)
                lcd_putc (x++, y, pgm_read_byte(&rose[front - 4 + i]), 0);
}
 
 
//--------------------------------------------------------------
// variometer
// draw variometer arrows at <x>/<y> according to <variometer>
//
void draw_variometer (uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)
{
        lcd_rect (x, y - ((hight) / 2), width, hight, 1);
        lcd_frect (x + 1, y - ((hight) / 2) + 1, width - 2, hight - 2, 0);
        lcd_line (x, y, x + width, y, 1);
 
        if (variometer > 0)  // steigend
        {
                switch (variometer / 5)
                {
                        case 0:
                                lcd_line  (x + 4, y - 1, x + 6, y - 1, 1);      //  1 >  4
                        break;
 
                        case 1:
                                lcd_line  (x + 4, y - 1, x + 6, y - 1, 1);      //  1 >  4
                                lcd_frect (x + 3, y - 3, 4, 1, 1);                      //  5 >  9
                        break;
 
                        case 2:
                                lcd_line  (x + 4, y - 1, x + 6, y - 1, 1);      //  1 >  4
                                lcd_frect (x + 3, y - 3, 4, 1, 1);                      //  5 >  9
                                lcd_frect (x + 2, y - 5, 6, 1, 1);                      // 10 > 14
                        break;
 
                        default:
                                lcd_line  (x + 4, y - 1, x + 6, y - 1, 1);  //  1 >  4
                                lcd_frect (x + 3, y - 3, 4, 1, 1);                      //  5 >  9
                                lcd_frect (x + 2, y - 5, 6, 1, 1);                      // 10 > 14
                                lcd_frect (x + 1, y - 6, 8, 1, 1);                      // 15 >
                        break;
                }
        }
        else if (variometer < 0)  // fallend
        {
                switch ((variometer) / -5)
                {
                        case 0:
                                lcd_line  (x + 4, y + 1, x + 6, y + 1, 1);      // - 1 > - 4
                        break;
 
                        case 1:
                                lcd_line  (x + 4, y + 1, x + 6, y + 1, 1);      // - 1 > - 4
                                lcd_frect (x + 3, y + 2, 4, 1, 1);                      // - 5 > - 9
                        break;
 
                        case 2:
                                lcd_line  (x + 4, y + 1, x + 6, y + 1, 1);      // - 1 > - 4
                                lcd_frect (x + 3, y + 2, 4, 1, 1);                      // - 5 > - 9
                                lcd_frect (x + 2, y + 4, 6, 1, 1);                      // -10 > -14
                        break;
 
                        default:
                                lcd_line  (x + 4, y + 1, x + 6, y + 1, 1);      // - 1 > - 4
                                lcd_frect (x + 3, y + 2, 4, 1, 1);                      // - 5 > - 9
                                lcd_frect (x + 2, y + 4, 6, 1, 1);                      // -10 > -14
                                lcd_frect (x + 1, y + 5, 8, 1, 1);                      // -15 >
                        break;
                }
        }
}
 
 
//--------------------------------------------------------------
void print_statistics (void)
{
        uint8_t line = 0;
        lcd_cls ();
//      lcd_printp_at (12, 7, PSTR("Ende"), 0);
        lcd_puts_at(12, 7, strGet(ENDE), 0);
 
        // max Altitude
        lcd_printp_at (0, line, stats_item_pointers[0], 0);
        write_ndigit_number_s (13, line, max_Altimeter / (30 / AltimeterAdjust), 4, 0);
        lcd_putc (17, line, 'm', 0);
 
        // max Speed
        lcd_printp_at (0, ++line, stats_item_pointers[1], 0);
        write_ndigit_number_u (14, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);
        lcd_printp_at(17, line, PSTR("km/h"), 0);
 
        // max Distance
        lcd_printp_at (0, ++line, stats_item_pointers[2], 0);
        write_ndigit_number_u (14, line, max_Distance / 10, 3, 0);
        lcd_putc (17, line, 'm', 0);
 
        // max time
        lcd_printp_at (0, ++line, stats_item_pointers[4], 0);
        write_time (13, line, max_FlyingTime);
 
        // min voltage
        lcd_printp_at (0, ++line, stats_item_pointers[3], 0);
        write_ndigit_number_u_10th (13, line, min_UBat, 3, 0);
        lcd_putc (17, line, 'V', 0);
 
#if 1
        // max Current
        lcd_printp_at (0, ++line, stats_item_pointers[5], 0);
        write_ndigit_number_u_10th (13, line, max_Current, 3, 0);
        lcd_putc (17, line, 'A', 0);
 
        // Used Capacity
        lcd_printp_at (0, ++line, stats_item_pointers[6], 0);
        write_ndigit_number_u (13, line, max_Capacity, 4, 0);
        lcd_printp_at(17, line, PSTR("mAh"), 0);
#else
        // longitude
        lcd_printp_at (0, ++line, stats_item_pointers[5], 0);
        write_gps_pos (8, line, naviData->CurrentPosition.Longitude);
 
        // latitude
        lcd_printp_at (0, ++line, stats_item_pointers[6], 0);
        write_gps_pos (8, line, naviData->CurrentPosition.Latitude);
#endif
 
        while (!get_key_press (1 << KEY_ESC))
                timer = TIMEOUT;
 
        COSD_FLAGS2 &= ~COSD_WASFLYING;
        get_key_press(KEY_ALL);
        lcd_cls();
}
 
//--------------------------------------------------------------
void print_position (void)
{
        lcd_cls ();
//      lcd_printp_at (0, 0, PSTR(" Breitengr  Längengr "), 2);
        lcd_puts_at(0, 0, strGet(START_LASTPOS1), 2);
//      lcd_printp_at (12, 7, PSTR("Ende"), 0);
        lcd_puts_at(12, 7, strGet(ENDE), 0);
        uint8_t ij =0;
 
        for(ij=0;ij<6;ij++)
        {
                uint32_t lon = last5pos[ij].Latitude;
                write_ndigit_number_u (1, ij+1, (uint16_t)(lon/10000000), 2, 0);
                lcd_printp_at (3, ij+1, PSTR("."), 0);
                write_ndigit_number_u (4, ij+1, (uint16_t)((lon/1000) % 10000), 4, 1);
                write_ndigit_number_u (8, ij+1, (uint16_t)((lon/10) % 100), 2, 1);
 
                uint32_t lat = last5pos[ij].Longitude;
                write_ndigit_number_u (12, ij+1, (uint16_t)(lat/10000000), 2, 0);
                lcd_printp_at (14, ij+1, PSTR("."), 0);
                write_ndigit_number_u (15, ij+1, (uint16_t)((lat/1000) % 10000), 4, 1);
                write_ndigit_number_u (19, ij+1, (uint16_t)((lat/10) % 100), 2, 1);
        }
 
        while (!get_key_press (1 << KEY_ESC))
                timer = TIMEOUT;
 
        get_key_press(KEY_ALL);
        lcd_cls();
}
void Show_LastPosition(void)
{
  lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
  lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
  lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
  uint32_t lon = last5pos[0].Latitude;
  write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);
  lcd_printp_at (3, 6, PSTR("."), 0);
  write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);
  write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);
 
  uint32_t lat = last5pos[0].Longitude;
  write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);
  lcd_printp_at (14, 6, PSTR("."), 0);
  write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);
  write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);
 
}
 
void OSD_Timeout(uint8_t flag)
{
 
//  uint8_t flag;
  uint8_t tmp_dat;
 // flag = 0;
  timer = TIMEOUT;
  // disable OSD Data from NC
  //      RS232_request_mk_data (1, 'o', 0);
//  tmp_dat = 0;
//  SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
 
  mode = 0;
  rxd_buffer_locked = FALSE;
 
 
  // Bei Verbindungsverlusst werden hier die letzten bekannten Koordinaten ausgegeben!!!
//  if (!timer)
//  {       // timeout occured
          if (flag)
          {
                  // Falls Spannungswarnung an war Beeper aus//
                  BeepTime = 0;
                  BeepMuster = 0xFFFF;
 
                  lcd_cls ();
                  WriteLastPosition(last5pos[0].Longitude,last5pos[0].Latitude);  // im EEprom speichern
                  lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
 
//                      lcd_printp_at (0, 0, PSTR(" ERROR: Datenverlust "), 2);
 
//                      lcd_printp_at (0, 2, PSTR("Letzte bekannte"), 0);
//                      lcd_printp_at (0, 3, PSTR("Position gespeichert."), 0);
                  lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
                  lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
//                      lcd_printp_at (19, 7, PSTR("OK"), 0);
                  lcd_puts_at(19, 7, strGet(OK), 0);
//                      lcd_printp_at (0, 5, PSTR(" Breitengr  Längengr "), 0);
 
                  lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
 
                  lcd_puts_at(12, 7, strGet(ENDE), 0);
 
                  BeepTime = 250;
                  BeepMuster = 0x0080;
                  error = 1;
 
                  uint32_t lon = last5pos[0].Latitude;
                  write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);
                  lcd_printp_at (3, 6, PSTR("."), 0);
                  write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);
                  write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);
 
                  uint32_t lat = last5pos[0].Longitude;
                  write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);
                  lcd_printp_at (14, 6, PSTR("."), 0);
                  write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);
                  write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);
 
//                  while (!get_key_press (1 << KEY_ENTER));
                  _delay_ms(1000);
                  timer = TIMEOUT;
                  lcd_cls();
//                  return;
 
 
          }
          else
            {
              lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
              Show_LastPosition();
              BeepTime = 250;
              BeepMuster = 0x0080;
            }
//  }
                  SwitchToNC();
 
                  mode = 'O';
 
                  // disable debug...
                  //      RS232_request_mk_data (0, 'd', 0);
                  tmp_dat = 0;
                  SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
 
                  // request OSD Data from NC every 100ms
                  //      RS232_request_mk_data (1, 'o', 100);
                  tmp_dat = 10;
                  SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
 
 
}
 
 
 
 
//--------------------------------------------------------------
void osd (uint8_t ShowMode)
{
        uint8_t flag;
        uint8_t tmp_dat;
        uint8_t OSD_Mode;
        uint8_t info_3D = 0;
 
        // Clear statistics
        max_Altimeter = 0;
        max_GroundSpeed = 0;
        max_Distance = 0;
        min_UBat = 255;
        max_FlyingTime = 0;
 
        // flags from last round to check for changes
        uint8_t old_FCFlags = 0;
 
        uint16_t old_hh = 0;
        uint8_t old_AngleNick = 0;
        uint8_t old_AngleRoll = 0;
        lcd_cls();
        OSD_Mode = ShowMode;
 
//      if(error == 0)
//              lcd_cls();
 
        if (hardware == FC)
        {
                lcd_printp_at(0, 3, PSTR("Only with NC !"), 0);
                timer = 100;
                while (timer > 0);
 
                return;
        }
 
        SwitchToNC();
 
        mode = 'O';
 
        // disable debug...
        //      RS232_request_mk_data (0, 'd', 0);
        tmp_dat = 0;
        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
 
        // request OSD Data from NC every 100ms
        //      RS232_request_mk_data (1, 'o', 100);
        tmp_dat = 10;
        SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
 
        flag = 0;
        timer = TIMEOUT;
        abo_timer = ABO_TIMEOUT;
 
 
        do
        {
                if (rxd_buffer_locked)
                {
                        timer = TIMEOUT;
                        Decode64 ();
                        naviData = (NaviData_t *) pRxData;
 
                        if(error == 1)
                                lcd_cls();
 
                        error = 0;
                        GPS_Pos_t currpos;
                        currpos.Latitude = naviData->CurrentPosition.Latitude;
                        currpos.Longitude = naviData->CurrentPosition.Longitude;
 
                        if((currpos.Latitude != last5pos[0].Latitude)&&(currpos.Longitude != last5pos[0].Longitude))
                        {
                                last5pos[6] = last5pos[5];
                                last5pos[5] = last5pos[4];
                                last5pos[4] = last5pos[3];
                                last5pos[3] = last5pos[2];
                                last5pos[2] = last5pos[1];
                                last5pos[1] = last5pos[0];
                                last5pos[0] = currpos;
                        }
 
                        flag = 1;
 
                        if (OSD_Mode == 1)
                        {
                                if (naviData->FCFlags & FCFLAG_MOTOR_RUN)
                                { // should be engines running
                                        // motors are on, assume we were/are flying
                                        COSD_FLAGS2 |= COSD_WASFLYING;
                                }
                                else
                                {       // stats
                                        if ((COSD_FLAGS2 & COSD_WASFLYING) | (get_key_press (1 << KEY_ENTER)))
                                                print_statistics ();
 
                                        if (get_key_press (1 << KEY_PLUS))
                                                print_position ();
                                }
 
                                lcd_ecircle(22, 35, 16, 1);
 
                                // Ground Speed
                                write_ndigit_number_u (1, 0, (uint16_t) (((uint32_t) naviData->GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);
                                lcd_printp_at(4, 0, PSTR("km/h"), 0);
 
                                // Compass
                                write_ndigit_number_u (14, 0, naviData->CompassHeading, 3, 0);
                                lcd_putc (17, 0, 0x1E, 0);      // degree symbol
                                lcd_printp_at (18, 0, (const char *) (pgm_read_word ( &(directions_p[heading_conv(naviData->CompassHeading)]))), 0);
 
                                draw_compass (12, 1, naviData->CompassHeading);
 
                                // Altitude
                                //note:lephisto:according to several sources it's /30
                                if (naviData->Altimeter > (300 / AltimeterAdjust) || naviData->Altimeter < (-300 / AltimeterAdjust))    // above 10m only write full meters
                                        write_ndigit_number_s (0, 1, naviData->Altimeter / (30 / AltimeterAdjust), 4, 0);
                                else    // up to 10m write meters.dm
                                        write_ndigit_number_s_10th (0, 1, naviData->Altimeter / (3 / AltimeterAdjust), 3, 0);
 
                                lcd_putc (4, 1, 'm', 0);
 
                                draw_variometer (54, 7, 10, 14, naviData->Variometer);
 
                                // TODO: verify correctness
                                uint16_t heading_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
                                lcd_ecirc_line (22, 35, 15, old_hh, 0);
                                old_hh = heading_home;
                                lcd_ecirc_line (22, 35, 15, heading_home, 1);
 
                                write_ndigit_number_u (7, 3, heading_home, 3, 0);
                                lcd_putc (10, 3, 0x1e, 0);      // degree symbol
 
                                write_ndigit_number_u (7, 2, naviData->HomePositionDeviation.Distance / 10, 3, 0);
                                lcd_putc (10, 2, 'm', 0);
 
                                // Sats in use
                                lcd_printp_at(11, 4, PSTR("Sats"), 0);
                                write_ndigit_number_u (8, 4, naviData->SatsInUse, 2, 0);
 
                                if (naviData->NCFlags & NC_FLAG_MANUAL_CONTROL)
                                        lcd_putc (19, 4, 'M', 0); // rc transmitter
                                else
                                        lcd_putc (19, 4, 'X', 0); // clear
 
                                if (naviData->NCFlags & NC_FLAG_CH)
                                        lcd_printp_at (8, 5, PSTR("Coming Home"), 0);
                                else if (naviData->NCFlags & NC_FLAG_PH)
                                        lcd_printp_at (8, 5, PSTR("Pos. Hold  "), 0);
                                else    // (naviData->NCFlags & NC_FLAG_FREE)
                                        lcd_printp_at (8, 5, PSTR("Free       "), 0);
 
                                // Flying time
                                write_time (7, 6, naviData->FlyingTime);
                                lcd_printp_at (12, 6, PSTR("h"), 0);
 
                                // RC
                                write_ndigit_number_u (15, 6, naviData->RC_Quality, 3, 0);
                                lcd_printp_at(18, 6, PSTR("\x1F"), 0);          // RC-transmitter
                                if (naviData->NCFlags & NC_FLAG_NOSERIALLINK)
                                {
                                        lcd_printpns_at(19, 6, PSTR("  "), 0);          // clear
                                }
                                else
                                {
                                        lcd_printpns_at(19, 6, PSTR("PC"), 0);
                                }
 
                                // Battery level
                                write_ndigit_number_u_10th (0, 7, naviData->UBat, 3, 0);
                                lcd_putc (4, 7, 'V', 0);
 
                                // Akku Warnung
                                if (naviData->UBat < MK_LowBat)
                                { //Beeper ein
                                        BeepTime = 3000;
                                        BeepMuster = 0x0020;
                                }
 
                                //if (naviData->UBat > MK_LowBat+2)  //bei kurzzeitigen Schwankungen Beeper erst wieder aus wenn UBat 0,2 V höher als Warnschwelle
                                //{ //Beeper aus
                                //      BeepTime = 0;
                                //      BeepMuster = 0xFFFF;
                                //}
                                // Akku Warnung Ende
 
                                // Current
                                write_ndigit_number_u_10th (7, 7, naviData->Current, 3, 0);
                                lcd_putc (11, 7, 'A', 0);
 
                                // Capacity
                                write_ndigit_number_u (14, 7, naviData->UsedCapacity, 4, 0);
                                lcd_printp_at(18, 7, PSTR("mAh"), 0);
 
                                // remember statistics (only when engines running)
                                if (naviData->FCFlags & FCFLAG_MOTOR_RUN)
                                {
                                        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;
                                        if (naviData->Current > max_Current) max_Current = naviData->Current;
                                        if (naviData->UsedCapacity > max_Capacity) max_Capacity = naviData->UsedCapacity;
                                }
 
                                // remember last values
                                last_RC_Quality = naviData->RC_Quality;
                                last_UBat = naviData->UBat;
                                old_FCFlags = naviData->FCFlags;
 
                                rxd_buffer_locked = FALSE;
                        }
        // 3D Lage anzeige beginnt hier -----------------------------------
                        else if (OSD_Mode == 3)
                        {
                                uint16_t head_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
 
                                lcd_cls ();
 
                                lcd_line(0,32,128,32,1);   // horizontal //
                                lcd_line(64,0,64,64,1);    // vertical   //
                                lcd_printp_at(12, 7, PSTR("End  Info"), 0);
 
 
                                // 45' Angel
                                lcd_line(62,11,66,11,1);   //    --    //
                                lcd_line(22,30,22,34,1);   //  |       //
                                lcd_line(106,30,106,34,1); //       |  //
                                lcd_line(62,53,66,53,1);   //    --    //
 
                                if (info_3D == 1)
                                {
                                        lcd_line(34,17,36,15,1);   //  /       //
                                        lcd_line(92,15,94,17,1);   //       \  //
                                        lcd_line(34,47,36,49,1);   //  \       //
                                        lcd_line(92,49,94,47,1);   //       /  //
 
//                                      lcd_printp_at(9, 0, PSTR("V"), 0);
//                                      lcd_printp_at(0, 3, PSTR("L"), 0);
//                                      lcd_printp_at(20, 3, PSTR("R"), 0);
//                                      lcd_printp_at(9, 7, PSTR("H"), 0);
 
                                        lcd_puts_at(9, 0, strGet(OSD_V), 0);
                                        lcd_puts_at(0, 3, strGet(OSD_L), 0);
                                        lcd_puts_at(20, 3, strGet(OSD_R), 0);
                                        lcd_puts_at(9, 7, strGet(OSD_H), 0);
 
                                        lcd_printp_at(0, 0, PSTR("N:"), 0);
                                        write_ndigit_number_s (2, 0, naviData->AngleNick, 3, 0);
 
                                        lcd_printp_at(0, 7, PSTR("R:"), 0);
                                        write_ndigit_number_s (2, 7, naviData->AngleRoll, 3, 0);
 
                                        lcd_printp_at(15, 0, PSTR("K:"), 0);
                                        write_ndigit_number_s (18, 0,head_home, 3, 0);
                                }
 
                                if (get_key_press (1 << KEY_ENTER))
                                {
                                        info_3D++;
                                        if (info_3D > 1)
                                                info_3D = 0;
                                }
 
                                uint8_t Nick = ((-naviData->AngleNick/2)+32);
                                uint8_t Roll = -naviData->AngleRoll+64;
                                lcd_ecircle(old_AngleRoll,old_AngleNick, 10, 0);
                                lcd_ecirc_line (old_AngleRoll, old_AngleNick, 9, old_hh, 0);
 
                                lcd_ecircle(Roll, Nick, 10, 1);
                                lcd_ecirc_line (Roll, Nick, 9, head_home, 1);
 
                                old_hh = head_home;
                                old_AngleNick = Nick;
                                old_AngleRoll = Roll;
                                // remember last values
                                last_RC_Quality = naviData->RC_Quality;
                                last_UBat = naviData->UBat;
                                old_FCFlags = naviData->FCFlags;
                                rxd_buffer_locked = FALSE;
                        }
 
                        if (!abo_timer)
                        {       // renew abo every 3 sec
                                // request OSD Data from NC every 100ms
                                //      RS232_request_mk_data (1, 'o', 100);
                                tmp_dat = 10;
                                SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
 
                                abo_timer = ABO_TIMEOUT;
                        }
                }
            if (!timer)
              {
                OSD_Timeout(flag);
                flag = 0;
              }
        }
 
        while (!get_key_press (1 << KEY_ESC));
//        while (!get_key_press (1 << KEY_ESC) && timer);
//      get_key_press(KEY_ALL);
//
//
//      // disable OSD Data from NC
//      //      RS232_request_mk_data (1, 'o', 0);
//      tmp_dat = 0;
//      SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
//
//      mode = 0;
//      rxd_buffer_locked = FALSE;
//
//
//      // Bei Verbindungsverlusst werden hier die letzten bekannten Koordinaten ausgegeben!!!
//      if (!timer)
//      {       // timeout occured
//              if (flag)
//              {
//                      // Falls Spannungswarnung an war Beeper aus//
//                      BeepTime = 0;
//                      BeepMuster = 0xFFFF;
//
//                      lcd_cls ();
//                      WriteLastPosition(last5pos[0].Longitude,last5pos[0].Latitude);  // im EEprom speichern
//                      lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
//
////                    lcd_printp_at (0, 0, PSTR(" ERROR: Datenverlust "), 2);
//
////                    lcd_printp_at (0, 2, PSTR("Letzte bekannte"), 0);
////                    lcd_printp_at (0, 3, PSTR("Position gespeichert."), 0);
//                        lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
//                        lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
////                    lcd_printp_at (19, 7, PSTR("OK"), 0);
//                        lcd_puts_at(19, 7, strGet(OK), 0);
////                    lcd_printp_at (0, 5, PSTR(" Breitengr  Längengr "), 0);
//
//                      lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
//
//                      lcd_puts_at(12, 7, strGet(ENDE), 0);
//
//                      BeepTime = 1500;
//                      BeepMuster = 0x0040;
//                      error = 1;
//
//                      uint32_t lon = last5pos[0].Longitude;
//                      write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);
//                      lcd_printp_at (3, 6, PSTR("."), 0);
//                      write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);
//                      write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);
//
//                      uint32_t lat = last5pos[0].Latitude;
//                      write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);
//                      lcd_printp_at (14, 6, PSTR("."), 0);
//                      write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);
//                      write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);
//
//                      while (!get_key_press (1 << KEY_ENTER));
//
//                      timer = TIMEOUT;
//                      lcd_cls();
//                      return;
//
//              }
//      }
}
 
 

Rev 1518	Rev 1525
1	/*****************************************************************************	1	/*****************************************************************************
2	* Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de *	2	* Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de *
3	* Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net *	3	* Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net *
4	* Copyright (C) 2011 Christian "Cebra" Brandtner, brandtner@brandtner.net *	4	* Copyright (C) 2011 Christian "Cebra" Brandtner, brandtner@brandtner.net *
5	* Copyright (C) 2011 Harald Bongartz *	5	* Copyright (C) 2011 Harald Bongartz *
6	* *	6	* *
7	* This program is free software; you can redistribute it and/or modify *	7	* This program is free software; you can redistribute it and/or modify *
8	* it under the terms of the GNU General Public License as published by *	8	* it under the terms of the GNU General Public License as published by *
9	* the Free Software Foundation; either version 2 of the License. *	9	* the Free Software Foundation; either version 2 of the License. *
10	* *	10	* *
11	* This program is distributed in the hope that it will be useful, *	11	* This program is distributed in the hope that it will be useful, *
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14	* GNU General Public License for more details. *	14	* GNU General Public License for more details. *
15	* *	15	* *
16	* You should have received a copy of the GNU General Public License *	16	* You should have received a copy of the GNU General Public License *
17	* along with this program; if not, write to the *	17	* along with this program; if not, write to the *
18	* Free Software Foundation, Inc., *	18	* Free Software Foundation, Inc., *
19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
20	* *	20	* *
21	* *	21	* *
22	* Credits to: *	22	* Credits to: *
23	* Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN *	23	* Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN *
24	* http://www.mikrokopter.de *	24	* http://www.mikrokopter.de *
25	* Gregor "killagreg" Stobrawa for his version of the MK code *	25	* Gregor "killagreg" Stobrawa for his version of the MK code *
26	* Thomas Kaiser "thkais" for the original project. See *	26	* Thomas Kaiser "thkais" for the original project. See *
27	* http://www.ft-fanpage.de/mikrokopter/ *	27	* http://www.ft-fanpage.de/mikrokopter/ *
28	* http://forum.mikrokopter.de/topic-4061-1.html *	28	* http://forum.mikrokopter.de/topic-4061-1.html *
29	* Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *	29	* Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
30	* http://www.mylifesucks.de/oss/c-osd/ *	30	* http://www.mylifesucks.de/oss/c-osd/ *
31	* Harald Bongartz "HaraldB" for providing his Ideas and Code for usibility*	31	* Harald Bongartz "HaraldB" for providing his Ideas and Code for usibility*
32	*****************************************************************************/	32	*****************************************************************************/
33		33
34		34
35	#include "cpu.h"	35	#include "cpu.h"
36	#include <avr/io.h>	36	#include <avr/io.h>
37	#include <inttypes.h>	37	#include <inttypes.h>
38	#include <stdlib.h>	38	#include <stdlib.h>
39	#include <avr/pgmspace.h>	39	#include <avr/pgmspace.h>
40	#include <util/delay.h>	40	#include <util/delay.h>
41		41
42	#include "main.h"	42	#include "main.h"
43	#include "osd.h"	43	#include "osd.h"
44	#include "lcd.h"	44	#include "lcd.h"
45	#include "timer.h"	45	#include "timer.h"
46	#include "usart.h"	46	#include "usart.h"
47	#include "eeprom.h"	47	#include "eeprom.h"
48	#include "messages.h"	48	#include "messages.h"
49		49
50	#include "mk-data-structs.h"	50	#include "mk-data-structs.h"
51		51
52	#define COSD_WASFLYING 4	52	#define COSD_WASFLYING 4
53	#define TIMEOUT 200 // 2 sec	53	#define TIMEOUT 200 // 2 sec
54		54
55	// global definitions and global vars	55	// global definitions and global vars
56	NaviData_t *naviData;	56	NaviData_t *naviData;
57		57
58	// löschen und alle mit "naviData->Variometer" ersetzen	58	// löschen und alle mit "naviData->Variometer" ersetzen
59	//int8_t Variometer = 0;	59	//int8_t Variometer = 0;
60		60
61	// Hier Höhenanzeigefehler Korrigieren	61	// Hier Höhenanzeigefehler Korrigieren
62	#define AltimeterAdjust 1.5	62	#define AltimeterAdjust 1.5
63		63
64	// stats for after flight	64	// stats for after flight
65	int16_t max_Altimeter = 0;	65	int16_t max_Altimeter = 0;
66	uint16_t max_GroundSpeed = 0;	66	uint16_t max_GroundSpeed = 0;
67	int16_t max_Distance = 0;	67	int16_t max_Distance = 0;
68	uint8_t min_UBat = 255;	68	uint8_t min_UBat = 255;
69	uint16_t max_FlyingTime = 0;	69	uint16_t max_FlyingTime = 0;
70	uint16_t max_Current = 0;	70	uint16_t max_Current = 0;
71	uint16_t max_Capacity = 0;	71	uint16_t max_Capacity = 0;
72		72
73	// cache old vars for blinking attribute, checkup is faster than full	73	// cache old vars for blinking attribute, checkup is faster than full
74	// attribute write each time	74	// attribute write each time
75	volatile uint8_t last_UBat = 255;	75	volatile uint8_t last_UBat = 255;
76	volatile uint8_t last_RC_Quality = 255;	76	volatile uint8_t last_RC_Quality = 255;
77		77
78	volatile uint16_t ftimer = 0;	78	volatile uint16_t ftimer = 0;
79		79
80	// store stats description in progmem to save space	80	// store stats description in progmem to save space
81	const char stats_item_0[] PROGMEM = "max Altitude:";	81	const char stats_item_0[] PROGMEM = "max Altitude:";
82	const char stats_item_1[] PROGMEM = "max Speed :";	82	const char stats_item_1[] PROGMEM = "max Speed :";
83	const char stats_item_2[] PROGMEM = "max Distance:";	83	const char stats_item_2[] PROGMEM = "max Distance:";
84	const char stats_item_3[] PROGMEM = "min Voltage :";	84	const char stats_item_3[] PROGMEM = "min Voltage :";
85	const char stats_item_4[] PROGMEM = "max Time :";	85	const char stats_item_4[] PROGMEM = "max Time :";
86	#if 1	86	#if 1
87	const char stats_item_5[] PROGMEM = "max Current :";	87	const char stats_item_5[] PROGMEM = "max Current :";
88	const char stats_item_6[] PROGMEM = "UsedCapacity:";	88	const char stats_item_6[] PROGMEM = "UsedCapacity:";
89	#else	89	#else
90	const char stats_item_5[] PROGMEM = "Long. :";	90	const char stats_item_5[] PROGMEM = "Long. :";
91	const char stats_item_6[] PROGMEM = "Lat. :";	91	const char stats_item_6[] PROGMEM = "Lat. :";
92	#endif	92	#endif
93		93
94		94
95	const char *stats_item_pointers[] PROGMEM = {	95	const char *stats_item_pointers[] PROGMEM = {
96	stats_item_0,	96	stats_item_0,
97	stats_item_1,	97	stats_item_1,
98	stats_item_2,	98	stats_item_2,
99	stats_item_3,	99	stats_item_3,
100	stats_item_4,	100	stats_item_4,
101	stats_item_5,	101	stats_item_5,
102	stats_item_6	102	stats_item_6
103	};	103	};
104		104
105	//char* rose = "-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W";	105	//char* rose = "-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W";
106	const char rose[48] PROGMEM = {	106	const char rose[48] PROGMEM = {
107	0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S',	107	0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S',
108	0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O',	108	0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O',
109	0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N',	109	0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N',
110	0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W',	110	0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W',
111	};	111	};
112		112
113	// the center is char 19 (north), we add the current heading in 8th	113	// the center is char 19 (north), we add the current heading in 8th
114	// which would be 22.5 degrees, but float would bloat up the code	114	// which would be 22.5 degrees, but float would bloat up the code
115	// and *10 / 225 would take ages... so we take the uncorrect way	115	// and *10 / 225 would take ages... so we take the uncorrect way
116		116
117	const char str_NE[] PROGMEM = "NE";	117	const char str_NE[] PROGMEM = "NE";
118	const char str_E[] PROGMEM = "E ";	118	const char str_E[] PROGMEM = "E ";
119	const char str_SE[] PROGMEM = "SE";	119	const char str_SE[] PROGMEM = "SE";
120	const char str_S[] PROGMEM = "S ";	120	const char str_S[] PROGMEM = "S ";
121	const char str_SW[] PROGMEM = "SW";	121	const char str_SW[] PROGMEM = "SW";
122	const char str_W[] PROGMEM = "W ";	122	const char str_W[] PROGMEM = "W ";
123	const char str_NW[] PROGMEM = "NW";	123	const char str_NW[] PROGMEM = "NW";
124	const char str_N[] PROGMEM = "N ";	124	const char str_N[] PROGMEM = "N ";
125	const char *directions_p[8] PROGMEM = {	125	const char *directions_p[8] PROGMEM = {
126	str_NE,	126	str_NE,
127	str_E,	127	str_E,
128	str_SE,	128	str_SE,
129	str_S,	129	str_S,
130	str_SW,	130	str_SW,
131	str_W,	131	str_W,
132	str_NW,	132	str_NW,
133	str_N	133	str_N
134	};	134	};
135		135
136	// Flags	136	// Flags
137	uint8_t COSD_FLAGS2 = 0;	137	uint8_t COSD_FLAGS2 = 0;
138		138
139	GPS_Pos_t last5pos[7];	139	GPS_Pos_t last5pos[7];
140	uint8_t error = 0;	140	uint8_t error = 0;
141		141
142		142
143	//--------------------------------------------------------------	143	//--------------------------------------------------------------
144	// convert the <heading> gotton from NC into an index	144	// convert the <heading> gotton from NC into an index
145	uint8_t heading_conv (uint16_t heading)	145	uint8_t heading_conv (uint16_t heading)
146	{	146	{
147	if (heading > 23 && heading < 68)	147	if (heading > 23 && heading < 68)
148	return 0; //direction = "NE";	148	return 0; //direction = "NE";
149	else if (heading > 67 && heading < 113)	149	else if (heading > 67 && heading < 113)
150	return 1; //direction = "E ";	150	return 1; //direction = "E ";
151	else if (heading > 112 && heading < 158)	151	else if (heading > 112 && heading < 158)
152	return 2; //direction = "SE";	152	return 2; //direction = "SE";
153	else if (heading > 157 && heading < 203)	153	else if (heading > 157 && heading < 203)
154	return 3; //direction = "S ";	154	return 3; //direction = "S ";
155	else if (heading > 202 && heading < 248)	155	else if (heading > 202 && heading < 248)
156	return 4; //direction = "SW";	156	return 4; //direction = "SW";
157	else if (heading > 247 && heading < 293)	157	else if (heading > 247 && heading < 293)
158	return 5; //direction = "W ";	158	return 5; //direction = "W ";
159	else if (heading > 292 && heading < 338)	159	else if (heading > 292 && heading < 338)
160	return 6; //direction = "NW";	160	return 6; //direction = "NW";
161		161
162	return 7; //direction = "N ";	162	return 7; //direction = "N ";
163	}	163	}
164		164
165	//--------------------------------------------------------------	165	//--------------------------------------------------------------
166	// draw a compass rose at <x>/<y> for <heading>	166	// draw a compass rose at <x>/<y> for <heading>
167	void draw_compass (uint8_t x, uint8_t y, uint16_t heading)	167	void draw_compass (uint8_t x, uint8_t y, uint16_t heading)
168	{	168	{
169	uint8_t front = 19 + (heading / 22);	169	uint8_t front = 19 + (heading / 22);
170	for (uint8_t i = 0; i < 9; i++)	170	for (uint8_t i = 0; i < 9; i++)
171	lcd_putc (x++, y, pgm_read_byte(&rose[front - 4 + i]), 0);	171	lcd_putc (x++, y, pgm_read_byte(&rose[front - 4 + i]), 0);
172	}	172	}
173		173
174		174
175	//--------------------------------------------------------------	175	//--------------------------------------------------------------
176	// variometer	176	// variometer
177	// draw variometer arrows at <x>/<y> according to <variometer>	177	// draw variometer arrows at <x>/<y> according to <variometer>
178	//	178	//
179	void draw_variometer (uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)	179	void draw_variometer (uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)
180	{	180	{
181	lcd_rect (x, y - ((hight) / 2), width, hight, 1);	181	lcd_rect (x, y - ((hight) / 2), width, hight, 1);
182	lcd_frect (x + 1, y - ((hight) / 2) + 1, width - 2, hight - 2, 0);	182	lcd_frect (x + 1, y - ((hight) / 2) + 1, width - 2, hight - 2, 0);
183	lcd_line (x, y, x + width, y, 1);	183	lcd_line (x, y, x + width, y, 1);
184		184
185	if (variometer > 0) // steigend	185	if (variometer > 0) // steigend
186	{	186	{
187	switch (variometer / 5)	187	switch (variometer / 5)
188	{	188	{
189	case 0:	189	case 0:
190	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4	190	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
191	break;	191	break;
192		192
193	case 1:	193	case 1:
194	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4	194	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
195	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9	195	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
196	break;	196	break;
197		197
198	case 2:	198	case 2:
199	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4	199	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
200	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9	200	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
201	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14	201	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14
202	break;	202	break;
203		203
204	default:	204	default:
205	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4	205	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
206	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9	206	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
207	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14	207	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14
208	lcd_frect (x + 1, y - 6, 8, 1, 1); // 15 >	208	lcd_frect (x + 1, y - 6, 8, 1, 1); // 15 >
209	break;	209	break;
210	}	210	}
211	}	211	}
212	else if (variometer < 0) // fallend	212	else if (variometer < 0) // fallend
213	{	213	{
214	switch ((variometer) / -5)	214	switch ((variometer) / -5)
215	{	215	{
216	case 0:	216	case 0:
217	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4	217	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
218	break;	218	break;
219		219
220	case 1:	220	case 1:
221	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4	221	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
222	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9	222	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
223	break;	223	break;
224		224
225	case 2:	225	case 2:
226	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4	226	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
227	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9	227	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
228	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14	228	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14
229	break;	229	break;
230		230
231	default:	231	default:
232	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4	232	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
233	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9	233	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
234	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14	234	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14
235	lcd_frect (x + 1, y + 5, 8, 1, 1); // -15 >	235	lcd_frect (x + 1, y + 5, 8, 1, 1); // -15 >
236	break;	236	break;
237	}	237	}
238	}	238	}
239	}	239	}
240		240
241		241
242	//--------------------------------------------------------------	242	//--------------------------------------------------------------
243	void print_statistics (void)	243	void print_statistics (void)
244	{	244	{
245	uint8_t line = 0;	245	uint8_t line = 0;
246	lcd_cls ();	246	lcd_cls ();
247	// lcd_printp_at (12, 7, PSTR("Ende"), 0);	247	// lcd_printp_at (12, 7, PSTR("Ende"), 0);
248	lcd_puts_at(12, 7, strGet(ENDE), 0);	248	lcd_puts_at(12, 7, strGet(ENDE), 0);
249		249
250	// max Altitude	250	// max Altitude
251	lcd_printp_at (0, line, stats_item_pointers[0], 0);	251	lcd_printp_at (0, line, stats_item_pointers[0], 0);
252	write_ndigit_number_s (13, line, max_Altimeter / (30 / AltimeterAdjust), 4, 0);	252	write_ndigit_number_s (13, line, max_Altimeter / (30 / AltimeterAdjust), 4, 0);
253	lcd_putc (17, line, 'm', 0);	253	lcd_putc (17, line, 'm', 0);
254		254
255	// max Speed	255	// max Speed
256	lcd_printp_at (0, ++line, stats_item_pointers[1], 0);	256	lcd_printp_at (0, ++line, stats_item_pointers[1], 0);
257	write_ndigit_number_u (14, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);	257	write_ndigit_number_u (14, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);
258	lcd_printp_at(17, line, PSTR("km/h"), 0);	258	lcd_printp_at(17, line, PSTR("km/h"), 0);
259		259
260	// max Distance	260	// max Distance
261	lcd_printp_at (0, ++line, stats_item_pointers[2], 0);	261	lcd_printp_at (0, ++line, stats_item_pointers[2], 0);
262	write_ndigit_number_u (14, line, max_Distance / 10, 3, 0);	262	write_ndigit_number_u (14, line, max_Distance / 10, 3, 0);
263	lcd_putc (17, line, 'm', 0);	263	lcd_putc (17, line, 'm', 0);
264		264
265	// max time	265	// max time
266	lcd_printp_at (0, ++line, stats_item_pointers[4], 0);	266	lcd_printp_at (0, ++line, stats_item_pointers[4], 0);
267	write_time (13, line, max_FlyingTime);	267	write_time (13, line, max_FlyingTime);
268		268
269	// min voltage	269	// min voltage
270	lcd_printp_at (0, ++line, stats_item_pointers[3], 0);	270	lcd_printp_at (0, ++line, stats_item_pointers[3], 0);
271	write_ndigit_number_u_10th (13, line, min_UBat, 3, 0);	271	write_ndigit_number_u_10th (13, line, min_UBat, 3, 0);
272	lcd_putc (17, line, 'V', 0);	272	lcd_putc (17, line, 'V', 0);
273		273
274	#if 1	274	#if 1
275	// max Current	275	// max Current
276	lcd_printp_at (0, ++line, stats_item_pointers[5], 0);	276	lcd_printp_at (0, ++line, stats_item_pointers[5], 0);
277	write_ndigit_number_u_10th (13, line, max_Current, 3, 0);	277	write_ndigit_number_u_10th (13, line, max_Current, 3, 0);
278	lcd_putc (17, line, 'A', 0);	278	lcd_putc (17, line, 'A', 0);
279		279
280	// Used Capacity	280	// Used Capacity
281	lcd_printp_at (0, ++line, stats_item_pointers[6], 0);	281	lcd_printp_at (0, ++line, stats_item_pointers[6], 0);
282	write_ndigit_number_u (13, line, max_Capacity, 4, 0);	282	write_ndigit_number_u (13, line, max_Capacity, 4, 0);
283	lcd_printp_at(17, line, PSTR("mAh"), 0);	283	lcd_printp_at(17, line, PSTR("mAh"), 0);
284	#else	284	#else
285	// longitude	285	// longitude
286	lcd_printp_at (0, ++line, stats_item_pointers[5], 0);	286	lcd_printp_at (0, ++line, stats_item_pointers[5], 0);
287	write_gps_pos (8, line, naviData->CurrentPosition.Longitude);	287	write_gps_pos (8, line, naviData->CurrentPosition.Longitude);
288		288
289	// latitude	289	// latitude
290	lcd_printp_at (0, ++line, stats_item_pointers[6], 0);	290	lcd_printp_at (0, ++line, stats_item_pointers[6], 0);
291	write_gps_pos (8, line, naviData->CurrentPosition.Latitude);	291	write_gps_pos (8, line, naviData->CurrentPosition.Latitude);
292	#endif	292	#endif
293		293
294	while (!get_key_press (1 << KEY_ESC))	294	while (!get_key_press (1 << KEY_ESC))
295	timer = TIMEOUT;	295	timer = TIMEOUT;
296		296
297	COSD_FLAGS2 &= ~COSD_WASFLYING;	297	COSD_FLAGS2 &= ~COSD_WASFLYING;
298	get_key_press(KEY_ALL);	298	get_key_press(KEY_ALL);
299	lcd_cls();	299	lcd_cls();
300	}	300	}
301		301
302	//--------------------------------------------------------------	302	//--------------------------------------------------------------
303	void print_position (void)	303	void print_position (void)
304	{	304	{
305	lcd_cls ();	305	lcd_cls ();
306	// lcd_printp_at (0, 0, PSTR(" Breitengr Längengr "), 2);	306	// lcd_printp_at (0, 0, PSTR(" Breitengr Längengr "), 2);
307	lcd_puts_at(0, 0, strGet(START_LASTPOS1), 2);	307	lcd_puts_at(0, 0, strGet(START_LASTPOS1), 2);
308	// lcd_printp_at (12, 7, PSTR("Ende"), 0);	308	// lcd_printp_at (12, 7, PSTR("Ende"), 0);
309	lcd_puts_at(12, 7, strGet(ENDE), 0);	309	lcd_puts_at(12, 7, strGet(ENDE), 0);
310	uint8_t ij =0;	310	uint8_t ij =0;
311		311
312	for(ij=0;ij<6;ij++)	312	for(ij=0;ij<6;ij++)
313	{	313	{
314	uint32_t lon = last5pos[ij].Latitude;	314	uint32_t lon = last5pos[ij].Latitude;
315	write_ndigit_number_u (1, ij+1, (uint16_t)(lon/10000000), 2, 0);	315	write_ndigit_number_u (1, ij+1, (uint16_t)(lon/10000000), 2, 0);
316	lcd_printp_at (3, ij+1, PSTR("."), 0);	316	lcd_printp_at (3, ij+1, PSTR("."), 0);
317	write_ndigit_number_u (4, ij+1, (uint16_t)((lon/1000) % 10000), 4, 1);	317	write_ndigit_number_u (4, ij+1, (uint16_t)((lon/1000) % 10000), 4, 1);
318	write_ndigit_number_u (8, ij+1, (uint16_t)((lon/10) % 100), 2, 1);	318	write_ndigit_number_u (8, ij+1, (uint16_t)((lon/10) % 100), 2, 1);
319		319
320	uint32_t lat = last5pos[ij].Longitude;	320	uint32_t lat = last5pos[ij].Longitude;
321	write_ndigit_number_u (12, ij+1, (uint16_t)(lat/10000000), 2, 0);	321	write_ndigit_number_u (12, ij+1, (uint16_t)(lat/10000000), 2, 0);
322	lcd_printp_at (14, ij+1, PSTR("."), 0);	322	lcd_printp_at (14, ij+1, PSTR("."), 0);
323	write_ndigit_number_u (15, ij+1, (uint16_t)((lat/1000) % 10000), 4, 1);	323	write_ndigit_number_u (15, ij+1, (uint16_t)((lat/1000) % 10000), 4, 1);
324	write_ndigit_number_u (19, ij+1, (uint16_t)((lat/10) % 100), 2, 1);	324	write_ndigit_number_u (19, ij+1, (uint16_t)((lat/10) % 100), 2, 1);
325	}	325	}
326		326
327	while (!get_key_press (1 << KEY_ESC))	327	while (!get_key_press (1 << KEY_ESC))
328	timer = TIMEOUT;	328	timer = TIMEOUT;
329		329
330	get_key_press(KEY_ALL);	330	get_key_press(KEY_ALL);
331	lcd_cls();	331	lcd_cls();
332	}	332	}
333	void Show_LastPosition(void)	333	void Show_LastPosition(void)
334	{	334	{
-		335	lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
-		336	lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
335	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);	337	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
336	uint32_t lon = last5pos[0].Latitude;	338	uint32_t lon = last5pos[0].Latitude;
337	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);	339	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);
338	lcd_printp_at (3, 6, PSTR("."), 0);	340	lcd_printp_at (3, 6, PSTR("."), 0);
339	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);	341	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);
340	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);	342	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);
341		343
342	uint32_t lat = last5pos[0].Longitude;	344	uint32_t lat = last5pos[0].Longitude;
343	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);	345	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);
344	lcd_printp_at (14, 6, PSTR("."), 0);	346	lcd_printp_at (14, 6, PSTR("."), 0);
345	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);	347	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);
346	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);	348	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);
347		349
348	}	350	}
349		351
350	void OSD_Timeout(uint8_t flag)	352	void OSD_Timeout(uint8_t flag)
351	{	353	{
352		354
353	// uint8_t flag;	355	// uint8_t flag;
354	uint8_t tmp_dat;	356	uint8_t tmp_dat;
355	// flag = 0;	357	// flag = 0;
356	timer = TIMEOUT;	358	timer = TIMEOUT;
357	// disable OSD Data from NC	359	// disable OSD Data from NC
358	// RS232_request_mk_data (1, 'o', 0);	360	// RS232_request_mk_data (1, 'o', 0);
359	// tmp_dat = 0;	361	// tmp_dat = 0;
360	// SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);	362	// SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
361		363
362	mode = 0;	364	mode = 0;
363	rxd_buffer_locked = FALSE;	365	rxd_buffer_locked = FALSE;
364		366
365		367
366	// Bei Verbindungsverlusst werden hier die letzten bekannten Koordinaten ausgegeben!!!	368	// Bei Verbindungsverlusst werden hier die letzten bekannten Koordinaten ausgegeben!!!
367	// if (!timer)	369	// if (!timer)
368	// { // timeout occured	370	// { // timeout occured
369	if (flag)	371	if (flag)
370	{	372	{
371	// Falls Spannungswarnung an war Beeper aus//	373	// Falls Spannungswarnung an war Beeper aus//
372	BeepTime = 0;	374	BeepTime = 0;
373	BeepMuster = 0xFFFF;	375	BeepMuster = 0xFFFF;
374		376
375	lcd_cls ();	377	lcd_cls ();
376	WriteLastPosition(last5pos[0].Longitude,last5pos[0].Latitude); // im EEprom speichern	378	WriteLastPosition(last5pos[0].Longitude,last5pos[0].Latitude); // im EEprom speichern
377	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);	379	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
378		380
379	// lcd_printp_at (0, 0, PSTR(" ERROR: Datenverlust "), 2);	381	// lcd_printp_at (0, 0, PSTR(" ERROR: Datenverlust "), 2);
380		382
381	// lcd_printp_at (0, 2, PSTR("Letzte bekannte"), 0);	383	// lcd_printp_at (0, 2, PSTR("Letzte bekannte"), 0);
382	// lcd_printp_at (0, 3, PSTR("Position gespeichert."), 0);	384	// lcd_printp_at (0, 3, PSTR("Position gespeichert."), 0);
383	lcd_puts_at(0, 2, strGet(OSD_POS1), 0);	385	lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
384	lcd_puts_at(0, 3, strGet(OSD_POS2), 0);	386	lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
385	// lcd_printp_at (19, 7, PSTR("OK"), 0);	387	// lcd_printp_at (19, 7, PSTR("OK"), 0);
386	lcd_puts_at(19, 7, strGet(OK), 0);	388	lcd_puts_at(19, 7, strGet(OK), 0);
387	// lcd_printp_at (0, 5, PSTR(" Breitengr Längengr "), 0);	389	// lcd_printp_at (0, 5, PSTR(" Breitengr Längengr "), 0);
388		390
389	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);	391	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
390		392
391	lcd_puts_at(12, 7, strGet(ENDE), 0);	393	lcd_puts_at(12, 7, strGet(ENDE), 0);
392		394
393	BeepTime = 250;	395	BeepTime = 250;
394	BeepMuster = 0x0080;	396	BeepMuster = 0x0080;
395	error = 1;	397	error = 1;
396		398
397	uint32_t lon = last5pos[0].Latitude;	399	uint32_t lon = last5pos[0].Latitude;
398	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);	400	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0);
399	lcd_printp_at (3, 6, PSTR("."), 0);	401	lcd_printp_at (3, 6, PSTR("."), 0);
400	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);	402	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1);
401	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);	403	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1);
402		404
403	uint32_t lat = last5pos[0].Longitude;	405	uint32_t lat = last5pos[0].Longitude;
404	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);	406	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0);
405	lcd_printp_at (14, 6, PSTR("."), 0);	407	lcd_printp_at (14, 6, PSTR("."), 0);
406	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);	408	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1);
407	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);	409	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1);
408		410
409	// while (!get_key_press (1 << KEY_ENTER));	411	// while (!get_key_press (1 << KEY_ENTER));
410	_delay_ms(1000);	412	_delay_ms(1000);
411	timer = TIMEOUT;	413	timer = TIMEOUT;
412	lcd_cls();	414	lcd_cls();
413	// return;	415	// return;
414		416
415		417
416	}	418	}
417	else	419	else
418	{	420	{
419	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);	421	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
420	Show_LastPosition();	422	Show_LastPosition();
421	BeepTime = 250;	423	BeepTime = 250;
422	BeepMuster = 0x0080;	424	BeepMuster = 0x0080;
423	}	425	}
424	// }	426	// }
425	SwitchToNC();	427	SwitchToNC();
426		428
427	mode = 'O';	429	mode = 'O';
428		430
429	// disable debug...	431	// disable debug...
430	// RS232_request_mk_data (0, 'd', 0);	432	// RS232_request_mk_data (0, 'd', 0);
431	tmp_dat = 0;	433	tmp_dat = 0;
432	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);	434	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
433		435
434	// request OSD Data from NC every 100ms	436	// request OSD Data from NC every 100ms
435	// RS232_request_mk_data (1, 'o', 100);	437	// RS232_request_mk_data (1, 'o', 100);
436	tmp_dat = 10;	438	tmp_dat = 10;
437	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);	439	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
438		440
439		441
440	}	442	}
441		443
442		444
443		445
444		446
445	//--------------------------------------------------------------	447	//--------------------------------------------------------------
446	void osd (uint8_t ShowMode)	448	void osd (uint8_t ShowMode)
447	{	449	{
448	uint8_t flag;	450	uint8_t flag;
449	uint8_t tmp_dat;	451	uint8_t tmp_dat;
450	uint8_t OSD_Mode;	452	uint8_t OSD_Mode;
451	uint8_t info_3D = 0;	453	uint8_t info_3D = 0;
452		454
453	// Clear statistics	455	// Clear statistics
454	max_Altimeter = 0;	456	max_Altimeter = 0;
455	max_GroundSpeed = 0;	457	max_GroundSpeed = 0;
456	max_Distance = 0;	458	max_Distance = 0;
457	min_UBat = 255;	459	min_UBat = 255;
458	max_FlyingTime = 0;	460	max_FlyingTime = 0;
459		461
460	// flags from last round to check for changes	462	// flags from last round to check for changes
461	uint8_t old_FCFlags = 0;	463	uint8_t old_FCFlags = 0;
462		464
463	uint16_t old_hh = 0;	465	uint16_t old_hh = 0;
464	uint8_t old_AngleNick = 0;	466	uint8_t old_AngleNick = 0;
465	uint8_t old_AngleRoll = 0;	467	uint8_t old_AngleRoll = 0;
466	lcd_cls();	468	lcd_cls();
467	OSD_Mode = ShowMode;	469	OSD_Mode = ShowMode;
468		470
469	// if(error == 0)	471	// if(error == 0)
470	// lcd_cls();	472	// lcd_cls();
471		473
472	if (hardware == FC)	474	if (hardware == FC)
473	{	475	{
474	lcd_printp_at(0, 3, PSTR("Only with NC !"), 0);	476	lcd_printp_at(0, 3, PSTR("Only with NC !"), 0);
475	timer = 100;	477	timer = 100;
476	while (timer > 0);	478	while (timer > 0);
477		479
478	return;	480	return;
479	}	481	}
480		482
481	SwitchToNC();	483	SwitchToNC();
482		484
483	mode = 'O';	485	mode = 'O';
484		486
485	// disable debug...	487	// disable debug...
486	// RS232_request_mk_data (0, 'd', 0);	488	// RS232_request_mk_data (0, 'd', 0);
487	tmp_dat = 0;	489	tmp_dat = 0;
488	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);	490	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
489		491
490	// request OSD Data from NC every 100ms	492	// request OSD Data from NC every 100ms
491	// RS232_request_mk_data (1, 'o', 100);	493	// RS232_request_mk_data (1, 'o', 100);
492	tmp_dat = 10;	494	tmp_dat = 10;
493	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);	495	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
494		496
495	flag = 0;	497	flag = 0;
496	timer = TIMEOUT;	498	timer = TIMEOUT;
497	abo_timer = ABO_TIMEOUT;	499	abo_timer = ABO_TIMEOUT;
498		500

Subversion Repositories Projects

(root)/Transportables_Koptertool/branch/GPL_PKT_V3_5_8b_FC086/osd.c - Rev 1518 → 1525