X2Sequence.hpp

Go to the documentation of this file.

#pragma ident "$Id: X2Sequence.hpp 2943 2011-10-25 17:17:11Z yanweignss $"


//  X2Sequence.hpp - GPS X2 Sequencer

#ifndef X2SEQUENCE_HPP
#define X2SEQUENCE_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software developed by Applied Research Laboratories at the University of
//Texas at Austin, under contract to an agency or agencies within the U.S. 
//Department of Defense. The U.S. Government retains all rights to use,
//duplicate, distribute, disclose, or release this software. 
//
//Pursuant to DoD Directive 523024 
//
// DISTRIBUTION STATEMENT A: This software has been approved for public 
//                           release, distribution is unlimited.
//
//=============================================================================






   // Local headers

#include "gpstkplatform.h"
#include "PCodeConst.hpp"
#include "mergePCodeWords.h"

namespace gpstk
{
      
      /*
         The following constants are derived in x2EOW.cpp and
         used as literals here.
      */
   const long LENGTH_OF_EOW_OVERLAP =      34;
   const long OVERLAP_WORD_POSITION = 1451897;
      // Maximum number of X2 chips (exclusive of BOW delay chips)
   const long MAX_X2_TEST = 4 * ((XA_COUNT * XA_MAX_EPOCH) + X2A_EPOCH_DELAY); 
      // Maximum number of X2 chips
   const long MAX_X2_COUNT = X2A_EPOCH_DELAY + MAX_X2_TEST;

   class X2Sequence
   {
      public:
         X2Sequence();
         ~X2Sequence( ) {};
    
         static void allocateMemory( );
         static void deAllocateMemory( );
         
         uint32_t operator[]( long i );

         void setEOWX2Epoch( const bool tf );

      private:
         uint32_t *bitsP;
         static uint32_t* X2Bits;
         static uint32_t* X2BitsEOW;
         static uint32_t EOWEndOfSequence[LENGTH_OF_EOW_OVERLAP];
         static bool isInit; 
   };

       /*
          Given a bit position within the X2 sequence (numbered starting at -37),
          return the next 32 bits.  Note: if there are insufficient bits left
          to fill the request, wrap around to the beginning of the sequence.
       */
   inline uint32_t X2Sequence::operator[] ( long i )
   {
      long adjustedCount = i + X2A_EPOCH_DELAY;
   
      uint32_t retArg = 0L;
      int ndx1 = adjustedCount / MAX_BIT;
      int offset = adjustedCount - (ndx1 * MAX_BIT);
      if ( (adjustedCount+MAX_BIT) <= MAX_X2_COUNT )
      {
         if (offset==0) retArg = bitsP[ndx1];
         else           retArg = merge( bitsP[ndx1], bitsP[ndx1+1], offset );
      }
         /*
            Complicated case when coming up to end of sequence.  May have to
            put together parts of up to three words to get 32 bits.  The problem 
            is complicated because the word at the end of the array is partial
            AND the beginning of sequence (BOW) occurs in mid-word due to the
            PRN offset.  Some numbers:
         
            Number of bits available in word N : 25
            Number of bits available in word at BOS : 27
                  
            Possible cases:
            1.) Combine bits from [n-1], [n], and [BOS] - word n will provide
                25 bits.  Therefore, some combination of (n-1,BOS) from the 
                choice of (1,4), (2,3), (3,2), (4,1).
             
            2.) Combine bits from [n-1] and [BOS] - word n-1 will provide 25-5 
                bits.  Therefore, BOS will provide 7-27 bits. 
         
            3.) Combine bits from [n-1], [BOS], and [BOS+1] - word n-1 provides
                4-1 bits.  BOS provides 27 bits (running total to 31-28 bits).
                BOS+1 provides 1-4 bits.
         */
      else
      {
         int numRemainingInSequence = MAX_X2_COUNT - adjustedCount;
         int numRemainingInWord;
         int numFilled = 0;

            // Handle word n-1
         if (ndx1==NUM_X2_WORDS-2)
         {
            numRemainingInWord = MAX_BIT - offset;
            retArg = bitsP[ndx1++] << offset;
            numFilled = numRemainingInWord;
            numRemainingInSequence -= numRemainingInWord;
         }
      
            // Handle word n
         uint32_t temp = bitsP[ndx1];
         numRemainingInWord = numRemainingInSequence;
         temp >>= (MAX_BIT-numRemainingInWord);
         temp <<= (MAX_BIT-(numRemainingInWord+numFilled));
         retArg |= temp;
         numFilled += numRemainingInSequence;
      
            //   Wrap to front.  Recall that "front" is actually bit
            //   37 in sequence due to "beginning of week" delay
         numRemainingInWord = (2 * MAX_BIT) - X2A_EPOCH_DELAY;
         int numNeeded = MAX_BIT - numFilled;
      
            // Case where all bits needed are in word 1 of sequence array
            //(which only has 27 "useful" bits)
         if (numNeeded <= numRemainingInWord)
         {
            temp = bitsP[1] << (MAX_BIT - numRemainingInWord);
            temp >>= (MAX_BIT - numNeeded);
            retArg |= temp;
         }
            // Case where all bits in word 1 are needed plus some bits in word 2.
         else
         {
               // Clearing high-order bits
            temp = bitsP[1] << (MAX_BIT - numRemainingInWord);
            temp >>= (MAX_BIT - numRemainingInWord);
            temp <<= (MAX_BIT - (numRemainingInWord+numFilled));
            retArg |= temp;
         
               // Fetch remaining bits from next word 
            numFilled += numRemainingInWord;
            numNeeded = MAX_BIT - numFilled;
            temp = bitsP[2] >> (MAX_BIT - numNeeded);
            retArg |= temp;
         }
      }
      return(retArg);
   }
}  // end of namespace

#endif // X2SEQUENCE_HPP

---