Super-convertitore A/D per porta seriale con 6 discreti

Che dire, sono emozionato! :) E' bello vedere crescere progetti per quanto piccoli con il contributo di molti. Domani provo l'impossibile, ovvero, compilare il tuo listato sotto una distro Linux che ho installato di recente (PCOS). Prometto impegno indefesso!

Preparatevi perch=E9 sto ottenendo buoni risultati con l'A/D pi=F9 complesso (6 BJT). Dispone di un ingresso in tensione vero e prorpio (0V to 2,55V, a caso). Ovviamente autoalimentato.

Ciao. Piccio.

A questo punto mi riscarico il Python e provo anche questa. Imparo di pi=F9 cos=EC che con un tomo.

Grazie anche a te! :)

Aggiornamenti imminenti...

Piccio.

Piccio ha scritto:

devi scaricare anche il modulo serial, che se non sbaglio per linux e': pyserial-2.5-rc1.zip

da

Attendiamo :)

ciao Claudio_F

Per cos=EC poco! Ci mancherebbe.

Se hai problemi con i fine linea, mandami un'email (l'indirizzo =E8 valido) e ti faccio avere il file originale, che =E8 poi quello che ho copia/incollato.

Non vediamo l'ora :-) Potrebbe essere la volta che metto qualche termometro in giro per casa.

Dimenticavo... a me il PCOS fa venire in mente l'M20 di olivettiana memoria (1982 circa). Vuoi che ti adatti il programma per collegare il convertitore a questa macchina, per caso? Ne ho proprio una qui a fianco ed un amico ha scritto una versione di gcc che funge da cross- compilatore per questa piattaforma...

Piccio ha scritto:

Se poi lo vuoi provare in modo grafico ;) Dovrebbe fare circa 25 letture al secondo...

#--------------------------------------------------------------------- # PICCIO ADC GRAPHIC-BAR VISUALIZER #--------------------------------------------------------------------- import Tkinter import serial

class ADC(): def __init__ (self): self.form1 =3D Tkinter.Tk() self.form1.title("Piccio ADC graphic visualizer") self.form1.resizable(0, 0) self.canvas1=3DTkinter.Canvas(self.form1, width=3D450, height=3D80, bg=3D"white") self.canvas1.grid(row=3D0, column=3D0) self.elabora() self.form1.mainloop()

def elabora(self): fh.write(chr(0)) v =3D fh.read(1) v =3D ( v and ord(v) ) or 0 z =3D 0 while v: z +=3D 50 v >>=3D 1 self.canvas1.delete("all") self.canvas1.create_rectangle((20, 30, 20+z, 50), fill=3D"red") self.canvas1.after(10, self.elabora)

fh =3D serial.Serial("com1", 300, 8, "N", 2, timeout=3D1) ADC() fh.close()

Molto interessante! Per quanto riguarda il tuo intervento pi=F9 sopra, sono perfettamente d'accordo: ormai interfacciarsi ai calcolatori sta diventando pi=F9 difficile di quanto non fosse vent'anni fa, soprattutto per problemi software pi=F9 che hardware.

Allora, ho provato. MacOSX viene d'ufficio con un interprete Python installato. L'unica differenza =E8 che ho dovuto sostituire la linea:

class ADC():

con la seguente:

class ADC:

per non ottenere un errore di sintassi. Ho installato facilmente l'estensione suggerita per pilotare le seriali (pySerial), scaricando il file suggerito nel post di Claudio_F di ieri, scompattando il pacchetto e lanciando:

$ sudo python setup.py install

Stranamente, ha funzionato tutto al primo colpo. La seconda modifica che ho fatto al programma di Claudio =E8 quella (ovvia) di indicare la mia porta seriale con le solite convenzioni Unix: "/dev/tty.USA19Hb2P1.1" invece che "com1" nella riga in cui la comunicazione viene aperta.

Mi viene mostrata una bella finestrina con una barra rossa, ma sembra che ci siano solo due posizioni permesse: o tutta intera, oppure solo una righetta a sinistra. Sbaglio qualcosa io?

Darwin ha scritto:

Forse hai un interprete versione antecedente alla 2.2, va bene come hai fatto.

Credo sia merito della cura (credo per ora ancora maniacale) con cui vengono testati i moduli e le distribuzioni python. Anche con windows e' filato tutto liscio al primo colpo.... stranamente...

Potrei aver sbagliato qualcosa io nella logica di "decodifica"... per provare la barra "manualmente" ho assegnato di volta in volta a v i valori chr(0), chr(1), chr(1+2), chr(1+2+4) ecc fino a chr(1+2+4+8+16+32+64+128) e ottengo tutte le 8 "posizioni".

Ad esempio "disabilitando" tx/rx seriale:

# fh.write(chr(0)) # v = fh.read(1) v=chr(1+2+4+8)

deve apparire una barra lunga a meta'

Se cosi' non fosse potrebbe esserci un inghippo nell'espressione funzionale:

v = ( v and ord(v) ) or 0

che si puo' riscrivere in forma "comune":

if v: v = ord(c) else: v = 0

Come avrai capito la lettura seriale in python ritorna un carattere, o stringa nulla se scade il timeout di 1 secondo in ricezione.

sappimi dire che questo scambio di informazioni e' interessante :)

ciao Claudio_F

Darwin ha scritto:

Mah, se cominciano a circolare "PC" come questi:

Ho l'impressione che la tecnologia sia matura per trasformare il=20 computer in quell'elettrodomestico "home entertainment" che era il sogno =

proposto dalle prime pubblicita' inizio anni ottanta.

Mi pare che ci sia un discreto successo dei net-PC, e anche di=20 mini/micro PC (simili a=20

permettono di fare tutto quello di cui ha bisogno un utente "comune"=20 (navigazione internet, office, posta, ascolto musica / DVD) in=20 pochissimo spazio e consumando poca energia... e come connessioni=20 hardware usabili dagli utenti "non comuni" rimangono solo USB e LAN.

=2E..... il vecchio bus ISA :=B0(

...

SIGH! Ho problemi a pescare il modulo per la seriale per Windows... Prover=F2 l'avventura (obbligata) con Linux. Si stava meglio quando si stava peggio... :(

Piccio.

Claudio_F ho scritto:

Mi sa che era proprio questo. Non so se l'ordine dei bit di v nel tuo programma e' invertito, ma in effetti qui occorre uno scorrimento a sinistra v

Claudio_F ho riscritto:

No, non l'ordine, leggo adesso che "In many programming languages (including those in the C family), the bitwise NOT operator is ~ (tilde)."

Allora invertiamo, cosi' funziona come il tuo ;)

Il python "ragiona" in termini di "cose ad alto livello" cercando di nascondere il piu' possibile i dettagli implementativi di basso livello, un numero e' un numero, e non una sequenza di bit in un campo lungo 8 16 o 32 bit... non e' neppure possibile dirgli di lavorare con 8 bit... cosi' le operazioni sui singoli bit sono una cosa abbastanza innaturale... e producono risultati poco intuitivi, ho appena scoperto che per fare il giusto complemento bisogna scriverlo in modo esplicito: v = 256 - v - 1

#--------------------------------------------------------------------- # PICCIO ADC GRAPHIC-BAR VISUALIZER - Versione 3.0 XD #--------------------------------------------------------------------- import Tkinter import serial

class ADC: def __init__ (self): self.form1 = Tkinter.Tk() self.form1.title("Piccio ADC graphic visualizer") self.form1.resizable(0, 0) self.canvas1=Tkinter.Canvas(self.form1, width=450, height=80, bg="white") self.canvas1.grid(row=0, column=0) self.elabora() self.form1.mainloop()

def elabora(self): fh.write(chr(0)) v = fh.read(1) v = ( v and ord(v) ) or 0 v = 256 - v - 1 z = 0 while v: z += 50 v >>= 1 self.canvas1.delete("all") self.canvas1.create_rectangle((20, 30, 20+z, 50), fill="red") self.canvas1.after(10, self.elabora)

fh = serial.Serial("/dev/tty.USA19Hb2P1.1", 300, 8, "N", 2, timeout=1) ADC() fh.close()

Questa versione funziona perfettamente sotto MacOSX. Probabilmente, la cosa migliore sarebbe richiedere la porta seriale come argomento, di modo da essere completamente universale.

Molto molto carino. Semplice e funzionale!

Piccio ha scritto:

Premetto che mi diletto di elettronica per passione e ho molte lacune. Ho visto il circuito però non riesco a capirlo, se qualcuno mi da una mano a capirlo ne sono grato. Come prima cosa ho sempre saputo che un convertitore a/d converte un segnale analogico in un digitale. Qui vedo che l'ingresso è praticamente un segnale digitale che proviene dal tx di una seriale 232, praticamente arrivato a questo punto mi sono perso. Non riesco a capire se con questo circuito si riesce realmente a leggere un segnale analogico o se questo è solo una parte di un circuito più complesso.

Alessio

carbonal ha scritto:

E' tutto li, ma piu' che leggere un segnale, il circuito converte in=20 digitale la posizione di un potenziometro. La tensione in arrivo da RX=20 da il via al processo, che e' semplicemente la misura del tempo che ci=20 mette il transistor ad andare in conduzione (dipendente dalla posizione=20 del potenziometro).

Il tutto gioca sul fatto che trasmettendo un valore binario 0 si ottiene =

su TX un impulso a 12V di durata pari a 9 bit, e si rileggono da rx=20 quanti di questi bit sono a zero e quanti a 1.

Dopo di che il software conta gli uni o gli zeri e classifica=20 (quantizza) la posizione del potenziometro in 8 settori (risoluzione di=20

ciao Claudio_F

Claudio_F ho scritto:

ovviamente volevo dire TX

Non so cosa dicano gli standard, ma nei 1488, i line receiver usati per decenni per la RS232, l'isteresi c'era sicuramente, assieme anche ad un pin per programmare il centro delle soglie. Comunque posso confermare che molte seriali di PC accettano un segnale 0-5V, cosa che permette di collegare direttamente, per esempio, un microcontrollore. Sfortunatamente molte altre seriali non accettano questi livelli e perci=F2 bisogna dotare il micro del canonico line driver capace di fornire tensioni negative.

Claudio_F ha scritto:

ti ringrazio molto dela spiegazione, ora mi è tutto più chiaro.

Alessio