Abstract:
Disclosed is an efficient and configurable apparatus and method for sample rate conversion using interpolation. The apparatus and method employ a configuration file to change the conversion coefficients, sampling rate, and interpolation algorithm without having to recompile control software and/or reprogram the controlled device. In some embodiments, the interpolation employs polynomial interpolation, which may include Lagrange interpolation. In some embodiments, the interpolation method is selected to minimize the loop delay in teleoperation applications.

Description:
GOVERNMENT SUPPORT NOTICE 
     This invention was made with government support under Contract No. W56HZV-05-C-0724 and Subcontract No. 5EC8377H, awarded by the U.S. Army. The government has certain rights in the invention. 
    
    
     COPYRIGHT NOTICE 
     Portions of the disclosure of this patent document contain material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. 
     BACKGROUND 
     In remote teleoperation of unmanned ground vehicles (UGVs), an operator uses a joystick to point sensors and steer the vehicle. Commands from these joysticks and other control devices are communicated to the UGV via radio waves or other systems generally known in the art. These control signals are received by the UGV and used to control the UGV and/or its sensors and payloads, generally referred to herein as “onboard subsystems.” Very often the onboard subsystem sampling rates required are greater than the sample rates that can be sent over a data link, and it is therefore necessary to perform a sample rate conversion. One typical application of sample rate conversion (SRC) may be performed (for example) onboard the UGV, as shown in  FIG. 1 . Operator  110  uses controller  120  to control UGV  130  via a wired tether or other means  140 , including wireless communications systems known to one of ordinary skill in the art. Anti-aliasing filter  150  samples joystick  155  data at a sample rate of F in  and communicates the position input data to UGV  130  over link  140 . Sample rate F in  is up-converted to the UGV&#39;s required sample rate F out  in converter  160  to control the onboard subsystems. 
     Sample rate conversions (SRC) of this sort are well known, as (for example) described in Schafer (Ronald W. Schafer and Lawrence R. Rabiner, “A Digital Signal Processing Approach to Interpolation,” Proceedings of the IEEE, vol. 61, no. 6, June 1973, pp. 692-702). Schafer considered the case of two-point linear interpolation and showed that the digital FIR implementation of the SRC has a triangular impulse response. Schafer also considered the general Lagrange interpolator and noted that for odd degree the filter was not linear phase. The Schafer reference, however, did not present a compact and configurable implementation for any of general Lagrange interpolations. Similarly, Ramstad (Tor A. Ramstad, “Digital Methods for Conversion Between Arbitrary Sampling Frequencies,” IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. ASSP-32, no. 3, June 1984, pp. 577-591 has noted that when the SRC rate is rational, the coefficients required are periodic and can be precomputed. But this paper does not present any method for the generation of the coefficients. 
     In most cases of sample rate conversion, the group delay of the filter is less important than signal fidelity. However, in remote teleoperation it is desirable to keep the loop delay to a minimum to insure that the vehicle remains controllable, and the SRC filter group delay should also be made as small as possible. 
     One problem seen in the prior art is that as sensors and payloads change and evolve, different sample rate conversions are required. Not only do the input sample rates change as controllers evolve, but the requirements on F out  vary widely as different sensors or other payloads are incorporated on the UGV. Currently, the control software on the UGV is implemented monolithically as dedicated block of code including the SRC computation algorithms. SRC parameters are typically hard coded into the software. This necessitates re-writing and re-compiling the controller code every time the SRC needs to be changed. What is needed is a rapidly reconfigurable sample rate conversion method that allows rapid changes to the SRC parameters without requiring recompiling the control software. 
     SUMMARY 
     Presently described is a configurable architecture for a variable parameter sample rate conversion (SRC) system that allows for easy and rapid re-parameterization of the interpolation algorithms without requiring software recompilation. This architecture allows the system operators to reconfigure payload and onboard sensor subsystems of a remote device, such as an unmanned ground vehicle (UGV) or other teleoperated device, without having to re-write and recompile any control software. Changes to the SRC parameters, even to the point of selecting different-order Lagrange interpolations, may be accomplished solely by commanding the use of one of a plurality of pre-defined configuration files stored in the remote device. 
     Architectures constructed according to the systems, methods, and principles of this disclosure can change the relative sample rate ratio and/or the interpolation algorithms by choosing from among a plurality of pre-defined configuration files. A control program operating on and in a controller reads the parameters particular to the subsystem of interest from the configuration file and uses them to interpolate the output samples. The interpolation is performed according to the selected Lagrange algorithm (or method) on each sample. 
     In some embodiments, when an onboard sensor or other subsystem is changed or adjusted, the operators need only generate a new configuration file from the desired sample rate parameters (i.e., the input and output sample rates and the interpolation algorithm appropriate to the onboard subsystem and data rates) and upload it to the remote device&#39;s onboard controller. Since the algorithms for generating the configuration file are designed to minimize the group delay for the given sample rate ratio, this architecture provides a flexible and reconfigurable solution for the SRC problem without having to recompile the control software on the remote device. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The foregoing and other objects, features and advantages of the invention will be apparent from the following description of particular embodiments of the invention, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the invention. 
         FIG. 1  is a block diagram of a prior art sample rate conversion (SRC) system. 
         FIG. 2  is a block diagram of a prior art fractional rate SRC. 
         FIG. 3  is an interpolation timing diagram for a sample and hold interpolation algorithm, according to one embodiment of the present invention. 
         FIG. 4  is plot of a 5 Hz control signal showing input samples at 50 Hz (circles) and output samples at 120 Hz (crosses) for a sample and hold interpolator operating at rate 12/5 SRC, according to one embodiment of the present invention. 
         FIG. 5  is an interpolation timing diagram for a two-point linear interpolation algorithm for the case when L=12 and M=5, according to one embodiment of the present invention. 
         FIG. 6  is a plot of a 5 Hz control signal showing input samples at 50 Hz (circles) and output samples at 120 Hz (crosses) for two-point linear interpolation in a rate 12/5 SRC, according to one embodiment of the present invention. 
         FIG. 7  is an interpolation timing diagram for a quadratic interpolation algorithm for the case when L=12 and M=5, according to one embodiment of the present invention. 
         FIG. 8  is a plot of a 5 Hz control signal showing input samples at 50 Hz (circles) and output samples at 120 Hz (crosses) for quadratic interpolation in a rate 12/5 SRC, according to one embodiment of the present invention. 
         FIG. 9  is a flowchart of a high-level SRC process according to one embodiment of the present invention. 
         FIG. 10  is a flowchart of the interpolation step  940  of the illustrated in  FIG. 9 . 
         FIG. 11  is a block diagram of a UGV system configured to perform SRC according to one embodiment of the present invention. 
         FIG. 12  is a block diagram of a vehicle platform blade (i.e., the SRC processor) according to one embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     In this disclosure, we present an efficient and easily configurable method for sample rate conversion (SRC) using Lagrange interpolation algorithms for arbitrary rational sample rate ratios where the group delay is maintained as small as possible. In some representative embodiments, the SRC is accomplished using data stored in one or more of a plurality of candidate configuration files, where different configuration files may be used to provide SRC at different F out /F in  ratios and using different interpolation algorithms. (The ratio F out /F in  is also referred to herein as the conversion rate.) In other embodiments, a single file with multiple sections (each comprising the filter or interpolation coefficients needed for a particular interpolation algorithm and conversion ratio) may be used. 
     Such configuration files may contain the interpolation or filter coefficients and the interpolation algorithm to apply for each sample rate conversion ratio needed. Hence, any change in F in  or F out  can be accommodated by changing the configuration file. Similarly, any change in the anti-imaging performance required by the SRC can also be realized by changing the configuration file. The fractional rate interpolation algorithms considered herein include a sample and hold, two-point linear interpolation (i.e. 1 st  order Lagrange), and parabolic (i.e. 2 nd  order Lagrange) interpolation, but the method is easily extended to any higher order Lagrange interpolator. Accordingly, although specific interpolators and interpolation algorithms are described, those skilled in the art will realize that interpolators and/or interpolation algorithms other than sample and hold, two-point linear, or higher order Lagrange-type methods can also be used. Accordingly, the concepts, systems, and techniques described herein are not limited to use with any particular type of interpolator. 
     Embodiments of the present apparatus and method are directed to techniques for SRC that reduce or in some cases even minimize group delay in associated filters while permitting rapid selection of alternate sample rates and/or interpolation algorithms using pre-determined configuration data files stored in a memory. Using an interpolation factor L and a decimation factor M as parameters and an operator-selected Lagrange interpolation appropriate to the application, this architecture provides for embodiments that can generate configuration files containing key lookup parameters for use in the rapid interpolation of output samples. 
     As noted above, in most SRC implementations, filter group delay is less important than signal fidelity. However, in remote teleoperation in particular, the loop delay between an operator/controller and an unmanned ground vehicle (UGV) should be minimized to insure that the vehicle remains controllable, and in these situations, the SRC filter group delay should be made as small as possible. The factors are determined in part by the types of sensors or payloads being commanded, the input control devices, and the type of interpolation algorithm selected. The sample image rejection needed by the operator also affects these choices, but the proper calculation of the configuration parameters used by the below-described architecture ensures that group delay is kept as small as possible. 
     To illustrate a typical implementation of sample rate conversion (as, for example but not by way of limitation, in a UGV application), consider a general sample rate conversion (SRC) where the input and output rates are not related by an integer. When the input X N  sample rate is 50 Hz and the required output sample rate is 120 Hz, the fractional conversion rate is L/M=12/5. Referring to  FIG. 2 , such an SRC may be implemented with system  200 . System  200  consists of up-sampler  210  operating at integer rate L. The up-sampled signal is filtered by filter  220  (for example, a FIR filter). The filtered output is then down-sampled at integer rate M by decimator  230  to produce output signal Y k . 
     An efficient and configurable SRC implementation is described below for three types of Lagrange interpolations: sample and hold, two-point linear interpolation, and quadratic interpolation. In each case considered below, it is shown that the group delay of the SRC filter is equal to one-half the input sample period. 
     The sample and hold interpolation algorithm holds and repeats the most recent input sample to obtain the higher output sample rate. Referring to  FIG. 3 , for input sample rate F in  and output sample rate F out , it is possible to calculate the times at which each input sample must be repeated.  FIG. 3  represents the input and output sample timing by slicing time (the horizontal axis) into frames  305 A through  305 E. Circles  310 A,  310 B, . . . ,  310 E represent input samples, i.e., the command signals from the controller arriving at rate F in . Circles  320 A,  320 B, . . . ,  320 M represent output samples that are sent to the sensor/payload at rate F out . Note that the most recent input sample  310  is used repeatedly, until a new input sample arrives. So, for example, input sample  310 A is sent out ( 320 A) at time zero, time 1/F out  ( 320 B), and time 2/F out  ( 320 C); input sample  310 B (X 1 ) at time 3/F out  ( 320 D) and time 4/F out  ( 320 E); and sample  310 C goes at time 5/F out  ( 320 F), time 6/F out  ( 320 G), and time 7/F out  ( 320 H), and so on. At time 5/Fin, the pattern repeats, since this is an example of sample conversion rate of 12/5; output sample  320 M is therefore the first sample of the next five frames. 
     In each frame, the next input sample (e.g.,  310 F,  310 G, . . .  310 J on the far right of each row) has not yet arrived. 
     The time t in  FIG. 3  between the current input sample and the output sample in the n th  frame is given by: 
             t   =         m   -   1       F   out       -     n     F     i   ⁢           ⁢   n                 
as shown in Table 1 for F in =50 Hz and F out =120 Hz, where m is the output frame index and n is the input frame index.
 
     
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Lookup table for sample and hold 
               
               
                 output times for rate 12/5 SRC. 
               
             
          
           
               
                 m 
                 n 
                 t (sec) 
               
               
                   
               
             
          
           
               
                 1 
                 0 
                 0.000000 
               
               
                 2 
                 0 
                 0.008333 
               
               
                 3 
                 0 
                 0.016667 
               
               
                 4 
                 1 
                 0.005000 
               
               
                 5 
                 1 
                 0.013333 
               
               
                 6 
                 2 
                 0.001667 
               
               
                 7 
                 2 
                 0.010000 
               
               
                 8 
                 2 
                 0.018333 
               
               
                 9 
                 3 
                 0.006667 
               
               
                 10 
                 3 
                 0.015000 
               
               
                 11 
                 4 
                 0.003333 
               
               
                 12 
                 4 
                 0.011667 
               
               
                   
               
             
          
         
       
     
     The m and n values from this lookup table may then be incorporated in a configuration file used to produce an output sequence of samples at the desired output rate from input samples with the sample and hold method. In one exemplary embodiment, only the n column is included in the configuration file because the m column is functioning as a counter. Thus the configuration file contains at least column n and an identifier of the interpolation algorithm. For sample and hold, the interpolation coefficients are all equal to unity because the sample is being held and not modified. 
     The software code of Table 2 is an exemplar MATLAB implementation for performing sample and hold interpolation SRC at a rate ratio of 12/5. The values for TOUT are generated based on the output sample rate. 
     Although a software implementation of this method (and other variations, discussed below) is described in MATLAB, those skilled in the art will realize that other implementations, in other software languages and in hardware, software, or a combination thereof can also be used. Accordingly, the concepts, systems, and techniques described herein are not limited to any particular software language or even to a software-only implementation. 
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 2 
               
               
                   
               
               
                 MATLAB implementation of rate 12/5  
               
               
                 SRC for sample and hold interpolation 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                   
                 %-- copyright © 2010 Raytheon Company 
                   
               
               
                   
                   
                 tout = 1/Fout; 
                   
               
               
                   
                   
                 L = 12; 
                   
               
               
                   
                   
                 M = 5; 
                   
               
               
                   
                   
                 k = 1; 
                   
               
               
                   
                   
                 for n=0:length(yin)−1 
                   
               
               
                   
                   
                  if n&gt;0, 
                   
               
               
                   
                   
                   nn = mod(n−1,M); 
                   
               
               
                   
                   
                   out = [ ]; 
                   
               
               
                   
                   
                   while (k&lt;=L)&amp;(config(k,1)==nn) 
                   
               
               
                   
                   
                    x0 = yin(n); 
                   
               
               
                   
                   
                    YOUT = [YOUT x0]; 
                   
               
               
                   
                   
                    dum = TOUT(end); 
                   
               
               
                   
                   
                    TOUT = [TOUT dum+tout]; 
                   
               
               
                   
                   
                    k = k + 1; 
                   
               
               
                   
                   
                   end 
                   
               
               
                   
                   
                   if k==L+1, k = 1; end 
                   
               
               
                   
                   
                  end 
                   
               
               
                   
                   
                 end 
               
               
                   
                   
               
             
          
         
       
     
     The sample and hold interpolation output is shown in  FIG. 4  for an exemplar 5 Hz control signal (solid curve). The input sample rate is 50 Hz; the input samples are represented by circles  410 . The output sample rate is 120 Hz; crosses  420  represent the output samples. Although a particular control signal and sampling rates are described, those skilled in the art will realize that various sampling rates and representative control signals other than those illustrated may be used. Accordingly, the concepts, systems, and techniques described herein are not limited to any particular control signal, input, and/or output sample rates. (For clarity in the drawing, not all output samples are visible because all samples within each frame have the same magnitude.) 
     In the two-point linear interpolation algorithm, one needs to consider an input sample rate F in  and an output sample rate F out  such that 
                 F   out       F     i   ⁢           ⁢   n         =     L   M           
such that L and M are relatively prime integers. It follows that
 
               L     F   out       =     M     F     i   ⁢           ⁢   n               
and the M th  input sample occurs at the same time as the L th  output sample. This is shown in  FIG. 5  for two-point linear interpolation where the circles  510 A,  510 B, . . . ,  510 E represent input samples and circles  520 A,  520 B,  520 C, etc., represent output samples. In general, there will be M frames in two-point linear interpolation and L rows in the interpolation table.
 
     To see how many rows in the interpolation table are generated in each frame, note that we are looking for the indices l such that 
                 m   -   1       F     i   ⁢           ⁢   n         ≤     l     F   out       &lt;     m     F     i   ⁢           ⁢   n               
in frame m. From this relation it follows that
 
                 L   ⁡     (     m   -   1     )       M     ≤   l   &lt;       L   ⁢           ⁢   m     M           
from which
 
               l   =     ceil   ⁡     (       L   ⁡     (     m   -   1     )       M     )         ,   L   ,     floor   ⁡     (     Lm   M     )             
where ceil(x) is the nearest integer greater than or equal to x and floor(x) is the nearest integer less than or equal to x. The interpolated output sample is given by
 
 y   l   =aX   m   +bX   m+1 
 
where l is the output sample index and m is the input frame index. To determine the coefficients a and b in the interpolation table for row l in frame m note that, by similar triangles,
 
                   y   l     -     X     m   -   1             X   m     -     X     m   -   1           =         l     F   out       -       m   -   1       F     i   ⁢           ⁢   n             1     F     i   ⁢           ⁢   n                 
from which
 
     
       
         
           
             
               y 
               l 
             
             = 
             
               
                 
                   [ 
                   
                     1 
                     - 
                     
                       ( 
                       
                         
                           
                             M 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             l 
                           
                           L 
                         
                         - 
                         
                           ( 
                           
                             m 
                             - 
                             1 
                           
                           ) 
                         
                       
                       ) 
                     
                   
                   ] 
                 
                 ⁢ 
                 
                   X 
                   
                     m 
                     - 
                     1 
                   
                 
               
               + 
               
                 
                   [ 
                   
                     
                       
                         M 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         l 
                       
                       L 
                     
                     - 
                     
                       ( 
                       
                         m 
                         - 
                         1 
                       
                       ) 
                     
                   
                   ] 
                 
                 ⁢ 
                 
                   
                     X 
                     m 
                   
                   . 
                 
               
             
           
         
       
     
     Hence, 
             b   =     [         M   ⁢           ⁢   l     L     -     (     m   -   1     )       ]           
and a=1−b. Note that the indexing on l starts at 0.
 
     An exemplar MATLAB script to generate a configuration file (also referred to herein as a lookup table) for two-point linear interpolation is shown in Table 3. Examples of the output parameters a and b (the interpolation coefficients) for various SRC rate conversions are shown in Tables 4, 5, and 6. Note that the exemplar code for generating the configuration files in all cases (see, e.g., MATLAB scripts in Tables 3 and 8) is designed to minimize the group delay by interpolating the output samples between the two most recent input samples, resulting in a group delay equal to half of the input sample rate. 
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 3 
               
               
                   
               
               
                 MATLAB script to generate lookup tables for  
               
               
                 two-point linear interpolation 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 %-- copyright © 2010 Raytheon Company 
                   
               
               
                   
                 %-- generate config file for rate L/M 
                   
               
               
                   
                 %-- there are L rows and M “frames” where a “frame” consists of 
                   
               
               
                   
                 %-- all the output samples bracketed by 2 adjacent input samples 
                   
               
               
                   
                 L = 8; 
                   
               
               
                   
                 M = 3; 
                   
               
               
                   
                 for m=1:M %--loop on frame number 
                   
               
               
                   
                  upper = floor(L*m/M); 
                   
               
               
                   
                  if upper==(L*m/M), upper = upper−1; end 
                   
               
               
                   
                  for l=ceil(L*(m−1)/M):upper 
                   
               
               
                   
                   b = (M*l/L)−m+1; 
                   
               
               
                   
                   a = 1−b; 
                   
               
               
                   
                   if l&lt;L, fprintf(1, ′ %d\t%f\t%f\t%d\n′,l+1,m−1,a,b); end 
                   
               
               
                   
                  end 
                   
               
               
                   
                 end 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
               
             
               
               
               
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Example for rate 12/5 (50 Hz to 120 Hz) 
               
             
          
           
               
                   
                 m 
                 n 
                 a 
                 b 
               
               
                   
                   
               
             
          
           
               
                   
                 1 
                 0 
                 1.000000 
                 0.000000 
               
               
                   
                 2 
                 0 
                 0.583333 
                 0.416667 
               
               
                   
                 3 
                 0 
                 0.166667 
                 0.833333 
               
               
                   
                 4 
                 1 
                 0.750000 
                 0.250000 
               
               
                   
                 5 
                 1 
                 0.333333 
                 0.666667 
               
               
                   
                 6 
                 2 
                 0.916667 
                 0.083333 
               
               
                   
                 7 
                 2 
                 0.500000 
                 0.500000 
               
               
                   
                 8 
                 2 
                 0.083333 
                 0.916667 
               
               
                   
                 9 
                 3 
                 0.666667 
                 0.333333 
               
               
                   
                 10 
                 3 
                 0.250000 
                 0.750000 
               
               
                   
                 11 
                 4 
                 0.833333 
                 0.166667 
               
               
                   
                 12 
                 4 
                 0.416667 
                 0.583333 
               
               
                   
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 5 
               
             
             
               
                   
               
               
                 Example for rate 3/1 (40 Hz to 120 Hz) 
               
             
          
           
               
                   
                 m 
                 n 
                 a 
                 b 
               
               
                   
                   
               
               
                   
                 1 
                 0 
                 1.000000 
                 0.000000 
               
               
                   
                 2 
                 0 
                 0.666667 
                 0.333333 
               
               
                   
                 3 
                 0 
                 0.333333 
                 0.666667 
               
               
                   
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 6 
               
             
             
               
                   
               
               
                 Example for rate 8/3 (45 Hz to 120 Hz) 
               
             
          
           
               
                   
                 m 
                 n 
                 a 
                 b 
               
               
                   
                   
               
               
                   
                 1 
                 0 
                 1.000000 
                 0.000000 
               
               
                   
                 2 
                 0 
                 0.625000 
                 0.375000 
               
               
                   
                 3 
                 0 
                 0.250000 
                 0.750000 
               
               
                   
                 4 
                 1 
                 0.875000 
                 0.125000 
               
               
                   
                 5 
                 1 
                 0.500000 
                 0.500000 
               
               
                   
                 6 
                 1 
                 0.125000 
                 0.875000 
               
               
                   
                 7 
                 2 
                 0.750000 
                 0.250000 
               
               
                   
                 8 
                 2 
                 0.375000 
                 0.625000 
               
               
                   
                   
               
             
          
         
       
     
     An exemplar MATLAB code fragment that generates the output sequence from the input samples is shown in Table 7 where the “config” array consists of the “a,” “b,” and “n” columns in the lookup tables. 
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 7 
               
               
                   
               
               
                 MATLAB implementation of rate L/M SRC 
               
               
                 for two-point linear interpolation. 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                   
                 %-- copyright © 2010 Raytheon Company 
                   
               
               
                   
                   
                 tout = 1/Fout; 
                   
               
               
                   
                   
                 k = 1; 
                   
               
               
                   
                   
                 for n=0:length(yin)−1 
                   
               
               
                   
                   
                  if n&gt;0, 
                   
               
               
                   
                   
                   nn = mod(n−1,M); 
                   
               
               
                   
                   
                   out = [ ]; 
                   
               
               
                   
                   
                   while (k&lt;=L)&amp;(config(k,1)==nn) 
                   
               
               
                   
                   
                    a = config(k,2); b = config(k,3); 
                   
               
               
                   
                   
                    x0 = yin(n); x1 = yin(n+1); 
                   
               
               
                   
                   
                    YOUT = [YOUT a*x0+b*x1]; 
                   
               
               
                   
                   
                    dum = TOUT (end); 
                   
               
               
                   
                   
                    TOUT = [TOUT dum+tout]; 
                   
               
               
                   
                   
                    k = k + 1; 
                   
               
               
                   
                   
                   end 
                   
               
               
                   
                   
                   if k==L+1, k = 1; end 
                   
               
               
                   
                   
                  end 
                   
               
               
                   
                   
                 end 
               
               
                   
                   
               
             
          
         
       
     
     Note that the implementation presented in  FIG. 6  for two-point linear interpolation is easily generalized for the sample and hold or parabolic interpolation by adjusting the number of coefficient columns. An example of this table for the sample and hold is given in Table 1. An example input and output of the two-point linear interpolation SRC implementation is shown in  FIG. 6 . 
     In the quadratic interpolation algorithm, the most recent three samples are fit to a quadratic, and the output samples that lie between the most recent two samples are obtained from this fit, as shown in  FIG. 7 . 
     Consequently, the output sample times used for the sample and hold or the two-point linear interpolation cases are unchanged. Making use of the 2 nd  order Lagrange interpolator described by Schafer and Rabiner (cited above) and Hamming (R. W. Hamming,  Numerical Methods for Scientists and Engineers , New York, McGraw-Hill, 1962, p. 235, (incorporated herein by reference in its entirety), the l th  output sample is given by
 
 y   l   =aX   m−1   +bX   m   +cX   m+1 
 
where l is the output sample index, m is the input frame index, and
 
     
       
         
           
             a 
             = 
             
               
                 d 
                 ⁡ 
                 
                   ( 
                   
                     d 
                     - 
                     1 
                   
                   ) 
                 
               
               / 
               2 
             
           
         
       
       
         
           
             b 
             = 
             
               
                 - 
                 
                   ( 
                   
                     d 
                     + 
                     1 
                   
                   ) 
                 
               
               ⁢ 
               
                 ( 
                 
                   d 
                   - 
                   1 
                 
                 ) 
               
             
           
         
       
       
         
           
             c 
             = 
             
               
                 d 
                 ⁡ 
                 
                   ( 
                   
                     d 
                     + 
                     1 
                   
                   ) 
                 
               
               / 
               2 
             
           
         
       
       
         
           
             d 
             = 
             
               
                 ( 
                 
                   
                     M 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     l 
                   
                   L 
                 
                 ) 
               
               - 
               m 
             
           
         
       
     
     An exemplar MATLAB script to generate the configuration table for the quadratic interpolation algorithm is shown in Table 8. An example of the output for a rate 12/5 SRC is given in Table 9. 
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 8 
               
               
                   
               
               
                 MATLAB script to generate lookup tables  
               
               
                 for quadratic interpolation 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 %-- copyright © 2010 Raytheon Company 
                   
               
               
                   
                 %-- generate quadratic interpolation config file for rate L/M 
                   
               
               
                   
                 %-- there are L rows and M “frames” 
                   
               
               
                   
                 %-- where a “frame” consists of all the output samples 
                   
               
               
                   
                 %-- bracketed by 2 adjacent input samples 
                   
               
               
                   
                 L = 12; 
                   
               
               
                   
                 M = 5; 
                   
               
               
                   
                 for m=1:M %--loop on frame number 
                   
               
               
                   
                  mm = m−1; 
                   
               
               
                   
                  upper = floor(L*m/M);   
                   
               
               
                   
                  if upper==(L*m/M), upper = upper−1; end 
                   
               
               
                   
                  for l=ceil(L*(m−1)/M):upper   
                   
               
               
                   
                   d = (M*l/L)−mm; 
                   
               
               
                   
                   a = d*(d−1)/2;  
                   
               
               
                   
                   b = −(d+1)*(d−1); 
                   
               
               
                   
                   c = d*(d+1)/2; 
                   
               
               
                   
                   if l&lt;L, fprintf(1, ′ %d\t%f\t%f\t%f\t%d\n′,l+1,mm,a,b,c); end 
                   
               
               
                   
                  end 
                   
               
               
                   
                 end 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
               
             
               
               
               
               
               
             
           
               
                 TABLE 9 
               
             
             
               
                   
               
               
                 Example for rate 12/5 (50 Hz to 120 Hz) 
               
             
          
           
               
                 m 
                 n 
                 a 
                 b 
                 c 
               
               
                   
               
             
          
           
               
                 1 
                 0 
                 −0.000000 
                 1.000000 
                 0.000000 
               
               
                 2 
                 0 
                 −0.121528 
                 0.826389  
                 0.295139 
               
               
                 3 
                 0 
                 −0.069444 
                 0.305556  
                 0.763889 
               
               
                 4 
                 1 
                 −0.093750 
                 0.937500  
                 0.156250 
               
               
                 5 
                 1 
                 −0.111111 
                 0.555556  
                 0.555556 
               
               
                 6 
                 2 
                 −0.038194 
                 0.993056  
                 0.045139 
               
               
                 7 
                 2 
                 −0.125000 
                 0.750000  
                 0.375000 
               
               
                 8 
                 2 
                 −0.038194 
                 0.159722  
                 0.878472 
               
               
                 9 
                 3 
                 −0.111111 
                 0.888889  
                 0.222222 
               
               
                 10 
                 3 
                 −0.093750 
                 0.437500 
                 0.656250 
               
               
                 11 
                 4 
                 −0.069444 
                 0.972222  
                 0.097222 
               
               
                 12 
                 4 
                 −0.121528 
                 0.659722  
                 0.461806 
               
               
                   
               
             
          
         
       
     
     An exemplar of the MATLAB code that generates the quadratic interpolation from the configuration table is shown in Table 10. Note that the code structures in Tables 10, 7, and 2 are the same. The difference between them is the calculation of the output sample within the “While” loop. Hence, the same code may be used for any of the interpolation algorithms considered where the method to be applied is selected within the “While” loop by a configuration file parameter. 
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 10 
               
               
                   
               
               
                 MATLAB implementation of rate L/M SRC  
               
               
                 for quadratic interpolation. 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                   
                 %-- copyright © 2010 Raytheon Company 
                   
               
               
                   
                   
                 tout = 1/Fout; 
                   
               
               
                   
                   
                 k = 1; 
                   
               
               
                   
                   
                 for n=0:length(yin)−1 
                   
               
               
                   
                   
                  if n&gt;1, 
                   
               
               
                   
                   
                   nn = mod(n−2,M); 
                   
               
               
                   
                   
                   while (k&lt;=L)&amp;(config(k,1)==nn) 
                   
               
               
                   
                   
                    a = config(k,2); b = config(k,3); c = config(k,4); 
                   
               
               
                   
                   
                    xm1 = yin(n−1); x0 = yin(n); xp1 = yin(n+1); 
                   
               
               
                   
                   
                    YOUT = [YOUT a*xm1+b*x0+c*xp1]; 
                   
               
               
                   
                   
                    dum = TOUT(end); 
                   
               
               
                   
                   
                    TOUT = [TOUT dum+tout]; 
                   
               
               
                   
                   
                    k = k + 1; 
                   
               
               
                   
                   
                   end 
                   
               
               
                   
                   
                   if k==L+1, k = 1; end 
                   
               
               
                   
                   
                  end 
                   
               
               
                   
                   
                 end 
               
               
                   
                   
               
             
          
         
       
     
     An example input and output of the quadratic interpolation SRC implementation is shown in  FIG. 8 . 
     The process by which configuration files are generated and then employed to change the SRC method as sensors and/or payloads are changed is illustrated in  FIG. 9 . In some embodiments, the present system is employed in the remote operation of a device, such as an unmanned ground vehicle (UGV). For each control operation, such as commanding a turn, a control signal is generated in the remote controller. In step  910 , that control signal is sampled, generating an input signal at a first sample rate. The input signal is then transmitted, step  920 , to the UGV. 
     The input signal is received by the UGV in step  930 . The onboard controller of the UGV then converts the input signal at the first sample rate to the output signal at a second sample rate in step  940 . (This step is further detailed below.) The UGV onboard controller then distributes the output signal to the actuator affected, in this example the steering subsystem, in step  950 . In general, and without limiting the scope of the present disclosure, the sampled output sample is sent to whichever sensor or payload is being commanded remotely. 
       FIG. 10  illustrates the operation of step  940  in detail. In some embodiments, the conversion process begins by computing one or more configuration files specific to the first and second sample rates in step  1010 . The operator may also select the interpolation algorithm (e.g., but not by way of limitation, sample and hold, two-point linear, quadratic Lagrange, higher order Lagrange, etc.) in step  1015  as an input to step  1010 . The configuration file(s) are then stored in the onboard controller of the UGV in step  1020 . 
     In other embodiments, steps  1010 ,  1015 , and  1020  may be performed before the UGV is operational, or at least before remote commanding begins. In such embodiments, step  940  begins with the reception of the input signal, step  1030 . The onboard controller of the UGV then determines the input signal sample rate (step  1040 ) and uses that information to select the proper configuration file. In step  1050 , the onboard controller uses the coefficients and other parameters stored in the configuration file to interpolate the output samples at the desired output sample rate. 
     It should be noted that the order in which the steps of the present method are performed is purely illustrative in nature. In fact, the steps can be performed in any order or in parallel, unless otherwise indicated by the present disclosure. 
     The method of the present invention may be performed in hardware, software, or any combination thereof, as those terms are currently known in the art. In particular, the present method may be carried out by software, firmware, and/or microcode operating on a computer or computers of any type. Additionally, software embodying the present invention may comprise computer instructions in any form (e.g., source code, object code, and/or interpreted code, etc.) stored in any computer-readable medium (e.g., ROM, RAM, magnetic media, punched tape or card, compact disc (CD), and/or digital versatile disc (DVD), etc.). Furthermore, such software may also be in the form of a computer data signal embodied in a carrier wave, such as that found within the well-known Web pages transferred among devices connected to and with computer networks, such as the Internet. Accordingly, the concepts, systems, and techniques described herein are not limited to any particular platform, unless specifically stated otherwise in the present disclosure. 
     For example, the present architecture may be implemented in a UGV system  1100  exemplified by  FIG. 11 . Here, an operator (or remote driver, in the UGV scenario)  1110  controls the remote device (e.g., a UGV)  1120  using a controller blade  1130  having a non-real time operating system (non-RTOS). 
     The control signals at rate F in  are sent from controller  1130  over the RF link  1135  and routed to a non-RTOS platform services blade  1140 . Sample rate conversion (to F out ) is performed in platform services blade  1140 . After conversion, the interpolated samples are routed over vehicle LAN  1145  to vehicle management RTOS blade  1150 . In some embodiments, switches  1146  and  1147  may be employed in LAN  1145 . Vehicle management RTOS blade  1150  then interfaces with and provides control signals to UGV  1120 . 
     Although both RTOS and non-RTOS blades  1130 ,  1140 , and  1150  are described, those skilled in the art will realize that processors and controllers other than blades can be used and that both real time and non-real time operating systems may be employed in each processor. Accordingly, the concepts, systems, and techniques described herein are not limited to any particular type of processor. Indeed, in some embodiments, each blade  1130 ,  1140 , and/or  1150  may be a personal computer, a workstation, or other stand-alone computer. In other embodiments, each of blades  1130 ,  1140 , and/or  1150  may be implemented in a combination of software and hardware in a distributed computing environment, such as but not limited to a client/server system employing blade servers. 
     A portion of the internal architecture of platform services blade  1140 , in one exemplary embodiment, is illustrated in  FIG. 12 . In the context of the UGV example, this implementation may be embodied within blade  1140 . However, in the general sense,  FIG. 12  illustrates the functions of an SRC processor according to some embodiments of the present invention. Here, the input signal arrives from vehicle LAN  1145  on port  1210  for processing by input facility  1220 , which senses rate F in . 
     The input signal is passed to sample rate conversion (SRC) processor  1230 , which retrieves and reads the appropriate configuration file (or files) from data store  1240 . In some exemplary embodiments, data store  1240  is a memory. Alternatively, data store  1240  may be a storage device, such as but not limited to a hard disk drive, a solid-state drive, a flash drive, or any other type of electronic data storage system known in the art. 
     Sample rate conversion processor  1230  interpolates the output samples from the input signal and passes the output samples to output facility  1250 . Output facility  1250 , in turn, sends, forwards, or otherwise communicates the output signal (at F out ) to vehicle LAN  1145 . 
     Input facility  1220  and output facility  1250  may each be implemented as software threads operating within platform services blade  1140 . Alternatively, these facilities may be implemented in hardware within blade  1140  or in a combination of software and hardware, such as but not limited to a digital signal processor and associated microcode or other operational software. Furthermore, the implementation of one facility does not depend on the other. Accordingly, the internal configuration of blade  1140  is not limited to any particular processing architecture, but encompasses all architectures known to those of skill in the relevant arts. 
     While particular embodiments of the present invention have been shown and described, it will be apparent to those skilled in the art that various changes and modifications in form and details may be made therein without departing from the spirit and scope of the invention as defined by the following claims. Accordingly, the appended claims encompass within their scope all such changes and modifications. Each references cited herein is hereby incorporated herein by reference in its entirety.