Demodulation technique for GFSK and DPSK

Abstract

A technique for low-complexity high-performance coherent demodulation of GFSK signals involves utilizing a novel phase and frequency tracking mechanism coupled with a trellis search technique to track signal memory in the demodulation process. A method according to the technique may include modeling modulation based upon a trellis. The method may further include estimating unknown parameters, selecting a maximum likelihood path through the trellis, and mapping the maximum likelihood path to an output bit sequence. The technique is also applicable to DSPK and other applicable known or convenient protocols.

Description

BACKGROUND

Phase-shift keying (PSK) is a digital modulation scheme that conveys data by changing, or modulating, the phase of a reference signal (the carrier wave). Any digital modulation scheme uses a finite number of distinct signals to represent digital data. PSK uses a finite number of phases. The demodulator, which is designed specifically for the symbol-set used by the modulator, determines the phase of the received signal and maps it back to the symbol it represents, thus recovering the original data. This requires the receiver to be able to compare the phase of the received signal to a reference signal-such a system is termed coherent.

Alternatively, instead of using the bit patterns to set the phase of the wave, the bit patterns can instead be used to change the phase of the wave by a specified amount. The demodulator then determines the changes in the phase of the received signal rather than the phase itself. Since this scheme depends on the difference between successive phases, it is termed differential phase-shift keying (DPSK). DPSK can be significantly simpler to implement than ordinary PSK since there is no need for the demodulator to estimate the reference signal to determine the exact phase of the received signal (it is a non-coherent scheme). In exchange, it sometimes produces more erroneous demodulations. The exact requirements of the particular scenario under consideration determine which scheme is used.

Gaussian Frequency Shift Keying (GFSK) is a type of Frequency Shift Keying modulation that utilizes a Gaussian filter to smooth positive/negative frequency deviations, which represent a binary 1 or 0. GFSK and DPSK are used in Bluetooth radios. GFSK is also used in the cordless Digital Enhanced Cordless Telecommunications (DECT) phone standard and the cellular Global System for Mobile Communications (GSM) standard, along with the GSM enhancements for High Speed Circuit Switched Data (HSCSD) and Enhanced Data Rates for GSM Evolution (EDGE). GFSK is also used by Cypress Wireless USB, Nordic Semiconductor, and z-wave devices.

The foregoing examples of the related art and limitations related therewith are intended to be illustrative and not exclusive. Other limitations of the related art will become apparent to those of skill in the art upon a reading of the specification and a study of the drawings.

SUMMARY

The following embodiments and aspects thereof are described and illustrated in conjunction with systems, tools, and methods that are meant to be exemplary and illustrative, not limiting in scope. In various embodiments, one or more of the above-described problems have been reduced or eliminated, while other embodiments are directed to other improvements.

Gaussian frequency shift keying (GFSK) modulation is a modulation whereby the information bits are embedded in the frequency or phase of the transmitted signal, which makes the signal less susceptible to amplitude nonlinearities introduced by the channel and/or receiver hardware. GFSK is typically implemented as a form of frequency modulation (FM), in which case it is a modulation format with memory. GFSK is typically demodulated incoherently to reduce receiver complexity, but this can result in a 2-3 dB degradation in performance relative to a coherent demodulation where the phase and frequency of the signal is tracked. A technique for low-complexity high-performance coherent demodulation of GFSK signals involves utilizing a novel phase and frequency tracking mechanism coupled with a trellis search technique to track signal memory in the demodulation process.

A method according to the technique may include modeling modulation based upon a trellis. The method may further include estimating unknown parameters, selecting a maximum likelihood path through the trellis, and mapping the maximum likelihood path to an output bit sequence.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the inventions are illustrated in the figures. However, the embodiments and figures are illustrative rather than limiting; they provide examples of the inventions.

FIG. 1 depicts a flowchart of an example of a method for detecting transmitted data with low complexity.

FIG. 2 depicts an example of a trellis diagram for GFSK with 2p states.

FIG. 3 depicts a flowchart of an example of a demodulation process based on phase/frequency tracking and a trellis search.

FIGS. 4A and 4B depict flowcharts of examples of methods for reducing ML detector complexity through per-survivor processing.

FIG. 5 depicts a diagram of an example of mapping an ML path to bit estimates.

FIG. 6 depicts a diagram of an example of a trellis and survivor path computation between the i−1th and ith stage.

FIGS. 7A and 7B depict flowcharts of examples of methods for reducing ML detector complexity through per-survivor processing.

DETAILED DESCRIPTION

In the following description, several specific details are presented to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that the invention can be practiced without one or more of the specific details, or in combination with other components, etc. In other instances, well-known implementations or operations are not shown or described in detail to avoid obscuring aspects of various embodiments of the invention.

In GFSK, past bit transmissions are embedded in the signal phase associated with the current bit period T. Specifically, the transmitted signal at time t has constant amplitude and a phase equal to θ(t,a)=2πƒ_ct+φ(t,a), where ƒ_c is the carrier frequency and φ(t,a) is the information carrying phase given by

$\varphi \left(t,a\right)=2\pi h\sum _{i=0}^{L-1}a\left[i\right]q\left(t-\mathrm{iT}\right)$ for h the modulation index, a[i]ε{+1,−1} the polar representation of the binary data bits, L the length of the signal memory, T the bit period, and q(t) the phase response. The memory in the information carrying phase is of length L−1, since at time t the phase depends on the current data bit as well as the previous L−1 data bits. The phase response is the integral of the frequency response g(t), i.e.

$q\left(t\right)=\frac{1}{2}{\int }_{-\infty }^{t-T}g\left(\beta \right)d\beta ,$ where g(t)=u(t)*h_g(t) is the convolution of a rectangular pulse u(t) and a Gaussian pulse h_g(t).

If the signal is down converted using a frequency

$f_0=f_c-\frac{h}{2T},$ then the complex baseband received signal becomes r(t)=s(t)e^jφ(t)+n(t)=e^jψ(t,b)e^jφ(t)+n(t), where s(t) is the complex baseband transmitted signal, n(t) is the complex baseband noise of the received signal, ψ(t,b) is the demodulated phase of the signal given by

$\psi \left(t,b\right)=\theta \left(t,b\right)-2\pi f_0=\varphi \left(t,b\right)+\frac{\pi h}{T}t\mathrm{for}b\left[i\right]=0.5\left(a\left[i\right]+1\right)\in \left\{0,1\right\}$ the binary representation of the data, and φ(t)=φ₀+2πΔ_ƒt is the time-varying phase offset of the received signal, which depends on a fixed phase offset φ₀ and a frequency offset Δ_ƒ, and is thus independent of the data.

The complex baseband transmitted signal can be written as

$s\left(t\right)=\sum _{i=0}^L{\rho }_{m_i}\left(t-iT\right),\mathrm{where}$ ${\rho }_{m_i}\left(t\right)=\{\begin{array}{cc}s\left(t+iT\right)=e^{j\psi \left(t+iT,b\right)}& 0<t\le T\\ 0& \mathrm{otherwise}\end{array}.$

A technique for detecting transmitted data with low complexity involves estimating unknown parameters and then using them in a trellis search to estimate the transmitted data. The trellis may or may not be a reduced state trellis.

FIG. 1 depicts a flowchart 100 of an example of a method for detecting transmitted data with low complexity. The method is organized as a sequence of modules in the flowchart 100. However, it should be understood that these and modules associated with other methods described herein may be reordered for parallel execution or into different sequences of modules. In the example of FIG. 1, the flowchart 100 starts at module 102 with modeling modulation based upon a trellis. The modeling may or may not be accomplished in real time. For example, the modeling may take place beforehand, and the remaining modules (104-108) of the flowchart 100 may take place in real-time or near-real-time.

In the example of FIG. 1, the flowchart 100 continues to module 104 where unknown parameters are estimated. In an illustrative embodiment, it is assumed that both the phase offset φ₀ and/or the frequency offset Δ_ƒ in the received signal are unknown. Let {circumflex over (φ)}₀ and {circumflex over (Δ)}_ƒ denote the estimates for the phase offset φ₀ and frequency offset Δ_ƒ, respectively. These estimates may be obtained from estimation algorithms applied to training sequences or preambles in the data prior to demodulation, data-driven estimation as described later with reference to FIGS. 3, 4A, 4B, 7A, and 7B, or using other applicable known or convenient estimation techniques.

A modulation index may or may not need to be approximated. For example, the modulation index could be either explicit, approximated, or obviated. In an illustrative embodiment, a state trellis search is based on some approximations that allow a simple characterization, and hence detection, of the transmitted signal. For example, where k and p are relative primes a modulation index h=k/p can be approximated. Advantageously, as described later, restricting the modulation index to these values allows coherent maximum-likelihood demodulation through a recursive updating of just a few parameters. As an example of a way to simplify the expression for the signal phase, q(2T)=0.5 can also be approximated. With these approximations ρ_mi(τ) corresponds to exactly 2p possible signals and we can write the phase over a given bit time in terms of the current and past bits as

$\psi \left(\tau +\left(n-1\right)T,b\right)=2\pi h\left(d\left[n-2\right]+\omega \left(\tau ,b\left[n-1\right],b\left[n\right]\right)\right),\mathrm{where}$ $d\left[n-2\right]=R_p\left[\sum _{i=0}^{n-2}b\left[i\right]\right]\in \left\{0,1,\dots ,p-1\right\},\mathrm{for}{R}_p\left[c\right]\mathrm{the}\mathrm{modulo}p\mathrm{operator}\mathrm{and}$ $\begin{array}{c}\omega \left(\tau ,b\left[n-1\right],b\left[n\right]\right)=2b\left[n-1\right]q\left(\tau +T\right)+2b\left[n\right]q\left(\tau \right)+\\ \frac{\tau }{2T}-q\left(\tau +T\right)-q\left(\tau \right)+\frac{1}{2}.\end{array}$

In the example of FIG. 1, the flowchart 100 continues to module 106 where a maximum-likelihood path through a trellis is selected. Note that there are only four different values for ω(τ,b[n−1],b[n]) and also that the phase is slightly different over the first bit time and the last bit time due to the lack of a previous bit for the first bit time and the lack of a subsequent bit for the last bit time. The phase of a received signal over any bit period (n−1)T≦t<nT depends only on d[n−2], b[n−1], and b[n], i.e. on the current and immediately previous data bit values (when present) as well d[n−2], which captures the n−2 bit values prior to b[n−1]. Since d[n−2] has p possible values and b[n−1] has two possible values, we can simplify detection by modeling the transmitted bit sequence as a path through a trellis with 2p states (corresponding to the possible joint values of d[n−2] and b[n−1]) at the nth trellis stage. Since the trellis state corresponds to the values of d[n−2] and b[n−1], it captures all the memory of past bit transmissions in the current bit transmission b[n]. The transition from the trellis state at the (n−1)th stage to the nth stage is determined by whether b[n] is a 0 or 1 bit, as depicted in FIG. 2. Thus, given a path through the trellis that is selected as the maximum-likelihood path based on the received signal, the maximum-likelihood bit decision {tilde over (b)}[n] is determined by the transition from Stage n−1 to Stage n.

In the example of FIG. 1, the flowchart 100 continues to module 108 where the maximum likelihood path is mapped to an output bit sequence. Having provided low complexity detection of transmitted data, the flowchart 100 ends.

FIG. 2 depicts an example of a trellis diagram 200 for GFSK with 2p states. The number of states (i.e., 2p) is based upon d[n−2] and b[n−1], as described previously.

FIG. 3 depicts a flowchart 300 of an example of a demodulation process based on phase/frequency tracking and a trellis search. In the example of FIG. 3, the flowchart 300 starts at module 302 with sampling a signal. In an illustrative embodiment, the received signal is sampled N times over a bit period, where N is a design parameter with a minimum value of 1 (1 sample per bit period). For the received signal over the ith bit period, these samples are averaged to obtain

$r\left[i\right]=\frac{1}{N}\sum _{k=0}^{N-1}r\left(\left(i+k/N\right)T\right).$

In the example of FIG. 3, the flowchart 300 continues to module 304 where estimates for phase parameters are updated. The phase parameters may include, by way of example but not limitation, phase and frequency offsets. The demodulation process for a sequence of L transmitted bits proceeds as follows. Over each bit time iT the received signal is used to compute r[i] and obtain estimates for the phase and frequency offsets, {circumflex over (φ)}₀[i] and {circumflex over (Δ)}_ƒ[i], respectively. These estimates may be obtained, by way of example but not limitation, from a preamble prior to bit transmission, through maximum-likelihood or maximum a posteriori estimation, or through a recursive updating at each bit time based on prior estimates and the received signal over the ith bit period. The recursive update can be simplified by making it a function of r[i] instead of the entire received signal over the ith bit time.

In the example of FIG. 3, the flowchart 300 continues to module 306 where a function associated with bits received up to the current time is computed. A sampled average for ρ[m_i(t)] over the ith bit period is given by

$\rho \left[m_i\right]=\frac{1}{N}\sum _{k=0}^{N-1}\rho \left(\left(i+k/N\right)T\right).$ Note that ρ[m_i] can be rewritten as

$\rho \left[m_i\right]=e^{\mathrm{j2\pi }{\mathrm{hv}}_i\left[1\right]}\sum _{k=0}^N{e}^{\mathrm{j2\pi }h\omega \left(\mathrm{kT}/N,v_i\left[2\right],v_i\left[3\right]\right)}$ for v_i=[v_i[1],v_i[2],v_i[3]]=[d[i−2],b[i−1],b[i]]. Thus, we can express ρ[m_i] in terms of the ith data bit and the state of the trellis shown in FIG. 2 at stage i.

In the example of FIG. 3, the flowchart 300 continues to module 308 where a trellis state that maximizes the metric is found. Assuming the time-varying phase offset φ(t) over bit time iT is accurately estimated by {circumflex over (φ)}(t)={circumflex over (φ)}₀[i]+2π{circumflex over (Δ)}_ƒ[i]t, we approximate the maximum-likelihood (ML) detector for the L transmitted data bits by, at time i, choosing the {tilde over (m)}_i (or, equivalently, the trellis path at time i) to maximize the metric

$\Lambda \left[L-1\right]=\mathrm{Re}\left\{\sum _{i=0}^{L-1}r\left[i\right]{\rho }^{*}\left[{\tilde{m}}_i\right]e^{-j\left({\hat{\varphi }}_0\left[i\right]+2\pi {\hat{\Delta }}_f\left[i\right]\mathrm{iT}\right)}\right\},$ where ρ*[{tilde over (m)}_i] denotes the complex conjugate of ρ[{tilde over (m)}_i].

It should be noted that, in an illustrative embodiment, metrics are computed at each stage, but the bit decisions can be made at each stage, or the decision can be delayed until all of the computations, at each stage, have been made. Waiting until the end to maximize the metric and output the corresponding bits introduces delay, but can result in a more optimal path, which tends to improve performance. Performing the maximization at each time i and outputting the bits associated with the trellis path with the maximum metric at time i, on the other hand, has the advantage of reduced delay and lower memory requirements.

In the example of FIG. 3, the flowchart 300 ends at module 310 where an estimate for the transmitted data based on the trellis state that maximizes the metric is determined. In an illustrative embodiment, {tilde over (m)}_i is mapped for i=1, . . . , L to {tilde over (b)}[0], . . . , {tilde over (b)}[L−1]. The detected data is thus a sequence {tilde over (b)}[0], . . . , {tilde over (b)}[L−1] that maximizes the maximum-likelihood metric Λ[i] for each time i, or at time L−1 at the end of the sequence of bit transmissions.

FIGS. 4A and 4B depict flowcharts of examples of methods for reducing ML detector complexity through per-survivor processing. The complexity and memory requirements of the ML detector corresponding to the metric, Λ[L−1], can be substantially reduced through per-survivor processing. This reduces the number of states in the trellis of FIG. 2 from 2p to 2.

FIG. 4A is intended to show per-survivor processing where output is at the end of the process. In the example of FIG. 4A, the flowchart 400A starts at module 402 where a trellis stage is initialized to −1.

In the example of FIG. 4A, the flowchart 400A continues to module 404 where the trellis stage is incremented. Over the ith bit time we compute d[i−2] based on past bit decisions up until time i−2. If d[i−2] is fixed then the current bit decision only depends on this fixed value and the 2 possible values for the previous bit value b[i−1]. Hence the trellis to determine b[i] has just 2 states, which we will denote as states 0 and 1. For this trellis let μ_y[i]ε{0,1} denote the start state of the survivor path in trellis section i that ends in state yε{0,1}.

In the example of FIG. 4A, the flowchart 400A continues to module 405 where the received signal is sampled and averaged. For the received signal over the Rh bit period, the samples are averaged to obtain

$r\left[i\right]=\frac{1}{N}\sum _{k=0}^{N-1}r\left(\left(i+k/N\right)T\right).$

In the example of FIG. 4A, the flowchart 400A continues to module 407 where time-varying phase parameters are estimated. The time-varying phase parameters may include, by way of example but not limitation, the phase offset and/or frequency offset. Thus, in an illustrative embodiment, over bit period iT the phase and frequency offsets {circumflex over (φ)}₀[i] and {circumflex over (Δ)}_ƒ[i] are estimated. It may be noted that the time-varying phase parameters are not affected by data values, but rather by hardware variations, temperature, propagation environment, and/or other factors.

In the example of FIG. 4A, the flowchart 400A continues to module 409 where complex data functions are updated.

In the example of FIG. 4A, the flowchart 400A continues to module 410 where a metric is computed based on recursive updates of data functions and the time-varying phase parameters. The total metric for the branch ending in state y after trellis section i can then be updated recursively as Λ_y[i]=max_xε{0,1}Λ_x[i−1]+λ_x→y[i], where λ_x→y[i] is the branch metric for the branch going from state x to state y in trellis section i. This recursive update indicates that there will be only one surviving path into each state yε{0,1} of the trellis at stage i, which will correspond to the path between x and y for the x achieving the maximum Λ_y[i]. The branch metric λ_x→y[i] is given by

$\begin{array}{c}{\lambda }_{x->y}\left[i\right]=\mathrm{Re}\left\{r\left[i\right]{\rho }^{*}\left[{\tilde{m}}_i\right]e^{-j\left({\hat{\varphi }}_0\left[i\right]+2\pi {\hat{\Delta }}_f\left[i\right]iT\right)}\right\}\\ =\mathrm{Re}\left\{r\left[i\right]e^{-\mathrm{j2}\pi {\mathrm{hd}}_c\left[i-2\right]}{z}^{*}\left(x,y\right)e^{-j\left({\hat{\varphi }}_0\left[i\right]+2\pi {\hat{\Delta }}_f\left[i\right]iT\right)}\right\},\end{array}$ for c=μ_x[i−1] and

$z\left(v_i\left[2\right],v_i\left[3\right]\right)={\int }_0^T{e}^{\mathrm{j2}\pi h\omega \left(\tau ,v_i\left[2\right],v_i\left[3\right]\right)}d\tau .$ Note that d_μx[i−1][i−2]=R_p[d_x[i−1]−μ_x[i−1]].

In the example of FIG. 4A, the flowchart 400A continues to module 412 where a survivor branch into each trellis state is determined. The calculation of the surviving branch entering each trellis state at stage i, i.e. the branch maximizing the metric Λ_y[i], y=0,1 is based on values for r[i], d_x[i−1],μ_x[i−1], and Λ_x[i−1], x=0,1. Once the surviving branch into each state yε{0,1} at stage i is determined, the starting state μ_y[i] is updated based on the start state of the surviving branch, and based on this value the parameter d_y[i] is updated according to d_x[i]=R_p[d_μx[i][i−1]+x].

In the example of FIG. 4A, the flowchart 400A continues to decision point 414 where it is determined whether i=L−1. If it is determined that i≠L−1 (414-N), then the flowchart 400A returns (recursively) to module 404 and continues as described previously. Thus, the process is repeated over each bit time until the final cumulative metric Λ_X[L−1] corresponding to all L bit transmissions is obtained for x=0,1. When it is determined that i=L−1 (414-Y), the recursion ends.

In the example of FIG. 4A, the flowchart 400A continues to decision point 416 where it is determined whether a metric 0 (e.g., Λ₀) is greater than a metric 1 (e.g., Λ₁). If it is determined that the metric 0 is greater than the metric 1, then the flowchart 400A continues to module 418 where the L−1 bits for the survivor path into State 0 at time L−1 are demodulated. In other words, if Λ₀[L−1]>Λ₁[L−1], the surviving path into State 0 at time L−1 is assumed to be the ML path. If, on the other hand, it is determined that the metric 0 is less than or equal to the metric 1, then the flowchart 400A continues to module 420 where the L−1 bits for the survivor path into State 0 at time L−1 are demodulated. In other words, the surviving path into State 1 at time L−1 is assumed to be the ML path. The bit sequence {tilde over (b)}[0], . . . , {tilde over (b)}[L−1] is demodulated based on the states x[i] along that ML path as {tilde over (b)}[i]=x[i], i.e. at time i, the bit {tilde over (b)}[i] corresponding to the survivor path into State 0 is μ₀[i+1] and the bit corresponding to the survivor path into State 1 is μ₁[i+1]. The bit sequences up to time i−1 corresponding to the survivor paths at time i are updated at each time interval and the demodulated bit sequence then corresponds to the ML trellis path at time L−1. After the bits for the survivor path are demodulated, the flowchart 400A ends.

FIG. 4B illustrates per-survivor processing with output at each stage of the trellis. This reduces memory requirements and delay by outputting the bit associated with the survivor path at time i for the state x[i]ε{0,1} with the largest metric Λ_x[i]. Specifically, at time i, the flowchart traces back some K of stages in the trellis and outputs the bit b[i−K] corresponding to the path for state x[i]ε{0,1} with the largest metric Λ_x[i] at time i. Typically, 1≦K≦L.

In the example of FIG. 4B, the modules 452-462 are quite similar to modules 402-412, so they are not re-described here. In the example of FIG. 4B, the flowchart 400B continues from the module 462 to the decision point 464 where it is determined whether a metric 0 greater than a metric 1. If it is determined that the metric 0 is greater than the metric 1, then the flowchart 400B continues to module 466 where the bit {tilde over (b)}[i−K] for the survivor path associated with State 0 at time i is output. If, on the other hand, it is determined that the metric 0 is less than the metric 1, then the flowchart 400B continues to module 468 where the bit {tilde over (b)}[i−K] for the survivor path associated with State 1 at time i is output.

In the example of FIG. 4B, the flowchart 400B continues to decision point 470 where it is determined whether i=L−1. If it is determined that i≠L−1 (470-N), then the flowchart 400B returns (recursively) to module 454 and continues as described previously. Thus, the process is repeated over each bit time. When it is determined that i=L−1 (470-Y), the recursion ends.

In the example of FIG. 4B, the flowchart 400B continues to module 472 where any remaining bits along the survivor path with the maximum metric are demodulated. For example, if you go back K stages, then you output K bits. In an illustrative embodiment, the bits b[L−K] to b[L−1] are output. After module 472, the flowchart 400B ends. FIG. 5 depicts a diagram 500 of an example of mapping an ML path to bit estimates.

In an alternate technique, you could trace back some random number K of stages in the trellis until the 2 bit values corresponding to both surviving paths in the trellis at time i are the same. This results in a random delay in the bit outputs.

FIG. 6 depicts a diagram 600 of an example of a trellis and survivor path computation between the i−1th and ith stage. In the example of FIG. 6, solid branches correspond to surviving paths (note there is only one entering each state at any trellis stage) and dashed branches corresponds to not yet decided survivor path entering State 0 at trellis stage i. If Λ₁[i−1]+λ_1→0[i]>Λ₀[i−1]+λ_0→0[i], the surviving branch entering State 0 in trellis section i starts in State 1 and ends in State 0. With the selection of this lower dashed branch as the surviving branch of the ML path, the parameters for the ML metric associated with the ith trellis stage are updated according to μ₀[i]=1, d₀[i]=R_p[d₁[i−1]+0], Λ₀[i]=Λ₁[i−1]+λ_1→0[i]. These parameters only depend on their previous values, i.e., a buffer of size two for each parameter is enough.

As stated earlier, the phase is slightly different over the first and last bit times since the phase over the first bit time does not have memory associated with the previous bit, and the phase over the last bit time does not have memory associated with a subsequent bit. We denote the phases corresponding to these first and last bit periods as ω_s(τ,b[0]) and ω_e(τ,b[L−1]), respectively. We similar define

$z_s\left(b\left[0\right]\right)={\int }_0^T{e}^{j2\pi h\omega \left(\tau ,b\left[0\right]\right)}d\tau$ $\mathrm{and}$ $z_e\left(b\left[L-1\right]\right)={\int }_0^T{e}^{\mathrm{j2\pi }h\omega \left(\tau ,b\left[L-1\right]\right)}d\tau$ so that we can express the metrics for the first trellis stage as

$\begin{array}{c}{\Lambda }_0\left[0\right]=\mathrm{Re}\left\{r\left[0\right]z_s^{*}\left(0\right)e^{-j{\hat{\varphi }}_0\left[0\right]}\right\},\\ {\Lambda }_1\left[0\right]=\mathrm{Re}\left\{r\left[0\right]z_s^{*}\left(1\right)e^{-j{\hat{\varphi }}_0\left[0\right]}\right\},\end{array}$ where e^{−j{circumflex over (φ)}0[i]} is the initial phase estimate. In an implementation, the preamble processing will often take care of the first bit transmission and also provide an estimate of the phase offset φ₀. In this case z_s(0) and z_s(1) will never be used.

After updating Λ_y[L−1] for yε{0,1} according to above, the tail of the signal need to be added using z_e(y) as

$\begin{array}{c}{\Lambda }_0\left[L-1\right]={\Lambda }_0\left[L-1\right]+\mathrm{Re}\left\{r\left[L\right]z_e^{*}\left(0\right)e^{-j\left({\hat{\varphi }}_0\left[L-1\right]+2\pi {\hat{\Delta }}_f\left[L-1\right]\left(L-1\right)T\right)}\right\},\\ {\Lambda }_1\left[L-1\right]={\Lambda }_1\left[L-1\right]+\mathrm{Re}\left\{r\left[L\right]z_e^{*}\left(1\right)e^{-j\left({\hat{\varphi }}_0\left[L-1\right]+2\pi {\hat{\Delta }}_f\left[L-1\right]\left(L-1\right)T\right)}\right\}.\end{array}$ The decisions on the last information bit is {tilde over (b)}[L−1]=x if Λ_x[L−1]>Λ_y[L−1] and the remaining bit decisions are made according to {tilde over (b)}[i]=μ_{{tilde over (b)}[i+1]}[i+1] for i=0,1, 2, . . . , L−2.

There are several techniques that can be used to obtain the time-varying phase estimate {circumflex over (φ)}(t)={circumflex over (φ)}₀+2π{circumflex over (Δ)}_ƒt, including estimation algorithms applied to training sequences or preambles in the data prior to demodulation, data-driven estimation that is updated at each symbol time, or other techniques. Since the branch metric calculation described above can be updated based on the previous values of Λ_y[i], d_y[i], μ_y[i], a low complexity algorithm would have the property that the phase estimation algorithm can be updated based only on the values from the previous stage of the branch metric calculation, i.e. if {circumflex over (φ)}₀[i] denotes the phase offset estimate at time i, it is desirable from a low-complexity perspective that this estimate depend only on {circumflex over (φ)}₀[i−1], and similarly the frequency offset estimate at time i, {circumflex over (Δ)}_ƒ[i] should depend only on {circumflex over (Δ)}_ƒ[i−1].

FIGS. 7A and 7B depict flowcharts 700A and 700B of examples of methods for reducing ML detector complexity through per-survivor processing. The flowcharts 700A and 700B are similar to the flowcharts 400A and 400B (FIGS. 4A and 4B), though different exemplary computations may be in order at certain of the steps. Notably, FIGS. 7A and 7B respectively refer to real data functions at modules 709, 710 and 758, 760. Advantageously, the use of real data functions, instead of complex data functions, can significantly reduce the complexity of the computations.

In an illustrative embodiment, a transmitted phase can be expressed as a function of the accumulated bits and the last two bits as φ(τ+(n−1)T,a)=πhd[n−2]+2πhω(τ,a[n−1],a[n]), where d[n−2] and ω(τ,a[n−1],a[n]) are redefined as

$d\left[n-2\right]=\sum _{i=0}^{n-2}a\left[i\right]\omega \left(\tau ,a\left[n-1\right],a\left[n\right]\right)=a\left[n-1\right]q\left(\tau +T\right)+a\left[n\right]q\left(\tau \right).$ where again a[i]ε{+1,−1} is the polar representation of the binary data. Then ρ[m_i]=e^jπhd[i−2]z(a[i−1],a[i]).

Let us denote the phase estimate at time i by q[i]. We can obtain this estimate based on averaging over the current and last sample as

e^{j{circumflex over (φ)}0}=q[i]=αq[i−1]+(1−α)r[i]ρ*[{tilde over (m)}_i], where 0≦α≦1 is the forgetting factor for the previous sample. Similarly, let us denote the frequency offset estimate at time i by

$e^{\mathrm{j2}\pi {\hat{\Delta }}_f}=\frac{p\left[i\right]}{p\left[i\right]},$ where p[i]=βp[i−1]+(1−β)r[i]ρ*[{tilde over (m)}_i]ρ[{tilde over (m)}_i−1]r*[i−1], and 0≦β≦1 is the forgetting factor. The branch metric for trellis section i in (6) can now be approximated by λ[i]=Re{r[i]ρ*[{tilde over (m)}_i]q*[i−1]}, where q[i] is the combined phase and frequency offset estimate according to

$q\left[i\right]=\left(\alpha q\left[i-1\right]+\left(1-\alpha \right)r\left[i\right]{\rho }^{*}\left[{\tilde{m}}_i\right]\right)\frac{p\left[i-1\right]}{p\left[i-1\right]}.$

Define also δ_y[i]=hd_y[i−1] and u[i]=r[i]ρ*[{tilde over (m)}_i]=r[i]e^{−jπδ[i−1]}z*(a[i−1],a[i]). These calculations require multiplications of complex numbers, which can be simplified to additions of real numbers as follows. Let zε[−1,+1) denote the angle of the complex number z divided by i, such that z=e^{jπ z}. Further, define r,ū, q, p, such that r=e^{jπ r},u=e^jπū,q=e^{jπ q},p=e^{jπ p}. This means that ū[i]= r[i]−δ[i−1]− z(a[i−1],a[i]), λ[i]=cos(π(ū[i]− q[i−1])).

However, some further modifications are needed for the updates of the phase and frequency offset estimation q[i]. Consider two complex-valued numbers with unit amplitude, e^−jπa and e^−jπb for −1≦a≦+1 and −1≦b≦+1. The weighted sum of these numbers can then be approximated according to γe^jπa+(1−γ)e^jπb≈e^{jπ(a+(1−y)[b−a]−1+1)}, where parameter 0≦y≦1 acts as a weighting factor and [b−a]₋₁⁺¹=mod(b−a−1,2)−1, which means that the number inside the brackets is wrapped around within [−1,+1). This is easily implemented in fixed point arithmetic by using one bit for the integer part and the rest of the bits for the fractional part together with wrapping instead of saturation, e.g., [0.5+0.7]₋₁⁺¹=−0.8. This also means that the modulo p operator R_p[c] is no longer needed. According to this approximation the recursive updates for the phase and frequency offset estimation can be simplified toq[i]=[ q[i−1]+(1−α)[ū[i]− q[i−1]]₋₁⁺¹+ p[i−1]]₋₁⁺¹,p[i]=[ p[i−1]+(1−β)[ū[i]−ū[i−1]− p[i−1]]₋₁⁺¹]₋₁⁺¹. Note also that the normalization of p is no longer necessary, since the operations are performed in phase domain.

The updates of Λ[i], δ[i], μ[i], ū[i], q[i], p[i] through the trellis and the decisions on the bits {tilde over (b)}[i] can be explained by the following pseudo code:

for i = 1 : L (for all trellis sections)
for y = 0 : 1 (for all ending states)
for x = 0 : 1 (for all starting states)
ū′x = [ r[i] − δx[i − 1] − z(x,y)]−1+1
Λ′x = Λx[i − 1] + cos(π(ū′x − qx[i − 1]))
end
if Λ′1 > Λ′0 (finding the winning starting state)
μy[i] = 1
δy[i] = [δ1[i − 1] + h]−1+1
Λy[i] = Λ′1
ūy[i] = ū′1
qy[i] = [ q1[i − 1] + (1 − α)[ūy[i] − q1[i − 1]]−1+1 + p1[i − 1]]−1+1
py[i] = [ p1[i − 1] + (1 − β)[ūy[i] − ū1[i − 1] − p1[i − 1]]−1+1]−1+1
else
μy[i] = 0
δy[i] = [δ0[i − 1] − h]−1+1
Λy[i] = Λ′0
ūy[i] = ū′0
qy[i] = [ q0[i − 1] + (1 − α)[ūy[i] − q0[i − 1]]−1+1 + p0[i − 1]]−1+1
py[i] = [ p0[i − 1] + (1 − β)[ūy[i] − ū0[i − 1] − p0[i − 1]]−1+1]−1+1
end
end
if Λ1[i] > Λ0[i] (trace back decision by K=1 and normalization of metric)
Λ0[i] = Λ0[i] − Λ1[i]
Λ1[i] = Λ1[i] − Λ1[i] = 0
{circumflex over (b)}[i − 1] = μ1[i]
else
Λ1[i] = Λ1[i] − Λ0[i]
Λ0[i] = Λ0[i] − Λ0[i] = 0
{tilde over (b)}[i − 1] = μ0[i]
end
end

Note that the above parameters only depend on their previous values, i.e., a buffer of size two for each parameter is enough. Only μ_y[i] needs to be saved for all yε{0,1} and i=1, 2, . . . , L−1 to be able to track the surviving path through the entire trellis, but on the other hand, μ_y[i] only contains 1 bit. The normalization of the metric Λ_y[i] is just to keep it from overflowing. The length of the trace back K to make decisions on the data bits can also be made longer than one symbol which may lead to some performance benefit.

In DPSK (also referred to as D-MPSK) the transmitted complex symbols are given by s[i]=s[i−1]e^jπφ[i] where φ[i]εS is the data phase carrying the m=log₂(M) information bits

$S\in \left\{\frac{2k}{M}\right\},k=0,1,\dots ,M-1.$ In an illustrative embodiment, the information bits are mapped to the phases using Gray mapping. The first symbol s[0]=e^jπφ[0] is transmitted with an arbitrary phase φ[0]ε[−1,+1). The transmitted symbols can also be written as s[i]=e^{jπ(Φ[i]+φ[0])}=e^jπΦ[i]e^jπφ[0], where Φ[i]εS denotes the coherent data phases with

$\Phi \left[i\right]=\sum _{n=1}^i\varphi \left[n\right]\mathrm{and}\Phi \left[0\right]=0.$ Note that φ[i]=Φ[i]−Φ[i−1], for i=1, 2, . . . , L. The transmitted baseband analog signal is given by

$s\left(t\right)=\sum _{i=1}^{L}s\left[i\right]h\left(t-\mathrm{iT}\right)=e^{\mathrm{j\pi \varphi }\left[0\right]}\sum _{i=1}^L{e}^{\mathrm{j\pi \Phi }\left[i\right]}h\left(t-\mathrm{iT}\right),$ where h(t) is the transmit pulse shaping and T is the data symbol duration. The received base band signal is

$\begin{array}{c}r\left(t\right)=\sum _{i=0}^{L}s\left[i\right]h\left(t-\tau -\mathrm{iT}\right)e^{\mathrm{j\pi }\left(2\Delta t-2\mathrm{\Delta \tau }\right)}+n\left(t\right)\\ =\sum _{i=0}^L{e}^{\mathrm{j\pi \Phi }\left[i\right]}h\left(t-\tau -\mathrm{iT}\right)e^{\mathrm{j\pi }\left(2\Delta t+\theta \right)}+n\left(t\right),\end{array}$ where τ is the unknown propagation delay, Δ is the unknown frequency offset, θ=φ[0]−2Δτ is the unknown phase offset, and n(t) is the additive white Gaussian noise with two sided power spectral density

$\frac{N_0}{2}.$

DPSK modulation can be modeled by a trellis with M states y=0, 1, . . . , M−1, where the reference symbol going into state y is

$z=e^{\mathrm{j\pi }\frac{2y}{M}}.$ There may or may not be unknown parameters associated with, for example, the signal. The DPSK signal can be demodulated by finding the maximum likelihood path through the trellis associated with the received signal, as has been described previously for GFSK (e.g., with reference FIG. 1).

In an illustrative embodiment, the transmit pulse can be truncated by using a window w(t) that is non-zero except N symbol intervals centered around zero

$\tilde{h}\left(t\right)=\{\begin{array}{cc}h\left(t\right)w\left(t\right)& -\mathrm{NT}/2\le t\le \mathrm{NT}/2\\ 0& \mathrm{elsewhere}\end{array}.$ Using {tilde over (h)}(t) as the transmit pulse, the received signal becomes

$r\left(t\right)=\sum _{i=0}^{L-1}{e}^{\mathrm{j\pi \Phi }\left[i\right]}\tilde{h}\left(t-\tau -\mathrm{iT}\right)e^{\mathrm{j\pi }\left(2\Delta t+\theta \right)}+n\left(t\right).$ This signal is averaged over the ith bit period to obtain

$r\left[i\right]=\frac{1}{N}\sum _{k=0}^{N-1}r\left(\left(i+k/N\right)T\right).$ Assuming perfect timing, the demodulation can be performed by a trellis search on a fully connected trellis with M states for the symbol z[i] that maximizes the maximum likelihood metric Λ[L−1] for L−1 symbols given by

$\Lambda \left[L-1\right]=\mathrm{Re}\left\{\sum _{i=0}^{L-1}r\left[i\right]z^{*}\left[i\right]q^{*}\left[i\right]\right\}.$ Using the same notation as for GFSK, described previously, define z, r,ū, q, p, such that z=e^{jπ z},r=e^{jπ r},u=e^jπū,q=e^{jπ q},p=e^{jπ p} which means that z(y)=[2y/M]₋₁⁺¹.

The updates of Λ[i], μ[i], ū[i], q[i], p[i] through the trellis and the decisions on the phases {circumflex over (φ)}[i] can be explained by the following pseudo code.

for i = 1:L (for all trellis sections)
for y = 0:M − 1 (for all ending states)
for x = 0:M − 1 (for all starting states)
u                        _                                            x                      ′                                        =                                                                  [                                                                                                            r                              _                                                        ⁡                                                          [                              i                              ]                                                                                -                                                                                    z                              _                                                        ⁡                                                          (                              y                              )                                                                                                      ]                                                                    -                        1                                                                    +                        1
Λ                      x                      ′                                        =                                                                                            Λ                          x                                                ⁡                                                  [                                                      i                            -                            1                                                    ]                                                                    +                                              cos                        ⁡                                                  (                                                      π                            ⁡                                                          (                                                                                                                                    u                                    _                                                                    x                                  ′                                                                -                                                                                                                                            q                                      _                                                                        x                                                                    ⁡                                                                      [                                                                          i                                      -                                      1                                                                        ]                                                                                                                              )                                                                                )
end
x                      *                                        =                                          arg                      ⁢                                                                                          ⁢                                                                        max                          x                                                ⁢                                                                                                  ⁢                                                                              Λ                            x                            ′                                                    ⁢                                                                                                          ⁢                                                      (                                                          winning                              ⁢                                                                                                                          ⁢                              starting                              ⁢                                                                                                                          ⁢                              state                                                        )
μ                        y                                            ⁡                                              [                        i                        ]                                                              =                                          x                      *
Λ                        y                                            ⁡                                              [                        i                        ]                                                              =                                          Λ                                              x                        *                                            ′
u                          _                                                y                                            ⁡                                              [                        i                        ]                                                              =                                                                  u                        _                                                                    x                        *                                            ′
q                          _                                                y                                            ⁡                                              [                        i                        ]                                                              =                                                                  [                                                                                                                                            q                                _                                                                                            x                                *                                                                                      ⁡                                                          [                                                              i                                -                                1                                                            ]                                                                                +                                                                                                                    (                                                                  1                                  -                                  α                                                                )                                                            ⁡                                                              [                                                                                                                                                                                    u                                        _                                                                            y                                                                        ⁡                                                                          [                                      i                                      ]                                                                                                        -                                                                                                                                                    q                                        _                                                                                                                    x                                        *                                                                                                              ⁡                                                                          [                                                                              i                                        -                                        1                                                                            ]                                                                                                                                      ]                                                                                                                    -                              1                                                                                      +                              1                                                                                +                                                                                                                    p                                _                                                                                            x                                *                                                                                      ⁡                                                          [                                                              i                                -                                1                                                            ]                                                                                                      ]                                                                    -                        1                                                                    +                        1
p                          _                                                y                                            ⁡                                              [                        i                        ]                                                              =                                                                  [                                                                                                                                            p                                _                                                                                            x                                *                                                                                      ⁡                                                          [                                                              i                                -                                1                                                            ]                                                                                +                                                                                                                    (                                                                  1                                  -                                  β                                                                )                                                            ⁡                                                              [                                                                                                                                                                                    u                                        _                                                                            y                                                                        ⁡                                                                          [                                      i                                      ]                                                                                                        -                                                                                                                                                    u                                        _                                                                                                                    x                                        *                                                                                                              ⁡                                                                          [                                                                              i                                        -                                        1                                                                            ]                                                                                                        -                                                                                                                                                    p                                        _                                                                                                                    x                                        *                                                                                                              ⁡                                                                          [                                                                              i                                        -                                        1                                                                            ]                                                                                                                                      ]                                                                                                                    -                              1                                                                                      +                              1                                                                                                      ]                                                                    -                        1                                                                    +                        1
end
y                      *                                        =                                          arg                      ⁢                                                                                          ⁢                                                                        max                          y                                                ⁢                                                                                                            Λ                              y                                                        ⁡                                                          [                              i                              ]                                                                                ⁢                                                                                                          ⁢                                                      (                                                          winning                              ⁢                                                                                                                          ⁢                              ending                              ⁢                                                                                                                          ⁢                              state                                                        )
for y = 0:M − 1 (normalize the metric to prevent overflow)
Λ                        y                                            ⁡                                              [                        i                        ]                                                              =                                                                                            Λ                          y                                                ⁡                                                  [                          i                          ]                                                                    -                                                                        Λ                                                      y                            *                                                                          ⁡                                                  [                          i                          ]
end
for k = i : −1:i − K (trace back in the trellis)
l                    =                                          mod                      (                                                                                                    y                            *                                                    -                                                                                    μ                                                              y                                *                                                                                      [                            k                            ]                                                                          ,                        M                                            )
y                      *                                        =                                                                  μ                                                  y                          *                                                                    ⁡                                              [                        k                        ]
end
ϕ                        ^                                            ⁡                                              [                                                  i                          -                          K                                                ]                                                              =                                                                  z                        _                                            ⁡                                              [                        l                        ]
end

K≦0 is the trace back length that will also affect the delay of the decision. To even further reduce the complexity the starting state x can be put to the winning ending state from the previous trellis section, i.e.,

$x=\arg \underset{y}{\max }{\Lambda }_y\left[i-1\right].$ That will reduce the innermost for-loop with a factor of M.

As used herein, the term “embodiment” means an embodiment that serves to illustrate by way of example but not limitation.

It will be appreciated to those skilled in the art that the preceding examples and embodiments are exemplary and not limiting to the scope of the present invention. It is intended that all permutations, enhancements, equivalents, and improvements thereto that are apparent to those skilled in the art upon a reading of the specification and a study of the drawings are included within the true spirit and scope of the present invention. It is therefore intended that the following appended claims include all such modifications, permutations and equivalents as fall within the true spirit and scope of the present invention.

Claims

1. A method comprising: demodulating a received signal in a signal receiver by determining estimates of unknown parameters of the received signal by using a weighted addition of real numbers and without performing an operation on a complex number;selecting a maximum likelihood path through a trellis based on the estimates; andmapping the maximum likelihood path to an output bit sequence.

2. A method comprising: in a signal receiver, demodulating a received signal by sampling the signal over a bit period;updating time-variable phase parameters by using a weighted addition of real numbers and without using multiplication of a complex number;computing a branch metric function associated with bits of the received signal received up to a current time;finding a trellis state that maximizes a branch metric of the trellis, wherein the branch metric is based on said branch metric function; anddetermining an estimate for the transmitted data based on the trellis state that maximizes the branch metric.

3. The method of claim 2, further comprising initializing a trellis stage.

4. The method of claim 2, further comprising, recursively, incrementing a trellis stage; sampling and averaging the received signal;updating data functions; andcomputing a metric based on recursive updates of the data functions and the time-variable phase parameters.

5. The method of claim 4, wherein the data functions include real data functions and not complex data functions.

6. The method of claim 4, further comprising, recursively estimating time-varying phase parameters.

7. The method of claim 4, further comprising, recursively estimating phase offsets and frequency offsets.

8. The method of claim 4, further comprising: determining, recursively, a survivor branch into each trellis state;determining whether the branch metric is greater for a first state or a second state;demodulating bits for a survivor path into the first state if the branch metric is greater for the first state than for the second state;demodulating bits for a survivor path into the second state if the branch metric is not greater for the first state than for the second state.

9. The method of claim 4, further comprising, recursively: determining a survivor branch into each trellis state;determining whether the branch metric is greater for a first state or a second state;demodulating a bit associated with a survivor path into the first state if the branch metric is greater for the first state than for the second state;demodulating a bit associated with a survivor path into the second state if the branch metric is not greater for the first state than for the second state.

10. The method of claim 9, further comprising demodulating any remaining bits along the survivor path into the first state.

11. The method of claim 1, wherein the unknown parameters comprise a parameter that is a function of a phase of the received signal or a parameter that is a function of a frequency of the received signal.

12. The method of claim 11, wherein the received signal is a GFSK signal or a DPSK signal.

13. The method of claim 1, wherein the unknown parameters comprise a phase offset and a frequency offset.

14. A method comprising: in a signal receiver, determining an estimate of an unknown parameter of a received signal by using a weighted addition of real numbers and without performing an operation on a complex number; anddemodulating the received signal based on the estimate.

15. The method of claim 14, wherein the unknown parameter comprises a parameter that is a function of a phase of the received signal or a parameter that is a function of a frequency of the received signal.

16. The method of claim 15, wherein the received signal is a GFSK signal or a DPSK signal.

17. The method of claim 14, wherein the unknown parameter comprises a phase offset or a frequency offset.

18. The method of claim 9, further comprising demodulating any remaining bits along the survivor path into the second state.