Connect with us

Convolution in signal processing

Discussion in 'General Electronics' started by Lily Bepant, Jun 9, 2004.

  1. Lily Bepant

    Lily Bepant Guest

    Hello,
    I'm stuck in a convolution question.

    x(t) = u(t) - 2u(t-2) + u(t-5)
    h(t) = e^(2t) u(1-t)
    y(t) = x(t) * h(t)

    (I'm using capital T as tao and Int as integral from minus infinity to
    plus infinity)

    y(t) = Int ( x(t-T) h(T) ) dT

    = Int ( u(t-T)-2u(t-T-2)+u(t-T-5)[e^(2T)u(1-T)] )dT

    = Int ( [e^(2T)u(1-T)] u(t-T) ) - Int ....
    ------------------------------------------

    I'm going to set integral limits due to the interval that the step
    functions are nonzero. So:

    1-T > 0 -> T < 1
    t-T > 0 -> T < t

    But the T is smaller than both 1 and t...

    so.. What do I have to take as integral limits? I'm stuck here.
    I know that it's basic calculus but, because it's about signal
    processing, I posted it here.

    Thank you for your assistance.
    Lily
     
  2. Activ8

    Activ8 Guest

    Are you confusing concolution with the sampling function and step
    with impulse?
    How can that be when t starts at zero and goes forever?
    The T I'm thinking of should be the sampling interval so it should
    be smaller than t_max from -oo to oo or 0 to t_max ... isn't that
    the idea behind dT, and infinitely small increment?

    So integrate y(t) = f(t)u(t-T)dT from -oo to oo (or wherever you get
    non zero values) for each t
     
  3. Jem Berkes

    Jem Berkes Guest

    Hello,
    Why integrate? Can't you solve this entirely in the frequency domain? Use
    Laplace transform/identities to get X(s), H(s)

    Y(s) = X(s) x H(s)

    Inverse transform to find y(t) in time domain.
     
  4. Ben Moss

    Ben Moss Guest

    Linear Systems, I'm guessing? If so, you'll love it once you learn to
    solve these with Laplace transforms (like Jem said). It makes life
    easy.


    It's easiest to solve convolution problems like these graphically. So
    I'll try to do some ascii art. h(t) looks like this (somewhat):
    h(t)
    | ,
    | /|
    |.' |
    .'| |
    ======='--+----------> t
    | t=1
    |
    |
    |
    t=0

    x(t) looks like this:

    x(t)
    |
    |
    | 1 2 3 4 5
    |__
    | |
    ----------+--+-----------+--------> t
    | |___________|
    |
    |
    |

    It is easiest to break this up into two parts. Convolution is linear
    and time-invariant so it is correct to do this.
    Say x1(t)=u(t)-u(t-1) and x2(t)=-u(t-1)+u(t-5), so x1(t) is the upper
    square and x2(t) is the lower rectangle, and x1(t) + x2(t) = x(t)

    Like you said, y(t) = Int ( x(t-T) h(T) ) dT
    This is also equivalent to y(t) = Int ( x(T) h(t - T) ) dT which is
    easier to handle, IMO.

    So, h(t) needs to be mirrored horizontally so we can see h(t-T).


    h(t-T)
    , |
    |\ |
    | `.|
    | |`.
    ------+---+--`========
    T=t-1 |
    |
    |
    |
    T=t

    Overlay this over x1(t), and this will be the case for t=0:


    h(0-T)--> , |
    |\ |_____
    | `.| | <----x1(t)
    | |`. |
    ------+---+--`=+====== T
    -1 |
    |
    |
    |
    T

    Ok, so you are integrating from -oo to oo and multiplying these two
    functions together. x1(t) is zero for everywhere less than 0 and
    everywhere greater than 1. So when you multiply 0 by h(t), you get
    zero. This confines the bounds to 0 and 1, but only when t is less
    than 1. (Otherwise, the two functions would not completely overlap).

    This makes the very first case for x1(t), and it works for t <= 1:

    y1(t) = Int ( x1(T) h(t - T) ) dT from T=0 to T=1

    and since x1(t) is 1 from 0 to 1, you can take that term out of the
    equation, and now it is
    y1(t) = Int ( e^(2t - 2T) ) dT = e^(2t) * Int( e^(-2T)) dT
    = e^(2t) * e^(2T)/(-2) evaluated from 0 to 1 for T
    = e^(2t) * (e^(-2) - 1 ) / (-2) ONLY FOR t<=1 !!

    (BTW, * denotes multiplication there, not convolution)

    Now the second case for x1(t) comes in when t>1 and t<=2:
    Same intetgral, but different limits. Now the limits are from t to 1.
    If you slide h(t-T) over in the picture, you can see why this is the
    case, because that is the only time the two functions overlap.

    y1(t) = Int (e^(2t - 2T) ) dT = e^(2t) * e^(2T)/(-2) evaluated from t
    to 1 for T
    = e^(2t) * (e^(-2) - e^(-2t) ) /(-2) ONLY FOR t>1, t<=2 !!!


    To get the total y(t), you have to continue in the same manner for
    x2(t) and then add y1(t) + y2(t) to get y(t). Hopefully you see how
    this works. Draw it out on a piece of paper, and these get kind of
    fun to do. You have to consider each case to find the bounds for the
    integral.

    I realize the ascii art isn't the best, so if you want I could write
    out the solution and scan it in for you. It would be much easier to
    see.
    Hope that helps,
    -Ben
     
Ask a Question
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.
Electronics Point Logo
Continue to site
Quote of the day

-