On 26 Ago, 08:52, Dennis Lee Bieber <wlfr...@ix.netcom.com> wrote: > On Tue, 24 Aug 2010 22:21:34 -0700 (PDT), Ritchy lelis > <ritchy_g...@hotmail.com> declaimed the following in > gmane.comp.python.general: > > > hi friend Dennis Lee Bieber > > > I have watching your code sujestion and now i can understand more of > > what you have there.. > > Take warning -- I think I had a major flaw in the summation part of > the logic... It's probably easier just to use a list of lists (one list > per stage, and each list as long as the number of stages) and sum the > diagonal > > result = sum([list_of_lists[i][i] for i in range(number_of_stages)]) > > > i would like to show you them but i need to now if you still > > interested in the challenge it self and also in helping me with your > > extraordinary tips. > > > Can i count on your help? I hope so gratefully. > > My apologies... much more help and I'll have done the work for you > (though I'm still perplexed at simulating a hardware A/D converter when > the input is already a floating point digital, and the output is integer > digital) > -- > Wulfraed Dennis Lee Bieber AF6VN > wlfr...@ix.netcom.com HTTP://wlfraed.home.netcom.com/
My apologies... much more help and I'll have done the work for you Until now you were the only person who helped me so far... your help has served a lot. Already learned a lot with you so please do not stop helping me. To show you that you have not done it alone, i'll show you that i have made some arrangements. About the pipeline Class still have some errors and i'm working on it. Hope this link help. http://www.eetimes.com/design/automotive-design/4010021/SIGNAL-CHAIN-BASICS-Part-8--Flash-and-Pipeline-Converter-Operation-Explored though I'm still perplexed at simulating a hardware A/D converter when > the input is already a floating point digital, and the output is integer > digital I believe that de residuals that we're getting at the output, already are the wave forms that we should get if we had a Oscilloscope and analyzing the behavior of a A/D hardware and the digital parts is to quantify the analog input ie first we analyze and translate the analog input to a known residue and then quantifies to the digital output. I already initialized the "non linear" issues with the Class Calculate, and after this we will start to see how A/D converter really works. I would love you to help me at this one to Class Calculate: 1 - http://www.national.com/appinfo/adc/files/ABCs_of_ADCs.pdf 2 - http://www.atmel.com/dyn/resources/prod_documents/doc2559.pdf And now my new arrangements: # -*- coding: cp1252 -*- #######################################ADC##################################### ##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Incluir as Bibliotecas>>>>>>>>>>>>>>>>>>>>>>>> import matplotlib.pyplot as plt import numpy as np from numpy.random import * from numpy.fft import * from pylab import * ##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>CLASS ADC>>>>>>>>>>>>>>>>>>>>>>>>>>>> class ADC(object): def __init__(self, Inc, V_in, V_ref, Cs, Cf): ##Guarda o número de estágio e a tensão de referência ## Stores the number of stage and reference voltage self.Inc = Inc self.V_ref = V_ref self.Cs = Cs self.Cf = Cs ##calcula os limiares da tensão do comparador ##calculates the threshold voltage of the comparator self.V_H = self.V_ref * 0.25 self.V_L = -self.V_H self.V_in = V_in #define dois array de "Inc" elementos todos a uns e zeros respectivamente ##sets two array "Inc" elements all the ones and zeros respectively self.ones = np.ones(Inc, dtype=np.float) self.zeros = np.zeros(Inc, dtype=np.float) ##função flash 1.5 bit ##1.5 bit flash function def flash1b5(self): # calcula as posições onde a tensão de entrada excede o limiar alto ## calculates the positions where the input voltage exceeds the high threshold highBits = np.where(self.V_in > self.V_H, self.ones, self.zeros) # calcula as posições onde a tensão de entrada é menor que o limiar baixo ## calculates the positions where the input voltage is less than the low threshold lowBits = np.where(self.V_in < self.V_L, self.ones, self.zeros) # calcula as posições onde a tensão de entrada é maior que o limiar baixo e não excede o limiar alto ## calculates the positions where the input voltage is greater than the low threshold and does not exceed the high threshold midleBits = np.where(highBits + lowBits == 0, self.ones, self.zeros) # "digital" output pode ser obtido somando 1 e o highBits e subtraindo lowBits ## "Digital" output can be obtained by adding and subtracting 1 and highBits lowBits self.digital_out = 1 + highBits + -lowBits # calcular residuo ## Calculate residue self.residuals = (((1+self.Cs/self.Cf)* self.V_in) -((self.Cs/self.Cf) * self.V_ref)) * highBits + ((1+self.Cs/ self.Cf)* self.V_in )* midleBits + (((1+self.Cs/self.Cf)* self.V_in) + ((self.Cs/ self.Cf)* self.V_ref)) * lowBits # retorno da saida digital e do residuo ## return of the digital output and the residue out = [self.digital_out, self.residuals] return out ##função flash 2 bit ## 2 bit flash function def flash2b(self): # calcula as posições onde a tensão de entrada excede o limiar alto ## calculates the positions where the input voltage exceeds the high threshold # (2X the threshold of the 1.5B stages) highBits1 = np.where(self.V_in > 2*self.V_H, [3], self.zeros) # calcula as posições onde a tensão de entrada está entre zero e o limiar alto ## calculates the positions where the input voltage is between zero and the high threshold if any(self.V_in <= 2*self.V_H) and any(self.V_in > 0.0): highBits2 = np.where((self.V_in <= 2*self.V_H) & (self.V_in > 0.0), [2], self.zeros) # calcula as posições onde a tensão de entrada está entre zero e o limiar baixo ## calculates the positions where the input voltage is between zero and low threshold if any(self.V_in <= 0.0) and any(self.V_in > 2*self.V_L): lowBits1 = np.where((self.V_in <= 0.0) & (self.V_in > 2*self.V_L), self.ones,self.zeros) # calcula as posições onde a tensão de entrada é menor que o limiar baixo ## calculates the positions where the input voltage is less than the low threshold lowBits2 = np.where(self.V_in <= 2*self.V_L, self.zeros, self.zeros) # "digital" output pode ser obtido somando todas as posiçoes desta forma. ## "Digital" output can be obtained by adding all the positions in this way self.digital_out = lowBits2 + lowBits1 + highBits2+ highBits1 # retorno da saida digital ## Digital output return out = [self.digital_out] return out ##função flash 2.5 bit ## 2.5 bit flash function def flash2b5(self): ## calculates the positions where the input voltage exceeds the high threshold highBits1 = np.where(self.V_in > (self.V_H*5/2), self.ones, self.zeros) ## calculates the positions where the input voltage is between zero and the high threshold if any(self.V_in <= (self.V_H*5/2)) and any(self.V_in >=(self.V_H*3/2)): highBits2 = np.where((self.V_in <= (self.V_H*5/2)) & (self.V_in >=(self.V_H*3/2)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*3/2)) and any(self.V_in >=(self.V_H*1/2)): highBits3 = np.where((self.V_in <= (self.V_H*3/2)) & (self.V_in >=(self.V_H*1/2)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*1/2)) and any(self.V_in >=(self.V_L*1/2)): midleBits = np.where((self.V_in <= (self.V_H*1/2)) & (self.V_in >=(self.V_L*1/2)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*1/2)) and any(self.V_in >=(self.V_L*3/2)): lowBits1 = np.where((self.V_in <= (self.V_L*1/2)) & (self.V_in >=(self.V_L*3/2)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*3/2)) and any(self.V_in >=(self.V_L*5/2)): lowBits2 = np.where((self.V_in <= (self.V_L*3/2)) & (self.V_in >=(self.V_L*5/2)), self.ones, self.zeros) ## calculates the positions where the input voltage is less than the low threshold lowBits3 = np.where(self.V_in < (self.V_L*5/2), self.ones, self.zeros) ## Calculate residue 2.5 Bit self.residuals = ((4*self.V_in - 3*self.V_ref)*highBits1 + (4*self.V_in - 2*self.V_ref) * highBits2 + (4*self.V_in - self.V_ref) * highBits3 + (4 * self.V_in) * midleBits + (4*self.V_in + self.V_ref) * lowBits1 + (4*self.V_in + 2*self.V_ref) * lowBits2 + (4*self.V_in + 3*self.V_ref) * lowBits3) ## Residue output return out = [self.residuals] return out ## ## ##função flash 3 Bit ## 3 Bit flash function def flash3b(self): ## calculates the positions where the input voltage exceeds the high threshold highBits1 = np.where(self.V_in > (self.V_H*3), [7], self.zeros) ## calculates the positions where the input voltage is between zero and the high threshold if any(self.V_in <= (self.V_H*3)) and any(self.V_in >=self.V_H*2): highBits2 = np.where((self.V_in <= (self.V_H*3)) & (self.V_in >=(self.V_H*2)), [6], self.zeros) if any(self.V_in <= (self.V_H*2)) and any(self.V_in >=(self.V_H)): highBits3 = np.where((self.V_in <= (self.V_H*2)) & (self.V_in >=(self.V_H)), [5], self.zeros) if any(self.V_in <= (self.V_H)) and any(self.V_in >=0.0): highBits4 = np.where((self.V_in <= (self.V_H)) & (self.V_in >=0.0), [4], self.zeros) if any(self.V_in <= 0.0) and any(self.V_in >= (self.V_L)): lowBits1 = np.where((self.V_in <= 0.0) & (self.V_in >= (self.V_L)), [3], self.zeros) if any(self.V_in <= (self.V_L)) and any(self.V_in >=(self.V_L*2)): lowBits2 = np.where((self.V_in <= (self.V_L)) & (self.V_in >=(self.V_L*2)), [2], self.zeros) if any(self.V_in <= (self.V_L*2)) and any(self.V_in >=(self.V_L*3)): lowBits3 = np.where((self.V_in <= (self.V_L*2)) & (self.V_in >=(self.V_L*3)), [1], self.zeros) ## calculates the positions where the input voltage is less than the low threshold lowBits4 = np.where(self.V_in < (self.V_L*3), self.zeros, self.zeros) ## "Digital" output can be obtained by adding all the positions in this way self.digital_out = lowBits4 + lowBits3 + lowBits2 + lowBits1 + highBits4 + highBits3 + highBits2 +highBits1 # retorno da saida digital ## Digital output return out = [self.digital_out] return out ## ## ##função flash 3.5 bit ## 3.5 Bit flash function def flash3b5(self): ## calculates the positions where the input voltage exceeds the high threshold highBits1 = np.where(self.V_in > (self.V_H*13/4), self.ones, self.zeros) ## calculates the positions where the input voltage is between zero and the high threshold if any(self.V_in <= (self.V_H*13/4)) and any(self.V_in >=(self.V_H*11/4)): highBits2 = np.where((self.V_in <= (self.V_H*13/4)) & (self.V_in >=(self.V_H*11/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*11/4)) and any(self.V_in >=(self.V_H*9/4)): highBits3 = np.where((self.V_in <= (self.V_H*11/4)) & (self.V_in >=(self.V_H*9/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*9/4)) and any(self.V_in >=(self.V_H*7/4)): highBits4 = np.where((self.V_in <= (self.V_H*9/4)) & (self.V_in >=(self.V_H*7/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*7/4)) and any(self.V_in >=(self.V_H*5/4)): highBits5 = np.where((self.V_in <= (self.V_H*7/4)) & (self.V_in >=(self.V_H*5/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*5/4)) and any(self.V_in >=(self.V_H*3/4)): highBits6 = np.where((self.V_in <= (self.V_H*5/4)) & (self.V_in >=(self.V_H*3/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*3/4)) and any(self.V_in >=(self.V_H*1/4)): highBits7 = np.where((self.V_in <= (self.V_H*3/4)) & (self.V_in >=(self.V_H*1/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_H*1/4)) and any(self.V_in >=(self.V_L*1/4)): midleBits = np.where((self.V_in <= (self.V_H*1/4)) & (self.V_in >=(self.V_L*1/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*1/4)) and any(self.V_in >=(self.V_L*3/4)): lowBits1 = np.where((self.V_in <= (self.V_L*1/4)) & (self.V_in >=(self.V_L*3/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*3/4)) and any(self.V_in >=(self.V_L*5/4)): lowBits2 = np.where((self.V_in <= (self.V_L*3/4)) & (self.V_in >=(self.V_L*5/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*5/4)) and any(self.V_in >=(self.V_L*7/4)): lowBits3 = np.where((self.V_in <= (self.V_L*5/4)) & (self.V_in >=(self.V_L*7/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*7/4)) and any(self.V_in >=(self.V_L*9/4)): lowBits4 = np.where((self.V_in <= (self.V_L*7/4)) & (self.V_in >=(self.V_L*9/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*9/4)) and any(self.V_in >=(self.V_L*11/4)): lowBits5 = np.where((self.V_in <= (self.V_L*9/4)) & (self.V_in >=(self.V_L*11/4)), self.ones, self.zeros) if any(self.V_in <= (self.V_L*11/4)) and any(self.V_in >=(self.V_L*13/4)): lowBits6 = np.where((self.V_in <= (self.V_L*11/4)) & (self.V_in >=(self.V_L*13/4)), self.ones, self.zeros) ## calculates the positions where the input voltage is less than the low threshold lowBits7 = np.where(self.V_in < (self.V_L*13/4), self.ones, self.zeros) ## Calculate residue 3.5 Bit self.residuals = ((8*self.V_in - 7*self.V_ref) *highBits1 + (8*self.V_in - 6*self.V_ref)* highBits2 + (8*self.V_in - 5*self.V_ref)*highBits3 + (8*self.V_in - 4*self.V_ref) * highBits4 + (8*self.V_in - 3*self.V_ref) * highBits5 + (8*self.V_in - 2*self.V_ref) * highBits6 + (8*self.V_in - self.V_ref) * highBits7 + (8 * self.V_in) * midleBits + (8*self.V_in + self.V_ref) * lowBits1 + (8*self.V_in + 2*self.V_ref) * lowBits2 + (8*self.V_in + 3*self.V_ref) * lowBits3 + (8*self.V_in + 4*self.V_ref) * lowBits4 + (8*self.V_in + 5*self.V_ref) * lowBits5 + (8*self.V_in + 6*self.V_ref) * lowBits6 + (8*self.V_in + 7*self.V_ref) * lowBits7 ) ## Residue output return out = [self.residuals] return out ## ## ## ##função Pipeline ## def pipeline(self): ##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>CLASS CALCULATE>>>>>>>>>>>>>>>>>>>>>>>>>>>> ##class calculate(ADC): ## ## def __init__ (self): ## ## ## def AC_Errors(self): ## ## ## def Offset_Errors(self): ## ## ## def plot_fft(self): ## ## ## def DNL_INL(self): ##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>SIMULAÇÃO>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ## if __name__=='__main__': V_in = np.linspace(-1, 1, 10000) F1B5 = ADC(10000, V_in, 1, 2, 2).flash1b5() F2B = ADC(10000, V_in, 1, 2, 2).flash2b() F2B5 = ADC(10000, V_in, 1, 2, 2).flash2b5() F3B5 = ADC(10000, V_in, 1, 2, 2).flash3b5() F3B = ADC(10000, V_in, 1, 2, 2).flash3b() fig1 = figure(1,figsize=(8,5)) ax1 = fig1.add_subplot(111, autoscale_on=True) ax1.plot(V_in, F1B5[1], lw = 1, color='b') grid(True); xlabel('IN'); ylabel('OUT'); title('RESIDUALS 1B5') fig2 = figure(2,figsize=(8,5)) ax2 = fig2.add_subplot(111, autoscale_on=False,xlim=(-1,1), ylim=(-1,3)) ax2.plot(V_in, F1B5[0], lw=1, color='r') grid(True); xlabel('IN'); ylabel('OUT'); title('DIGITAL OUT 1B5') fig3 = figure(3,figsize=(8,5)) ax3 = fig3.add_subplot(111, autoscale_on=False,xlim=(-1,1), ylim=(-1,4)) ax3.plot(V_in, F2B[0], lw=1, color='g') grid(True); xlabel('IN'); ylabel('OUT'); title('DIGITAL OUT 2B') fig4 = figure(4,figsize=(8,5)) ax4 = fig4.add_subplot(111, autoscale_on=True) ax4.plot(V_in, F2B5[0], lw=1, color='y') grid(True); xlabel('IN'); ylabel('OUT'); title('RESIDUALS 2B5') fig5 = figure(5,figsize=(8,5)) ax5 = fig5.add_subplot(111, autoscale_on=False,xlim=(-1,1), ylim=(-1,8)) ax5.plot(V_in, F3B[0], lw=1, color='brown') grid(True); xlabel('IN'); ylabel('OUT'); title('DIGITAL OUT 3B') fig6 = figure(6,figsize=(8,5)) ax6 = fig6.add_subplot(111, autoscale_on=False, xlim=(-1,1), ylim=(-1,1)) ax6.plot(V_in, F3B5[0], lw=1, color='purple') grid(True); xlabel('IN'); ylabel('OUT'); title('RESIDUALS 3B5') plt.show() Ps: How can i put my messages just for you to read it like you always do? -- http://mail.python.org/mailman/listinfo/python-list