dispfun.c

GPS导航定位程序

    for(i=0; i<=MainTask; ++i)
    {
        PROTECT++; /* Ensure indivisible access to TCB */
        /* Compute the maximum observed stack usage.  Note that Borland
           uses a hidden 512 bytes at the bottom of the stack segment for
           floating point scratch, so account for this usage, too. */
        StkUsagePct = 100.0*(TCB[i].STRTSP-TCB[i].MinSP+512)
                      / TCB[i].STRTSP;
        sprintf(buff,"%2d%10s%15s %5u %5u %5u  %5u %2u%% %15s",
                i,TCB[i].TNAME,TCB[i].ProcName,TCB[i].UserCheckpoint,
                TCB[i].Active,RemainingSuspendInterval[i],TCB[i].Slices,
                StkUsagePct,TCB[i].Comment);
        PROTECT--;
        OutputString(3,8+i,buff);
    }
}

/****************************************************************************    
* Function: void F10_Display(void)
*
* The display obtained by pressing key F10.
*
* Input: None.
*
* Output: None.
*
* Return Value: None.
****************************************************************************/
void F10_Display(void)
{
    char buff[90];

    OutputString(31,6,"Data Logging Status");

    if(fpDataLog!=NULL)
    {
        sprintf(buff,"Data log file         : %s         ",DataLogFile);
        OutputString(3,8,buff);
    }
    else
        OutputString(3,8,"Data log file         : <no file>   ");

    if(DataLogSerial==TRUE) 
        OutputString(3,9,"Data logging to COM1  : Active  ");
    else
        OutputString(3,9,"Data logging to COM1  : Inactive");

    sprintf(buff,"Records logged        : %ld       ",DataRecordsLogged);
    OutputString(3,10,buff);

    sprintf(buff,"Logging interval      : %ld sec     ",DataLogInterval);
    OutputString(3,11,buff);

    OutputString(3,14,"Commands pertaining to simple data logging:");
    OutputString(3,15," LF filename  open log file (no name to close file)");
    OutputString(3,16," LI n         log at intervals of n seconds");
    OutputString(3,17," LS           toggle serial port (COM1) output");
}

/****************************************************************************    
* Function: void F11_Display(void)
*
* The display obtained by pressing key F11.
*
* Input: None.
*
* Output: None.
*
* Return Value: None.
****************************************************************************/
void F11_Display(void)
{
#define MaxAlmPage 35

    int year,month,day,hour,minute;
    int prn,nav_health,signal_health;
    int prnstart,prnstop,rowoffset;

    double second;

    char datetime[20],nav_health_msg[5],signal_health_msg[5],msg[78],
         buff[90];

    almstruc A;

    if(AlmPage<0)
        AlmPage=MaxAlmPage;
    else if(AlmPage>MaxAlmPage)
        AlmPage=0;

    if(AlmPage==0 || AlmPage==1 || AlmPage==2 || AlmPage==3)
    {
        OutputString(3,6,"SATELLITE ALMANAC STATUS                  "
                   "         PageUp/PageDown to Scroll");
        sprintf(buff,"PRN      Reference Time        Validity     Nav Health"
                     "    Signal Health");
        OutputString(3,8,buff);                           

        switch(AlmPage)
        {
            case 0:
                prnstart = 1;
                prnstop = 10;
                rowoffset = 0;
                break;
            case 1:
                prnstart = 10;
                prnstop = 19;
                rowoffset = 9;
                break;
            case 2:
                prnstart = 19;
                prnstop = 28;
                rowoffset = 18;
                break;
            case 3:
                prnstart = 28;
                prnstop = 33;
                rowoffset = 27;
                break;
        }

        for(prn=prnstart;prn<prnstop;prn++)
        {
            PROTECT++;  /* Indivisible access to the SV's almanac entry */
            A = alms[prn-1];
            PROTECT--;

            GpsTimeToGregorianDate(A.refweek,A.toa,
                                   &year,&month,&day,&hour,&minute,&second);
            sprintf(datetime,"%2.2d:%2.2d:%2.2d %2.2d/%2.2d/%4.4d",
                    hour,minute,(int)second,day,month,year);

            nav_health = (A.almhlth>>5)&0x0003;
            if(nav_health)
                sprintf(nav_health_msg," Bad");
            else
                sprintf(nav_health_msg,"Good");

            signal_health = (A.almhlth)&0x001F;
            if(signal_health)
                sprintf(signal_health_msg," Bad");
            else
                sprintf(signal_health_msg,"Good");

            switch(A.vflg)
            {
                case 0:
                    sprintf(buff,"%c%2.2d    %s      Invalid        %s"
                                 "            %4s",LastAlm==prn?RTARROW:' ',
                              prn,datetime,nav_health_msg,signal_health_msg);
                    break;
                case 1:
                    sprintf(buff,"%c%2.2d    %s       Valid         %s"
                                 "            %4s",LastAlm==prn?RTARROW:' ',
                              prn,datetime,nav_health_msg,signal_health_msg);
                    break;
                case 2:
                    sprintf(buff,"%c%2.2d    %s    Nonexistent      %s"
                                 "            %4s",LastAlm==prn?RTARROW:' ',
                              prn,datetime,nav_health_msg,signal_health_msg);
                    break;
                default:
                    sprintf(buff,"%c%2.2d    %s     Invalid Code",
                                      LastAlm==prn?RTARROW:' ',prn,datetime);
                    break;
            }
            OutputString(3,9+prn-rowoffset,buff);
        }
    } 
    else
    {
        PROTECT++;
        A = alms[AlmPage-4];
        PROTECT--;
        
        GpsTimeToGregorianDate(A.refweek,A.toa,
                               &year,&month,&day,&hour,&minute,&second);
        sprintf(datetime,"%2.2d:%2.2d:%2.2d %2.2d/%2.2d/%4.4d",
                hour,minute,(int)second,day,month,year);

        sprintf(buff,"SATELLITE ALMANAC STATUS FOR PRN%2.2d         "
                   "     PageUp/PageDown to Scroll",AlmPage-3);
        OutputString(3,6,buff);

        if(A.vflg==0)
            sprintf(buff,"Almanac Validity = No Information");
        else if(A.vflg==1)
            sprintf(buff,"Almanac Validity = Valid Almanac at %s",datetime);
        else if(A.vflg==2)
            sprintf(buff,"Almanac Validity = Nonexistent Satellite");
        else
            sprintf(buff,"Almanac Validity = Validity Code Not Recoqnised");
        OutputString(3,8,buff);

        if(A.vflg==1)
        {
            sprintf(buff,"Semi-Major Axis = %9.3lf km",
                                                   (A.sqrta*A.sqrta)/1000.0);
            OutputString(3,9,buff);

            sprintf(buff,"Eccentricity = %8.6lf",A.ecc);
            OutputString(3,10,buff);

            sprintf(buff,"Inclination = %9.6lf %c",A.inclin*R2D,DEGREE);
            OutputString(3,11,buff);

            sprintf(buff,"Right Ascension = %11.6lf %c",A.ratoa*R2D,DEGREE);
            OutputString(3,12,buff);
        
            sprintf(buff,"Right Ascension Rate = %11.6e %c/s",
                                                          A.rora*R2D,DEGREE);
            OutputString(3,13,buff);
        
            sprintf(buff,"Mean Anomaly = %11.6lf %c",A.manom*R2D,DEGREE);
            OutputString(3,14,buff);
        
            sprintf(buff,"Argument of Perigee = %11.6lf %c",
                                                         A.argpg*R2D,DEGREE);
            OutputString(3,15,buff);

            sprintf(buff,"Clock Offset = %11.6e s, Clock Drift = %11.6e s/s",
                    A.af0,A.af1);
            OutputString(3,16,buff);

            nav_health = (A.almhlth>>5)&0x0003;
            signal_health = (A.almhlth)&0x001F;

            switch(nav_health)
            {
                case 0:
                    sprintf(msg,"All Data OK");
                    break;
                case 1:
                    sprintf(msg,"Parity Failure");
                    break;
                case 2:
                    sprintf(msg,"TLM/HOW Format Problem");
                    break;
                case 3:
                    sprintf(msg,"Z-Count in HOW Bad");
                    break;
                case 4:
                    sprintf(msg,"Subframes 1,2 or 3 Bad");
                    break;
                case 5:
                    sprintf(msg,"Subframes 4 or 5 Bad");
                    break;
                case 6:
                    sprintf(msg,"All Upload Data Bad");
                    break;
                case 7:
                    sprintf(msg,"All Data Bad");
                    break;
                default:
                    sprintf(msg,"Unrecognised Error Number");
            }
            sprintf(buff,"Navigation Health Status is: %s",msg);
            OutputString(3,17,buff);

            switch(signal_health)
            {
                case 0:
                    sprintf(msg,"All Signals OK");
                    break;
                case 1:
                    sprintf(msg,"All Signal Weak");
                    break;
                case 2:
                    sprintf(msg,"All Signal Dead");
                    break;
                case 3:
                    sprintf(msg,"All Signals Have No Data Modulation");
                    break;
                case 4:
                    sprintf(msg,"L1 P Signal Weak");
                    break;
                case 5:
                    sprintf(msg,"L1 P Signal Dead");
                    break;
                case 6:
                    sprintf(msg,"L1 P Signal Has No Data Modulation");
                    break;
                case 7:
                    sprintf(msg,"L2 P Signal Weak");
                    break;
                case 8:
                    sprintf(msg,"L2 P Signal Dead");
                    break;
                case 9:
                    sprintf(msg,"L2 P Signal Has No Data Modulation");
                    break;
                case 10:
                    sprintf(msg,"L1 C Signal Weak");
                    break;
                case 11:
                    sprintf(msg,"L1 C Signal Dead");
                    break;
                case 12:
                    sprintf(msg,"L1 C Signal Has No Data Modulation");
                    break;
                case 13:    
                    sprintf(msg,"L2 C Signal Weak");
                    break;
                case 14:
                    sprintf(msg,"L2 C Signal Dead");
                    break;
                case 15:
                    sprintf(msg,"L2 C Signal Has No Data Modulation");
                    break;
                case 16:
                    sprintf(msg,"L1 & L2 P Signal Weak");
                    break;
                case 17:
                    sprintf(msg,"L1 & L2 P Signal Dead");
                    break;
                case 18:
                    sprintf(msg,"L1 & L2 P Signal Has No Data Modulation");
                    break;
                case 19:
                    sprintf(msg,"L2 & L2 C Signal Weak");
                    break;
                case 20:
                    sprintf(msg,"L2 & L2 C Signal Dead");
                    break;
                case 21:
                    sprintf(msg,"L2 & L2 C Signal Has No Data Modulation");
                    break;
                case 22:
                    sprintf(msg,"L1 Signal Weak");
                    break;
                case 23:
                    sprintf(msg,"L1 Signal Dead");
                    break;
                case 24:
                    sprintf(msg,"L1 Signal Has No Data Modulation");
                    break;
                case 25:
                    sprintf(msg,"L2 Signal Weak");
                    break;
                case 26:
                    sprintf(msg,"L2 Signal Dead");
                    break;
                case 27:
                    sprintf(msg,"L2 Signal Has No Data Modulation");
                    break;
                case 28: