How to implement a pipeline...??? Please help

[Ritchy lelis]

Hi guys

In the development of my ADC project i have a new new challenge.

First i need to implement a 10 Bit pipelineADC  that  will be the
basis to later implement any kind of pipeline arquitecture (i mean,
with 10 Bit, 16 Bit or any other configuration i want) i wish to...

What's a 10 Bit pipiline ADC?

This link with a draw will help have a perfect view of what is it:
 http://t3.gstatic.com/images?q=tbn:ANd9GcQK_Pwz3ssk1yoDDFwGjJ5FWAwcqr1mV9EwdndlHCEvOMdTOa4&t=1&usg=__-TsH7dnNdJm4GZTuWCxjvajZhfk=

To have a 10 Bit pipiline ADC we need 9 stages, where 8 of them are a
1.5 bit configuration and the last one have a 2 Bit configuration.

How it works?

When we inject a input voltage (at the first block), it will be
computed in the first 1.5 Bit stage and when finished the compute it
will generate a output voltage who served of input voltage for the
second 1.5 Bit stage which in his turn generate also a output voltage
who served of input voltage in the third stage ... and successively
continuing until the ninth stage. The ninth stage it's a 2 Bit stage
and it will receive the last output voltage from the eighth stage and
in his turn it will compute a final output signal.

I already implemented the 1.5 Bit/stage and the 2 Bit/stage functions
with good results (i already watch their plot's and they are cool to
me) but my Pipeline function try don't seems that good.

After the 2 Bit compute i expect a output signal like the drawing on
the link below but more stretched.
http://t3.gstatic.com/images?q=tbn:ANd9GcQGQYDW0iLCSXfMMurIksWsgklsvtj26IBtQRacFtY7ifu9RQA&t=1&usg=__-yHJFMatnCPcf9jWQv3kaxM0brE=

Instead of have a lot of steps one after the another, it will have
something like a single step only. Why? That it's because when we have
a pipeline with a lot of stage's the final output voltage until the 2
Bit stage it's very "dense" and long and that nearly saturating the
last block ( the 2 Bit stage).

Next i will leave the code that I have done so far for my Pipeline
function:

-------------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------------

from flash1b5 import flash1b5
from flash1b5 import *
from flash2b import flash2b
from flash2b import *
import matplotlib.pyplot as plt
import numpy as np
from pylab import *

if __name__ == "__main__":

    Inc = raw_input("Valor do Incrimento = ")

    Vref = np.linspace(1,1, Inc)
    Vi = np.linspace(-1,1, Inc)

    Cs = np.linspace(3e-12, 3e-12, Inc)
    Cf = np.linspace(3e-12, 3e-12, Inc)

    f1 = flash1b5(Vi, Vref, Cs, Cf)

    Vin1 = f1[0]
    Vt1 = f1[1]
    Vd1 = f1[2]


    f2b = flash2b(Vt1, Vref)

    Vin2 = f2b[0]
    Vd2 = f2b[1]


    hold(True)

    fig2 = figure(1,figsize=(8,5))
    ax2 = fig2.add_subplot(111, autoscale_on=False, xlim=(-1,1),
ylim=(-0.5,2.5))
    ax2.plot(Vin2, Vd2, lw=2, color='blue')
    grid (True); xlabel('V_ent');ylabel('Vout_Digital')


    plt.show()
-------------------------------------------------------------------------------------------------------------------------------------------------------------------

The 1.5 Bit function:

import numpy as np
from pylab import *


def flash1b5(Vi, Vref, Cs, Cf):

    Vin = np.zeros(Vi.shape, dtype=np.float)
    Vt = np.zeros(Vi.shape, dtype=np.float)
    Vd = np.zeros(Vi.shape, dtype=np.float)

    if any(Vi > Vref/4):
        mask1 = (Vi > Vref/4)
        np.putmask(Vin, mask1, Vi)
        Vs= (1+Cs/Cf)*Vin - (Cs/Cf)*Vref
        np.putmask(Vd, mask1, [2])
        np.putmask(Vt, mask1, Vs)

##
    if any(-Vref/4 <= Vi) and any( Vi<= Vref/4):
        mask2 = (-Vref/4 <= Vi) & (Vi <= Vref/4)
        np.putmask(Vin, mask2, Vi)
        Vs = (1+(Cs/Cf))*Vin
        np.putmask(Vd, mask2, [1])
        np.putmask(Vt, mask2, Vs)

##
    if any(Vi < -Vref/4):
        mask3 = (Vi < -Vref/4)
        np.putmask(Vin, mask3, Vi)
        Vs= (1+Cs/Cf)*Vin + (Cs/Cf)*Vref
        np.putmask(Vd, mask3, [0])
        np.putmask(Vt, mask3, Vs)

##
    out = [Vin, Vt, Vd]
    return out
-------------------------------------------------------------------------------------------------------------------------------------------------------------------

The 2 Bit function:

import numpy as np
from pylab import *


def flash2b(Vi, Vref):

    Vin = np.zeros(Vi.shape, dtype=np.float)
    Vt = np.zeros(Vi.shape, dtype=np.float)
    Vd = np.zeros(Vi.shape, dtype=np.float)

    if any(Vi > Vref/2):
        mask1 = (Vi > Vref/2)
        np.putmask(Vin, mask1, Vi)
        np.putmask(Vd, mask1, [3])

    if any(Vi > 0) and any(Vref/2 >= Vi):
        mask2 = (Vref/2 >= Vi) & (Vi > 0)
        np.putmask(Vin, mask2, Vi)
        np.putmask(Vd, mask2, [2])

    if any(Vi <= 0) and any(-Vref/2 < Vi):
        mask3 = (-Vref/2 < Vi) & (Vi <= 0)
        np.putmask(Vin, mask3, Vi)
        np.putmask(Vd, mask3, [1])

    if any(Vi <= -Vref/2):
        mask4 = (Vi < -Vref/2)
        np.putmask(Vin, mask4, Vi)
        np.putmask(Vd, mask4, [0])

    S_Out = [Vin, Vd]

    return S_Out
---------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------

Guys i'm asking if it's possible for a generic function for a
pipeline, all the suggestions ideas are welcome.

Also if you have a specific solution for my problem I will be grateful
for it here.

Thanks for reading my post.

Cheers