display.c

此程序为GPS接收机的源码

// display.c gpl-gps display output
// Copyright (C) 2005  Andrew Greenberg
// Distributed under the GNU GENERAL PUBLIC LICENSE (GPL) Version 2 (June 1991).
// See the "COPYING" file distributed with this software for more information.

#include <cyg/kernel/kapi.h>
#include <cyg/infra/diag.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "display.h"
#include "constants.h"
#include "ephemeris.h"
#include "message.h"
#include "position.h"
#include "pseudorange.h"
#include "serial.h"
#include "switches.h"
#include "threads.h"
#include "time.h"
#include "tracking.h"


unsigned short display_command = DISPLAY_POSITION;
static unsigned short ephemeris_mode;


/******************************************************************************
 * Send out the VT100 series clear-screen command
 ******************************************************************************/
static void
clear_screen( void)
{
    char clear_screen[] = "\033[2J";

    uart2_send_string( clear_screen);
}

/******************************************************************************
 * Display position/clock info
 ******************************************************************************/
static void
display_position( void)
{
#ifdef ENABLE_POSITION_DISPLAY

    static unsigned short  was_positioning;

    char string[120];
    char header[] = "\
Ch: PN C PrV EpV Pseudorange    Elev. Azim.\n\r";
// Ch: PN C PrV EpV U pseudorange   El. Az. ----x---- ----y---- ----z----\n\r";

    time_t          std_time;
    gpstime_t       gps_time;
    unsigned short  clock_state;
    double          lat, lon;
    double          az, el;

    unsigned short  ch;
    unsigned short  channel_state;
//     char            in_use;

    gps_time = get_time();
    std_time = get_standard_time();
    clock_state = get_clock_state();

    lat = receiver_llh.lat * RADTODEG;
    lon = receiver_llh.lon * RADTODEG;

    // Print the Clock/Time info first
    sprintf( string,
             "\033[HTime = %d/%d/%d %d:%d:%2.3f (state:%d)\033[K\n\r\n\r",
             std_time.years,
             std_time.months,
             std_time.days,
             std_time.hours,
             std_time.minutes,
             std_time.seconds,
             clock_state);
    uart2_send_string( string);

    // Print the ECEF position info (even if it hasn't been set yet!)
    sprintf( string,
             "dECEF = (X:% 8.1f Y:% 8.1f Z:% 8.1f) tb:%1.3e\033[K\n\r\n\r",
             receiver_pos.x - HERE_X,
             receiver_pos.y - HERE_Y,
             receiver_pos.z - HERE_Z,
             receiver_pos.b);
    uart2_send_string( string);

    // Print the LLH position info (even if it hasn't been set yet!)
    sprintf( string,
             "LLH  = (Lat:%2.5f Lon:%2.5f Hgt:%6.2f)\033[K\n\r\n\r",
             lat,
             lon,
             receiver_llh.hgt);
    uart2_send_string( string);

    // Print out some position.c info
    sprintf( string, "\
State: positioning = %d, last position valid = %d, pr_rdy = %d\n\r\n\r",
             receiver_pos.positioning,
             receiver_pos.valid,
             pr2_data_fresh);
    uart2_send_string( string);

    // beep the bell if we just got busy in position.
    if( receiver_pos.positioning)
    {
        if( !was_positioning)
        {
            sprintf( string, "\007"); // bell code
            uart2_send_string( string);
            was_positioning = 1;
        }
    }
    else
        was_positioning = 0;

    // Now put out a summary of what the hell is going on in the receiver
    uart2_send_string( header);

    // Send out data on all 12 channels if there's no error
    for( ch = 0; ch < N_CHANNELS; ch++)
    {
        switch( CH[ch].state)
        {
            case CHANNEL_ACQUISITION:
                channel_state = 'A';
                break;
            case CHANNEL_CONFIRM:
                channel_state = 'C';
                break;
            case CHANNEL_PULL_IN:
                channel_state = 'P';
                break;
            case CHANNEL_LOCK:
                channel_state = 'L';
                break;
            default:
                channel_state = '-';
                break;
        }

        if( (pr[ch].valid) && ephemeris[ch].valid)
        {
            az = sat_azel[ch].az * RADTODEG;
            el = sat_azel[ch].el * RADTODEG;

            sprintf( string,
//                      "%2d: %2d %c  %d   %d  % e %3.f %3.f %.3e %.3e %.3e\033[K\n\r",
                     "%2d: %2d %c  %d   %d  % e  %5.1f %5.1f\033[K\n\r",
                     ch,
                     CH[ch].prn,
                     channel_state,
                     pr[ch].valid,
                     ephemeris[ch].valid,
                     pr[ch].range,
                     el,
                     az);
//                      sat_pos_by_ch[ch].x,
//                      sat_pos_by_ch[ch].y,
//                      sat_pos_by_ch[ch].z);
            uart2_send_string( string);
        }
        else
        {
            sprintf( string,
                     "%2d: %2d %c  %d   %d\033[K\n\r",
                     ch,
                     CH[ch].prn,
                     channel_state,
                     pr[ch].valid,
                     ephemeris[ch].valid);
            uart2_send_string( string);
        }
    }
#endif // POSITION_DISPLAY
}


/******************************************************************************
 * Display pseudorange info
 ******************************************************************************/
static void
display_pseudorange( void)
{
#ifdef ENABLE_PSEUDORANGE_DISPLAY

    unsigned short ch;
    unsigned char channel_state;
    char header[] =
            "\033[HCH: PN S bit%50 eb ems Pseudorange Average\n\r";
    char string[80];

    uart2_send_string( header);

    // Send out data on all 12 channels if there's no error
    for( ch = 0; ch < N_CHANNELS; ch++)
    {
        switch( CH[ch].state)
        {
            case CHANNEL_ACQUISITION:
                channel_state = 'A';
                break;
            case CHANNEL_CONFIRM:
                channel_state = 'C';
                break;
            case CHANNEL_PULL_IN:
                channel_state = 'P';
                break;
            case CHANNEL_LOCK:
                channel_state = 'L';
                break;
            default:
                channel_state = '-';
                break;
        }

        if( pr[ch].valid)
        {
            sprintf( string,
                    "%2d: %2d %c %6ld %2d %2d  %e %5ld\033[K\n\r",
                    ch,
                    pr[ch].prn,
                    channel_state,
                    pr[ch].bit_time,
                    pr[ch].epoch_20ms,
                    pr[ch].epoch_1ms,
                    pr[ch].range,
                    CH[ch].avg);
            uart2_send_string( string);
        }
        else
        {
            sprintf( string,
                    "%2d: %2d %c\033[K\n\r",
                    ch,
                    pr[ch].prn,
                    channel_state);
            uart2_send_string( string);
        }

    }
#endif // PSEUDORANGE_DISPLAY
}


/******************************************************************************
 * Display ephemeris_thread info
 ******************************************************************************/
static void
display_ephemeris( void)
{
#ifdef ENABLE_EPHEMERIS_DISPLAY

    unsigned short ch;
    char string[120];
    char header0[] = "\033[H\
CH: PN V UR HE IODC  ------tgd------ ------toc------\033[K\n\r";
    char header1[] ="\033[H\
CH: ------af2------ ------af1------ ------af0------\033[K\n\r";
    char header2[] ="\033[H\
CH: IODE ------Crs------ ------dn------- ------Mo------- ------Cuc------\033[K\n\r";
    char header3[] = "\033[H\
CH: ------e-------- ------Cus------ ------sqA------ --toe--\033[K\n\r";
    char header4[] = "\033[H\
CH: ------cic------ ------w0------- ------cis------ ------inc0-----\033[K\n\r";
    char header5[] = "\033[H\
CH: ------crc------ ------w-------- ---omegadot---- ------idot-----\033[K\n\r";

    if( ephemeris_mode == 0)
    {
        uart2_send_string( header0);

        for( ch = 0; ch < N_CHANNELS; ch++)
        {
            if( ephemeris[ch].valid)
            {
                sprintf( string,
                         "%2d: %2d %d %2d %2x %3x % 15e % 15e\033[K\n\r",
                         ch,
                         ephemeris[ch].prn,
                         ephemeris[ch].valid,
                         ephemeris[ch].ura,
                         ephemeris[ch].health,
                         ephemeris[ch].iodc,
                         ephemeris[ch].tgd,
                         ephemeris[ch].toc);
                uart2_send_string( string);
            }
            else
            {
                sprintf( string,
                         "%2d: %2d %d %2d %2x %3x\033[K\n\r",
                         ch,
                         ephemeris[ch].prn,
                         ephemeris[ch].valid,
                         ephemeris[ch].ura,
                         ephemeris[ch].health,
                        ephemeris[ch].iodc);
                uart2_send_string( string);
            }
        }
    }
    else if( ephemeris_mode == 1)
    {
        uart2_send_string( header1);

        for( ch = 0; ch < N_CHANNELS; ch++)
        {
            if( ephemeris[ch].valid)
            {
                sprintf( string,
                         "%2d: % 15e % 15e % 15e\033[K\n\r",
                         ch,
                         ephemeris[ch].af2,
                         ephemeris[ch].af1,
                         ephemeris[ch].af0);
                uart2_send_string( string);
            }
            else
            {
                sprintf( string, "%2d:\033[K\n\r", ch);
                uart2_send_string( string);
            }
        }
    }
    else if( ephemeris_mode == 2)
    {
        uart2_send_string( header2);

        for( ch = 0; ch < N_CHANNELS; ch++)
        {
            if( ephemeris[ch].valid)
            {
                sprintf( string,
                         "%2d: %3x  % 15e % 15e % 15e % 15e\033[K\n\r",
                         ch,
                         ephemeris[ch].iode,
                         ephemeris[ch].crs,
                         ephemeris[ch].dn,
                         ephemeris[ch].ma,
                         ephemeris[ch].cuc);
                uart2_send_string( string);
            }
            else
            {
                sprintf( string, "%2d:\033[K\n\r", ch);
                uart2_send_string( string);
            }
        }
    }
    else if( ephemeris_mode == 3)
    {
        uart2_send_string( header3);

        for( ch = 0; ch < N_CHANNELS; ch++)
        {
            if( ephemeris[ch].valid)
            {
                sprintf( string,
                         "%2d: % 15e % 15e % 15e %6.1f\033[K\n\r",
                         ch,
                         ephemeris[ch].ecc,