Como una continuación del manejo del puerto paralelo con Python que realice como una contribución a un programa de munguis, ahora presento el manejo del puerto Serie con Python. Para este además del código de Python vamos a necesitar un hardware, que sera a partir de un microcontrolador, el PIC16F876. Espero que sepan utilizar dichos controladores, los parámetros importantes son que el PORTB será de salida y el cristal a usar será de 4MHz para una comunicación a 9600 Bauds. El código asm para ensamblar y programar al PIc es el siguiente:

<pre>
; readf.asm
;
; CopyLeft 2008 Aztk
;
; This program is free software; you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 2 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program; if not, write to the Free Software
; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
; MA 02110-1301, USA.
; -----------------------------------------------------------------------
; Este programa configura al PIC para leer 1 byte enviado del PC a
; una velocidad de 9600 bauds con un cristal de 4MHz.
; El dato se imprimirá en el PORTB.

processor 16f877
; -----------------------------------------------------------------------
; Template source file generated by piklab
#include <p16f877.inc>

; -----------------------------------------------------------------------
; Bits de configuración:
__CONFIG 0x3F71

; -----------------------------------------------------------------------
; inicio

org 0x00 ; Respetamos vector de
goto start ; interrupción
org 0x05
start: bsf STATUS,RP0 ; Bank01
clrf TRISB ; PORTB = 'ssss ssss'
movlw .25 ; Fosc = 4MHz
movwf SPBRG ; BaudRate = 9600
bsf TXSTA,BRGH ; High-Speed
bcf TXSTA,SYNC ; Modo asíncrono
bcf STATUS,RP0 ; Bank00
bsf RCSTA,SPEN
bsf RCSTA,CREN ; Habilitar recepción
clrf PORTB ; Limpiar primero el PORTB
readf:
wait: btfss PIR1,RCIF ; ¿Dato recibido?
goto wait ; No, esperar
movf RCREG,W ; Si, cargar dato a W
movwf PORTB ; imprimir dato de W al PORTB
goto readf ; Regresar para esperar
; otro dato
end
</pre>

Ahora para el programa en Python, es prácticamente el mismo que utilice con el manejo del puerto paralelo con Python, a excepción de que no utilizo el modulo parport sino es el PySerial, ventajas de usar este puerto es que para mi se me hace más fácil que el puerto paralelo, se pueden usar todos los pines del micro y definir cuantos serán de entrada y cuantos de salida (aunque en este ejemplo solo hemos definido 8 bits de salida) además de que NO! son necesarios permisos del superUser.
Los requisitos para este programa es que se tengan instalado Python, las librerías del escritorio GTK+, las librerías PyGTK y el modulo Pyserial (pueden buscarlas en Synaptic).

<pre>
#!/usr/bin/env python
#
# serieAztk.py
#
# CopyLeft 2008 aztk
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.

# 'pySerial'('serial' is a module that encapsulates the access
# for the serial port, to know how install it visit:
# http://pyserial.wiki.sourceforge.net/pySerial
import serial

import pygtk
pygtk.require('2.0'
import gtk

s = serial.Serial(0) # Open port '/dev/tty0', BaudRate 9600
pdatax = 0

class SerialX:

# This callback write a data in serial port
def writex(self, widget, data=None):
global pdatax

# When a button is hold on
if (widget.get_active()):
pdatax = pdatax + data
print "data = %s" %(pdatax)
s.write(chr(pdatax))

# When a button is hold off
else:
pdatax = pdatax - data
print "data = %s" %(pdatax)
s.write(chr(pdatax))

# This callback quits the program
def delete_event(self, widget, event, data=None):
s.write('\x00' # Clear the seril port
s.close() # Close the seril port
return gtk.FALSE

def destroy(self, widget, data=None):
s.write('\x00'
s.close()
print "data = 0"
print "Good Wave!!! "
gtk.main_quit()

def __init__(self):

# Create a new window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("SerialX"
self.window.connect("delete_event", self.delete_event)
self.window.set_border_width(20)
self.window.set_resizable(gtk.FALSE)

# Create a vertical box
vbox = gtk.VBox(gtk.TRUE, 2)
self.window.add(vbox)

# Create the data buttons (D07)
# D0
d0 = gtk.ToggleButton("D0"
d0.connect("toggled", self.writex, 0x01)
vbox.pack_start(d0, gtk.TRUE, gtk.TRUE, 2)
# D1
d1 = gtk.ToggleButton("D1"
d1.connect("toggled", self.writex, 0x02)
vbox.pack_start(d1, gtk.TRUE, gtk.TRUE, 2)
# D2
d2 = gtk.ToggleButton("D2"
d2.connect("toggled", self.writex, 0x04)
vbox.pack_start(d2, gtk.TRUE, gtk.TRUE, 2)
# D3
d3 = gtk.ToggleButton("D3"
d3.connect("toggled", self.writex, 0x0
vbox.pack_start(d3, gtk.TRUE, gtk.TRUE, 2)
# D4
d4 = gtk.ToggleButton("D4"
d4.connect("toggled", self.writex, 0x10)
vbox.pack_start(d4, gtk.TRUE, gtk.TRUE, 2)
# D5
d5 = gtk.ToggleButton("D5"
d5.connect("toggled", self.writex, 0x20)
vbox.pack_start(d5, gtk.TRUE, gtk.TRUE, 2)
# D6
d6 = gtk.ToggleButton("D6"
d6.connect("toggled", self.writex, 0x40)
vbox.pack_start(d6, gtk.TRUE, gtk.TRUE, 2)
# D7
d7 = gtk.ToggleButton("D7"
d7.connect("toggled", self.writex, 0x80)
vbox.pack_start(d7, gtk.TRUE, gtk.TRUE, 2)

# Add a separator for the quitbutton
separator = gtk.HSeparator()
separator.set_size_request(120, 5)
vbox.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)

# Create the "Quit" button
buttonq = gtk.Button("Quit"
buttonq.connect("clicked", self.destroy, None)
vbox.pack_start(buttonq, gtk.TRUE, gtk.TRUE, 2)

self.window.show_all()

def main():
gtk.main()
return 0

if __name__ == '__main__':
SerialX()
main()

# This code is inspirated in a munguis' code
# Thanks munguis
# http://munguis.wordpress.com/2008/02/16/manejo-del-puerto-paralelo-con-python/

# http://www.pygtk.org/pygtk2tutorial-es/
# A great tuto about pygtk
</pre>

Buena Vibra!

Nota: Sigo insistiendo en que falta un subforo de 'Desarrollo', aunque sea yo el único que lo use, jajajaja

Hola Aztk

Oye yo tambien estoy empesando con este pero de control del puerto serie, estudie un poco de control automatico pero con el uso de PLC, pero ahora estoy por hacer mi estancai profecional, y tengo como proyecto elcontrol de una valvula en base a un sensor, me dicen que necesitaremos monitorear antes el sistema antes de comensar el control de este, y para ello se esta pensando en hacerlo a traves del puerto serie. La verdad estoy verde en este pero me estoy poniendo en putisa a investigar sobre ello, por que la neta en la escuela vimos bien leve eso.

Bueno al grano, ya estube investigando como tengo que armar el circuito para intalar el sensor y este conectarlo al puerto y tengo entendido en un orden asi:
sensor ---> conversor A/D ---->PIC---->Puerto Serie

Bueno me gustaria me orientaras si voy por buen camino, he estado leyendo un chingo un manual sobre Python, la neta esque me estoy agarrando apenas a este lenguage, se en otros pero no de uso en Linux, y pues quiero olvidarme de win2.

Sas pues muy buen post y no te desanimes esperemos el admin incluya un seccion de desarrollo, digo voy empesando pero soy entusiasta y con un chingo de ganas de aprender en linux. Asdi que al rato puede que yo sea el que te acompañe en este foro jajaja.

Camara estamos en contacto, por ahi voy a postear de un problema que traigo con el fsck ojala me puedas hechar la mano.
Grax

Hey Karloseer!!
Jejejeje, da gusto encontrarse electrónicos (o personas relacionadas con estos temas) usando Ubuntu.
Sabes usar Pics???? Me imagino que no, pss bien algunos pics tienen incluidos convertidores analógicos a digital, como el 16f876 (el que use para este tema), también el puerto serie es de entrada/salida por lo que puedes incluir el control desde el mismo pic (con su adecuada etapa de potencia) para la electroválvula.
Kuentame más sobre tu proyecto para que con gusto te de una mano, que tipo de sensor es el que vas a ocupar??????
Kamara bro!
Buena Vibra!

Que onda aztk, perdon por la demora estaba de vacasiones, pero aqui estoy de nuevo.

Bueno mi proyecto se trata de monitorear dos sensores (una termocupla y un hidrofono), usando el puerto serie o bien paralelo usb, no se cual me venga mejor. Tengo planeado usar un PIC que ya venga con el convertidor ADC y con la salida al puerto, la verdad aun no establesco si va a ser necesario un amplificador de la se;al de los sensores.

Estoy duro y dale aprendiendo programacion Python pero pues tambien me tengo que meter con programacion de PIC, cosa que no he hecho nada. Podrias orientarme un poco para empesar a aprender programacion de PICs?, tengo un tecnico en mi escuela que me esta hechando la mano, pero ya ves uno no dispone del tiempo de nadie.

Me he puesto a leer un tutorial de Python pero ya veo que estoy tremendamente tierno en la programacion con este lenguaje, intento leer el programam que aqui pones y duras penas capto mas o menos. Pero no lo voy a dejar de lado, continuo con este lenguaje.

Intente ejecutar tu programa pero pienso que no lo estoy haciendo bien, copie el codigo lo meti en un archivo con extencion .py y lo ejecuto, como hasta ahora le he hecho con los progamas que he elaborado. pero claro este es mas avansado, me das el tip de como puedo usarlo, o a fuerzas tengo que aver programado y conectado el PIC?

Aztk tenme pasiencia para seguir con este lenguaje porque los profesores me estan queriendo meter otros C, o bien el uso de Mathlab, pero no quiero, en fin aqui estamos en contacto, no se si se prodente tenta charla por este medio o quieras darme tu correo y despues presentarles en este foro avaces, para que no se engorren con tanta platica. Como ves?

que hongo 'karloseer'!

Si vas a usar un PIC pss sería mejor usar el puerto Serie, así aprovechas mejor el chip y el circuito es más pequeño, trata que tu señal no sobrepase los 5V porque si pasa eso se puede dañar el ucontrolador pero también es bueno tratar de abarcar lo más posible los 5V para tener una mejor exactitud.

Claro que te puedo echar un cable con la programación de PICs, aunque solo sé assembly, pero eso sería en otros foros (http://www.forosdeelectronica.com/) o no sé si se pueda aquí ¿?

La neta yo no tengo mucha idea sobre Python, pero con lo que sé de otros lenguajes (que es muy poco) e investigando un poco puedo ingeniármelas para crear aplicaciones sencillas. Este programa que hize son de copy/paste's (copiar/pegar's) de ejemplos del tuto de PyGTK (http://www.pygtk.org/pygtk2tutorial-es/index.html) para crear la ventana y botones. La parte interesante es que cada botón tiene un peso: 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 (del LSB al MS, cuando un botón de ellos es clickeado se llama a la retrollamada (valga la redundancia) 'writex' la cual si el botón es sumido se le suma el peso al dato a escribir en el puerto serie, pero si el botón es soltado se le resta el peso. Los botones son 'Toggle Buttons' esto es que si se les da un click se mantienen presionados hasta que se le vuelve a dar otro click para quedar sueltos. Al inicio todos los botones estan sueltos y el dato a enviar está en 0 (0x00). Espero que no te este confundiendo más y espero igual que tengas nociones del sistema binario (igualmente hexadecimal).

Mta, se fue la luz, mejor luego te sigo explicando.

Buena Vibra!