Representação da formula de Bhaskara em Python

Bem pessoal, essa dica não é algo fantástico  e muito menos  difícil de se encontrar por aí, mas mesmo assim resolvi postar para aquele que estão iniciando com a linguagem Python.

Sem dúvida alguma, um dos primeiros algoritmos ensinados em um curso de computação quando se está aprendendo uma linguagem de programação, é o calculo da formula de bhaskara. Esse calculo é um dos mais famosos métodos de resolução de uma equação. Pode-se dizer que é um modelo matemático que fornece, quase que instantaneamente, as raízes de uma equação do 2º grau.

Um exemplo que demonstra isso é:

x² + 3x – 4 = 0

Para resolvermos essa equação basta aplicar a formula de Bhaskara e pronto, obteremos dois resultados que serão os valores possíveis para as duas raízes. Segundo Bhaskara (nome do indiano criador da formula tão conhecida e usada) a formula é escrita dessa maneira:

Levando em conta a equação acima o calculo utilizando a formula seria:

Muito fácil não? Claro que sim… Mas e se eu quisesse expressar isso em um programa na linguagem C, como ficaria? Bem, verificando rapidamente os cálculos que são feitos em todo o processo de desenvolvimento da equação temos:

1 – Elevar b ao expoente 2  (obtém-se 9).
2 – Fazer a multiplicação de 4(a)(c) (obtém-se 16).
3 – Fazer a soma entre os valores dos passos 1° e 2° (obtem-se raiz de 25).
4 – Extrair a raiz obtida no 3° passo (obtem-se 5).
5 – Agora vamos obter o valor para a primeira raiz que é chamada de x’ para isso se faz 3 + 5 = 2 que entao é dividido por 2 (obtem-se x’ = 1)
6 – Agora vamos obter o valor para a segunda raiz que é chamada de x” para isso se faz  -3 – 5 = -8 que então é divido por 2 (obtem-se x” = -4)

Todos esses passos do calculo feito acima pode ser resumido para a linguagem Python dessa forma:

x=(b**2)-(4*a*c)
x=math.sqrt(x)
x1=(-b+x)/(2*a)
x2=(-b-x)/(2*a)

Um código completo para o calculo:

# Autor: Fernando Krein Pinheiro
# Data: 28/04/2012
# Linguagem: Python

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#! /usr/bin/env python

import math
a= int(raw_input("Digite a:"))
b= int(raw_input("Digite b:"))
c= int(raw_input("Digite c:"))

x=(b**2)-(4*a*c)

if x<0 :
        print ("Raiz negativa nao pode ser extraida.")
        exit()

else :
	x=math.sqrt(x)
	x1=(-b+x)/(2*a)
	x2=(-b-x)/(2*a)
print "\n\nX' = %s \nX'' = " % x1, x2

Ordenando valores de um arquivo usando Python

Oi galera… essa é uma dica rápida de como ordenar valores de um arquivo texto usando a linguagem python. Não vou me deter em explicações adicionais  pois o código é muito fácil de entender!

Esse código é útil se você tem uma enorme quantidade de dados em um arquivo e precisa ordena-los de forma crescente ou decrescente, mas para essa ultima você deveŕa fazer uma pequena alteração!

Segue o código abaixo:

# Autor: Fernando Krein Pinheiro
# Data: 28/04/2012
# Linguagem: Python

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#! /usr/bin/env python

import random, time

#Cria um dado tipo lista chamado valores
valores = []

#Tamanho da lista (linhas do arquivo)
TAM = 27

#DADOS.txt e o nome do arquivo txt, troque esse nome
#para o nome de seu arquivo antes de executar o script
arquivo = open("DADOSS.txt", "r")
i = 0

#Loop para a verificacao da quantidade de valores
while i < TAM:
	num = arquivo.readlines()

	# insere os valores na lista
	valores.append(num)
	i += 1
arquivo.close()

#pega o tempo antes da ordenacao
tempo1 = time.time()

#ordena a lista usando o metodo sort()
valores.sort()

#imprime os valores ordenados
print valores

#pega o tempo novamente apos a ordenacao
tempo2 = time.time()

#faz a diferenca entre os tempos
tempo = tempo2-tempo1

#imprime o tempo em que a funcao levou para ordenar o arquivo
print "TEmpo: %2.4f "%(tempo)

#Cria um novo arquivo para inserir os valores ordenados
arquivo = open("Ordenados_Python.txt", "w")
i = 0
while i < TAM:

	#escreve os valores no arquivo
	arquivo.write(("%s"%(valores[i])))
	i += 1

arquivo.close()
#fecha o arquivo

Agenda de contatos com Python e MySQL

Olá pessoal. Hoje vou mostrar como criar uma rápida agenda em Python usando banco de dados MySQL.

Ao final desse tutorial voce terá aprendido:

– Criar uma base de dados no MySQL.
– Criar uma tabela nessa base de dados.
– Manipular os dados dessa tabela (Inserir, Procurar, Alterar e Excluir).
– Passos basicos para conexão ao banco utilizando Python.
– Criar uma agenda de contatos.

Para esse tutorial vamos precisar ter instalado em nosso computador:

– Python
– Modulo MySQLdb
– MySQL

O modulo MySQLdb prove funcionalidades para manipulação de bases de dados MySQL através da linguagem Python.

Criando a base de dados:
Em um terminal digite: mysql -u root -p (Digite então a senha do banco de dados)
Então você terá uma tela como essa:

Agora vamos criar a base de dados que irá se chamar Agenda, para isso digite:
CREATE DATABASE Agenda;

Em seguida digite o comando: show databases; Você terá a seguinte tela:

Note que já existe algumas outras bases de dados além da criada por nós. Vamos selecionar a nossa base digitando: use Agenda;

Agora vamos criar uma tabela para nossa base. Essa tabela irá se chamar “pessoas” para isso digite:
create table pessoas(
    id int(10) unsigned not null auto_increment,
    nome varchar(60) not null,
    endereco varchar(50) not null,
    email varchar(40) not null,
    telefone varchar(15) not null,
    primary key (id));

Após termos criado a tabelas vamos visualiza-la para ver se esta tudo certo, digite então: desc pessoas;
Então teremos:

A base de dados Agenda esta pronta para ser usada! Vamos ao código Python. O código será dividido em 8 partes ou funções, são elas:

1 Principal = _main_
2 Tela do Usuario = opcaoUsuario()
3 Conexão com o Banco = funcConectaBanco()
4 Cadastrar Contato = funcCadastrar()
5 Consultar Contatos = funcConsultar()
6 Alterar Contato = funcAlterar()
7 Excluir Contato = funcExcluir()
8 Mostrar todos os Contatos do Banco = funcMostrarTodos()

1 Principal:
Inicia o programa chamando a função opçãoUsuario() que é a tela inicial do software.

# Autor: Fernando Krein Pinheiro
# Data: 08/03/2012
# Linguagem: Python

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#! /usr/bin/env python

import time
import os
import sys
import string
import MySQLdb

if __name__=='__main__':
	opcaoUsuario()

2 Tela do Usuario:
Após ter sido chamada pela função principal a função opcçaoUsuario() mostrar algumas das opções que o usuário poderá escolher. Caso escolha uma determinada opção então é chamada outra função responsável pela opção escolhida.

def opcaoUsuario():

	os.system("clear");
	print "==================================="
	print "======= Agenda de Contatos ========"
	print "==================================="
	opcao = raw_input("Escolha a opcao desejada\n\n[1] - Cadastrar\n[2] - Consultar\n[3] - Alterar\n[4] - Excluir\n[5] - Mostrar Todos\n[6] - Sair")

	try:
		opcao = int(opcao)
		if opcao<1 or opcao>6:
			os.system("clear");
			print "OPCAO INVALIDA: Verifique o valor digitado"
			time.sleep(2)
			opcaoUsuario()
	except:
		os.system("clear");
		print "OPCAO INVALIDA: Verifique o valor digitado"
		time.sleep(2)
		opcaoUsuario()

	if opcao == 1:
		conecta = conectaBanco()
		funcCadastrar(conecta)

	elif opcao == 2:
		conecta = conectaBanco()
		funcConsultar(conecta)

	elif opcao == 3:
		conecta = conectaBanco()
		funcAlterar(conecta)

	elif opcao == 4:
		conecta = conectaBanco()
		funcExcluir(conecta)

	elif opcao == 5:
		conecta = conectaBanco()
		funcMostrarTodos(conecta)

	elif opcao == 6:
		sys.exit()

3 Conexão com o Banco:
Usa o metodo MySQLdb.conect() para iniciar a conexão com o banco, seus parâmetro são: host, usuario e senha da base de dados. Ainda possui outro método select_db() que seleciona a base. Os parâmetros para esse método é o nome da base de dados, nesse caso Agenda. Faz tratamento de exceções caso necessário através de try: exception: retorna o objeto “conecta” que é repassado para as outras funções para manipulação de outros métodos.

def conectaBanco():

	HOST = "localhost"
	USER = "root"
	PASSWD = "SenhaDoseuBancodeDados"
	BANCO = "Agenda"

	try:
		conecta = MySQLdb.connect(HOST, USER, PASSWD)
		conecta.select_db(BANCO)

    	except MySQLdb.Error, e:
        	print "Erro: O banco especificado nao foi encontrado...",e
		menu = raw_input()
		os.system("clear")
		opcaoUsuario()

	return conecta

4 Cadastrar Contato:
Recebe o objeto “conecta” da função funcConectaBanco(), espera a entrada do teclado digitada pelo usuário e a converte para letras maiúsculas afim de prover um padrão de gravação na base. (Isso serve para nossa base ficar organizada não misturando caracteres maiúsculos e minúsculos). A conversão é feita pelo método string.upper(). Criamos um cursor através de conecta.cursor() para manipulação das consultas SQL. Definimos uma consulta SQL com o comando INSERt para inserir os dados lidos do teclado na base. Repassamos essa consulta para o método cursor.execute() e então usamos o método cursor.commit() para concretizar o comando SQL, tratamos possíveis erros com try: exception: e fechamos a conexão através do método close().

def funcCadastrar(conecta):

	print "\n\nDigite os dados:\n"
	name = str(raw_input("Nome: "))
	name = (name.upper())
	address = str(raw_input("Endereco: "))
	address = (address.upper())
	mail = str(raw_input("Email: "))
	mail = (mail.upper())
	fone = str(raw_input("Telefone: "))
	fone = (fone.upper())
	cursor = conecta.cursor()

	sql="INSERT INTO pessoas (nome,endereco,email,telefone) VALUES ('"+name+"','"+address+"','"+mail+"','"+fone+"')"

	try:
        	cursor.execute(sql)
		conecta.commit()

    	except MySQLdb.Error, e:
        	print "Erro: " + sql
        	print e

	print "Dados gravados com sucesso."
	conecta.close()
	menu = raw_input()
	os.system("clear")
	opcaoUsuario()

5 Consultar Contatos:
Recebe o objeto “conecta” da função funcConectaBanco(), espera a entrada do teclado digitada pelo usuário e a converte para letras maiúsculas afim de prover compatibilidade com os dados gravados na base. Criamos um cursor através de conecta.cursor() para manipulação das consultas SQL. Definimos uma consulta SQL com o comando SELECT para selecionar os dados na base. Repassamos essa consulta para o método cursor.execute(), imprimimos os dados da consulta e então usamos o método cursor.commit() para concretizar o comando SQL, tratamos possíveis erros com try: exception: e fechamos a conexão através do método close().

def funcConsultar(conecta):

	name = str(raw_input("\nDigite o Nome a Pesquisar: "))
	name = (name.upper())
	cursor = conecta.cursor()
 	sql="SELECT * FROM pessoas WHERE nome='"+name+"'"
 	resultados = 0

   	try:
        	cursor.execute(sql)
		resultado = cursor.fetchall()
		for dados in resultado:
			ide = dados[0]
            		nome = dados[1]
			endereco = dados[2]
			email = dados[3]
			telefone = dados[4]
			resultados= int(resultados)
			resultados = resultados + 1
			print"\n----------------------------\n"
			print " ID: %s\n Nome: %s\n Endereco: %s\n Email: %s\n Telefone: %s"%(ide, nome, endereco, email, telefone)
		conecta.commit()

    	except MySQLdb.Error, e:
        	print "Erro: " + sql
        	print e

	print "\n\nForam encontrados %d resultados"%resultados
	conecta.close()
	menu = raw_input()
	os.system("clear")
	opcaoUsuario()

6 Alterar Contatos:
Recebe o objeto “conecta” da função funcConectaBanco(), espera a entrada do teclado digitada pelo usuário e a converte para letras maiúsculas afim de prover compatibilidade com os dados gravados na base. Criamos um cursor através de conecta.cursor() para manipulação das consultas SQL. Definimos uma consulta SQL com o comando UPDATE para alterar os dados na base. Repassamos essa consulta para o método cursor.execute() e então usamos o método cursor.commit() para concretizar o comando SQL, tratamos possíveis erros com try: exception: e fechamos a conexão através do método close().

def funcAlterar(conecta):

	print "\n\nDigite os dados:\n"
	ide = raw_input("ID do contato a alterar: ")
	novo_nome = raw_input("Novo Nome: ")
	novo_nome = (novo_nome.upper())
	cursor = conecta.cursor()

	sql = "UPDATE pessoas SET nome='"+novo_nome+"' WHERE id='"+ide+"'"
	try:
        	cursor.execute(sql)
		conecta.commit()

    	except MySQLdb.Error, e:
        	print "Erro: " + sql
        	print e

	print "Alteracao feita com sucesso."
	conecta.close()
	menu = raw_input()
	os.system("clear")
	opcaoUsuario()

7 Excluir Contato:
Recebe o objeto “conecta” da função funcConectaBanco(), espera a entrada do teclado digitada pelo usuário e a converte para letras maiúsculas afim de prover compatibilidade com os dados gravados na base. Criamos um cursor através de conecta.cursor() para manipulação das consultas SQL. Definimos uma consulta SQL com o comando DELETE para excluir os dados na base. Repassamos essa consulta para o método cursor.execute() e então usamos o método cursor.commit() para concretizar o comando SQL, tratamos possíveis erros com try: exception: e fechamos a conexão através do método close().

def funcExcluir(conecta):

	print "\n\nDigite os dados:\n"
	ide_exclusao = raw_input("ID a Excluir: ")
	cursor = conecta.cursor()

	sql = "DELETE FROM pessoas WHERE id='"+ide_exclusao+"'"
	try:
        	cursor.execute(sql)
		conecta.commit()

    	except MySQLdb.Error, e:
        	print "Erro: " + sql
        	print e

	print "Exclusao feita com Sucesso."
	conecta.close()
	menu = raw_input()
	os.system("clear")
	opcaoUsuario()

8 Mostrar todos os Contatos do Banco:
Recebe o objeto “conecta” da função funcConectaBanco(). Criamos um cursor através de conecta.cursor() para manipulação das consultas SQL. Definimos uma consulta SQL com o comando SELECT para selecionar os dados na base. Repassamos essa consulta para o método cursor.execute(), imprimimos todos os resultados da consulta e então usamos o método cursor.commit() para concretizar o comando SQL, tratamos possíveis erros com try: exception: e fechamos a conexão através do método close().

def funcMostrarTodos(conecta):

	resultados = 0
	cursor = conecta.cursor()
 	sql="SELECT * FROM pessoas;"

   	try:
        	cursor.execute(sql)
		resultado = cursor.fetchall()

		for dados in resultado:
			ide = dados[0]
            		nome = dados[1]
			endereco = dados[2]
			email = dados[3]
			telefone = dados[4]
			resultados= int(resultados)
			resultados = resultados + 1
			print"----------------------------------"
			print " ID: %s\n Nome: %s\n Endereco: %s\n Email: %s\n Telefone: %s"%(ide, nome, endereco, email, telefone)
		conecta.commit()

    	except MySQLdb.Error, e:
        	print "Erro: " + sql
        	print e

	print "\n\nForam encontrados %d resultados"%resultados
	conecta.close()
	menu = raw_input()
	os.system("clear")
	opcaoUsuario()

Copie e cole todo o código em um mesmo arquivo. Para executar o programa digite no terminal: python Agenda.py
E pronto!! Voce verá uma tela como essa:

Agora é só testar para ver se tudo está funcionando…

Download do código, imagens e instruções SQL.

Algumas Referencias:

MySQL 5.5 Reference Manual
Documento sobre SQL e MySQL
MySQLdb user guide Python
MySQL Python Tutorial

Fazendo seu proprio Gmail Notifier

Olá pessoal. A dica que trago hoje para voces é um código muito simples que substitui o GMAIL Notifier! Sou usuario desse pequeno programa verificador de email que a poucos dias parou de funcionar devido a uma atualização do Gmail!

Estava cansado de ter que logar a todo momento em minha conta para verificar os email, por isso pensei: E porque eu não desenvolver um script que faça isso para mim? Novamente fui até o Oraculo (Google) para pedir seus conselhos. foi então que me deparei com um modulo chamado feedparser para python. Recorri a sua documentação e encontrei uns exemplos de códigos onde o pessoal usava esse modulo!

Sem pensar abri um terminal e fui logo instalando. Segue o comando abaixo para instalar

apt-get install python-feedparser

Após instalar o modulo, dei inicio a escrita do script que resultou em:

# Autor: Fernando Krein Pinheiro
# Data: 04/12/2011
# Linguagem: Python
# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#!/usr/bin/python
# -*- coding: cp1252 -*-

import feedparser
import time
import sys
###############################################################################
def verifica_email(tempo):

    Usuario="usuario@gmail.com" #Seu usuario de email
    Senha="senhadoemail*" #Sua senha do email
    URL="https://"
    ServidorMail="mail.google.com"
    Caminho="/gmail/feed/atom"

    if tempo == 0:
        qtd_emails = int(feedparser.parse(URL + Usuario + ":" + Senha + "@" +
	ServidorMail + Caminho)["feed"]["fullcount"])

	if qtd_emails > 0:
    	    print "Parabens: Voce tem" ,qtd_emails, "emails na caixa de entrada!"
        else:
    	    print "Ops: Nenhum email na caixa de entrada!"

    else:

        while True:
	    qtd_emails = int(feedparser.parse(URL + Usuario + ":" + Senha + "@" +
	    ServidorMail + Caminho)["feed"]["fullcount"])

	    if qtd_emails > 0:
                print "Parabens: Voce tem" ,qtd_emails, "emails na caixa de entrada!"
	    else:
    		print "Ops: Nenhum email na caixa de entrada!"
    		time.sleep(tempo)

################################################################################

if __name__=='__main__':

    print"==========================================="
    print"=====      Notificador do gmail       ====="
    print"==========================================="
    print"===== 1 - Verificar emails agora?     ====="
    print"===== 2 - Verificar email por tempo?  ====="
    print"===== 3 - Sair                        ====="
    print"==========================================="
    opcao = int (raw_input("Digite a Opcao: "))
    tempo = 0
    if opcao == 1:
        verifica_email(tempo)

    elif opcao == 2:
        tempo = int(raw_input("Digite o tempo de intervalo a cada verificacao (tempo em segundos)"))
        verifica_email(tempo)

    elif opcao == 3:
        sys.exit()

    else:
        print"Valor invalido"
################################################################################

O código funciona da seguinte maneira: O usuário poderá escolher entre duas opções:

1 – Verificar email agora? Essa opção verifica apenas uma vez a caixa de email e informa ao usuário se existe ou não emails.
2 – Verificar email por tempo? Essa opção necessita que o usuário informe um tempo que será o intervalo entre cada verificação da caixa de entrada. Por exemplo, caso o usuário queira que o script verifique a caixa de entrada a cada 1 minuto então ele deve informar o valor 60 (segundos) o tempo precisa ser informado em segundos. No caso de verificar a cada 2 minutos, então o usuario deverá informar 120 e assim por diante….

Para executa-lo basta digitar em um terminal: python gmail.py
(Obs: gmail.py é o nome do arquivo que contem o código fonte)

Após isso você deverá ver uma tela como essa:

Basta escolher uma opção e ser feliz……rsrsrsrsrs! Espero que isso tenha sido útil assim como foi para mim.
Download do Código Fonte o do modulo FeedParser AQUI.

Informações referentes ao modulo pode ser encontrado em:
http://www.ibm.com/developerworks/xml/library/x-tipufp/
http://wiki.python.org/moin/RssLibraries
http://pypi.python.org/pypi/feedparser

Lendo valores de um sensor de temperatura e gerando logs.

Escrevi esse código baseado no tutorial que falei sobre o modulo PySerial. O objetivo deste é ler valores de um sensor de temperatura e armazena-lo em um log que nesse caso será um arquivo texto. Essa dica é útil para quem precisa monitorar a temperatura de um ambiente onde precisam ser guardados os valores de temperatura para uma possível conferencia ou até mesmo fazer cálculos de media entre outros.

O algoritmo é muito simples e sua lógica se expressa por:

Pergunta-se ao usuário se ele quer fazer a leitura dos dados. Caso ele responda sim, o algoritmo irá pedir um tempo  que será o intervalo entre cada leitura (tempo em segundos). Esses dados são gravados em um arquivo do tipo texto juntamente com a data e a hora em que foram lidos: Veja o fluxograma:

Nesse caso o algoritmo ficará em loop infinito. O usuário poderá para-lo através de uma interrupção com o teclado digitando as teclas Ctrl + c.

# Autor: Fernando Krein Pinheiro
# Data: 09/09/2011
# Linguagem: Python

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#!/usr/bin/python
# -*- coding: cp1252 -*-

from datetime import datetime
import serial
import time

#Define a porta e o baudrate usado
#No Windows a porta e alguma das COMs
porta = '/dev/ttyUSB0'
baud_rate = 9600

opcao = raw_input("Verificar Temperatura? s / n")

if opcao == 's':

    #Tempo de intervalo entre cada leitura
    tempo = int (raw_input("Informe o intervalo entre cada leitura: "))

    #Cria o objeto_porta, limpa o buffer da serial,
    objeto_porta = serial.Serial(porta, baud_rate)
    objeto_porta.flushInput();

    #Abre o arquivo para escrever os dados
    arquivo = open("LOG.txt", "a+")

    #Fica em LOOP Infinito, para sair pressione
    #Ctrl + c
    while True:

        #Cria o objeto_hoje, pega os valores de
        #dia, mes, ano e horario, converte para string
        objeto_hoje = datetime.today()
        dia = str(objeto_hoje.day)
        mes = str(objeto_hoje.month)
        ano = str(objeto_hoje.year)
        horario = str(objeto_hoje.strftime("%X"))

        # Le os valores passados pelo arduino
        temperatura = objeto_porta.readline()

        #Escreve os dados de HORA, DATA e TEMPERATURA no arquivo
        arquivo.write("Leitura de sensor de temperatura\n")
        arquivo.write("DATA: ")
        arquivo.write(dia)
        arquivo.write(" / ")
        arquivo.write(mes)
        arquivo.write(" / ")
        arquivo.write(ano)
        arquivo.write("\n")
        arquivo.write("HORA: ")
        arquivo.write(horario)
        arquivo.write("\nTEMPERATURA: ")
        arquivo.write(temperatura)
        arquivo.write("\n-------------------------------\n")

        # Imprime os dados na tela (Terminal)
        print "DATA :",  dia , "/" , mes , "/" , ano , "/"
        print "HORA : ", horario
        print "TEMPERATURA :", temperatura

        #Faz uma pausa de X (tempo informado) segundos para fazer o loop novamente
        time.sleep(tempo)

    #Fecha o arquivo e a porta serial
    arquivo.close()
    objeto_porta.close()

else:

        print "Saindo..."

Você pode usar esse código juntamente com o Arduino ou qualquer outra placa que esteja conectada pela porta serial e que envie os dados do sensor para a mesma. Repare que este código não irá funcionar se você executa-lo sem ter algum dispositivo conectado na serial.

Você pode unir esse algoritmo com o projeto que está AQUI, assim será possível ver como ele funciona!!! Para fazer isso monte o projeto inicie a leitura dos dados pelo Arduino e executo algoritmo.

Até a próxima…

Usando Python para comunicar com a Porta Serial.

E aí galera. Tava meio pobre a categoria sobre python então resolvi trazer uma dica que vale por três (ou não, rsrsr). Hoje vou demonstrar como utilizar a linguagem Python para comunicar com a porta serial. Já é sabido de todos que python é uma das linguagens de mais fácil utilização e que prove alto nível, logo o que será mostrado abaixo poderá ser entendido por todos aqueles que conheçam alguma linguagem de programação e sua lógica.

Existe um modulo rico em documentação, chamado PySerial escrito para ser usada na comunicação de programas python com dispositivos que usam portas seriais. Haaaa mas então posso utilizar isso para comunicar com o Arduino??? Sim, você pode. E tem mais, vou fazer um tutorial especialmente para demonstrar isso.

Para ver a documentação sobre o modulo CLIQUE AQUI.

Bem, vamos ao que interessa. Primeiramente precisamos instala-lo, acesse um terminal e digite:  apt-get install python-serial
Se tudo ocorrer bem deverá ser instalado. Vamos ver os métodos básicos para manipulação das portas:

Antes de mais nada devemos dar um import serial para podermos usar os métodos básicos como open(), write(), read() e close(). Logo após devemos criar um objeto para manipularmos os métodos. No exemplo acima o objeto é chamado de ser. O objeto ser é criado e recebe o retorno de serial.Serial() nesse método devemos passar os argumento como: nome da porta e baudrate etc… Podemos usar ainda o método portstr para listar as portas existentes na maquina e as que realmente estão sendo usadas. Para escrevermos algo na porta usamos o método write(), mas lembre-se de que ele deve ser acessado pelo objeto ser. Nesse caso foi escrita a string “hello”. E finalmente precisamos fechar a porta com o método close().

Essa figura demonstra melhor a passagem de parâmetros para o método serial.Serial(). Repare que o método read() foi usado e o retorno deste foi armazenado em uma variável de nome x. Esse método le apenas 1 byte da porta. Para podermos ler linhas usamos o metodo readline(). Na figura acima o método foi usado e o retorno foi armazenado em uma variável chamada line. E então novamente a porta foi fechada.

Agora que já sabemos um pouco sobre os métodos básicos, vejamos um exemplo em código: Obs (O código foi testado no Linux).

# Autor: Fernando Krein Pinheiro
# Data: 07/09/2011
# Linguagem: Python

# ========= IMPORTANTE ===========
# O codigo esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.

#! /usr/bin/env python

import serial
porta = '/dev/ttyUSB0'
baud_rate = 9600

###################### FUNCAO PARA VERIFICAR PORTAS ATIVAS ###############
def verifica_portas():

    portas_ativas = []
    for numero in range(10):

        try:
            objeto_verifica = serial.Serial(numero)
            portas_ativas.append((numero, objeto_verifica.portstr))
            objeto_verifica.close()

        except serial.SerialException:
            pass
    return portas_ativas

################    FUNCAO PARA ESCREVER NA PORTA ####################
def escrever_porta():

   try:

       valor = (raw_input("Digite o valor a ser enviado: "))
       Obj_porta = serial.Serial(porta, baud_rate)
       Obj_porta.write(valor)
       Obj_porta.close()

   except serial.SerialException:
       print"ERRO: Verifique se ha algum dispositivo conectado na porta!"

   return valor

########################## FUNCAO PARA LER A PORTA #######################
def ler_porta():

   try:

       Obj_porta = serial.Serial(porta, baud_rate)
       valor = Obj_porta.read()
       print"Valor lido da Serial: ",valor
       Obj_porta.close()

   except serial.SerialException:
       print"ERRO: Verifique se ha algum dispositivo conectado na porta!"

################################ MAIN ####################################
if __name__=='__main__':

    print"==========================================="
    print"===== 1 - Verificar Portas Existentes ====="
    print"===== 2 - Ler Valor da Porta Serial   ====="
    print"===== 3 - Escrever Valor na Porta Serial =="
    print"==========================================="
    opcao = int (raw_input("Digite a Opcao: "))

    if opcao == 1:
        print"Numero da porta | Nome da Porta"
        for numero,portas_ativas in verifica_portas():
            print"      %d         |    %s" % (numero,portas_ativas)

    elif opcao == 2:
        ler_porta()

    elif opcao == 3:
        escrever_porta()

    else:
       print"Entrada Invalida!!"

O código funciona da seguinte maneira:
Possui uma função chamada de verifica_portas() a qual usa o método portstr() para listar as portas da maquina. Uma outra função chamada ler_porta() que usa o método read() para ler os dados, lembre-se esse método le apenas 1 byte. E outra função chamada escrever_porta que faz o uso do método write() para enviarmos um valor inteiro digitado pelo usuário.

Então temos uma main() onde são chamadas essas funções. Simples não?!!

Bem é isso aí, qualquer coisa é só perguntar ou seguir a documentação da PySerial!!!

Porque Python?

Primeiramente quero dizer que o título foi inspirado em uma palestra ocorrida no FISL 9 a qual eu tive oportunidade de ir, também foi minha primeira edição do evento e a que mais me inspirou para seguir no caminho de software livre. Bom, mas esse post era para ser sobre Python, não???. Sim, então vamos lá!!

Qual a origem para o nome Python?
Seu nome foi inspirado em um grupo de humoristas ingleses chamado Monty Python.

Mas o que realmente é Python?
Uma cobra??. Não, não é uma cobra, embora muitas pessoas façam associação com o réptil o “Python em questão é uma linguagem de programação”. Essa rima foi mera coincidência.

Um pouco de sua História.
Python foi criada no final de 1989 por Guido Van Rossum, é uma linguagem sucessora da linguagem ABC que tinha como umas das funções tratar exceções e prover interface com o Sistemas Operacional Amoeba. Em 1991, Guido Van Rossum publicou o código nomeado de versão 0.9.0 em um grupo de discussão para que fosse avaliada e comentada.

Características da Linguagem
– Linguagem orientada a objetos com suporte aos paradigmas estrutural e funcional, ou seja tem para todos os gostos.
– Sua sintaxe é simples e fácil de ser assimilada.
– Tipagem forte e dinâmica.
– Multiplataforma.
– Interpretada: é compilada para bytecode e então interpretada.
– Licença de código aberto, compatível com a GLP.

Como é uma linha de código Python?
Como de costume, para se apresentar uma linguagem vamos fazer o bom e velho “Olá mundo!”.

# Olá Mundo!
print ("Olá Mundo!");

Algumas linhas de código.

# Fatorial
n = int(raw_input("Digite um numero: "))
resultado = 1
lista = range(1,n+1)
for x in lista:
   resultado = x * resultado
   print "%s! = %s" % (n, resultado)

Agora programadores C/C++, Java e afins estão se perguntando:
Ta mas e onde esta o início e o fim do bloco ou ainda onde está as {} que determinam onde o bloco começa e termina?

Em python isso ja era, quem determina inicio e fim de bloco ou de estruturas do tipo “for, while, if entre outras” é a mais pura indentação do código. Isso mesmo a indentação do código. “Mas eu nunca fiz isso nos meus códigos, apenas abria e fechava as chaves quando necessário!”. Então acostume-se no Python funciona dessa maneira. Mas e se eu não fizer dessa maneira? Muito provável que seu interpretador irá acusar erro.

Algumas das bibliotecas que Python oferece:
– Persistência de Objetos
– Banco de Dados
– Geração de Gráficos
– Protocolo de Redes
– Web
– Criptografia
– E muitas outras…

Quem usa Python?
– Google
– NASA
– YouTube
– Industrial Light and Magic (ILM)
– DreamWorks
– E muitas outras empresas

Qnde posso aplicar Python?
Python oferece diversas funcionalidades que podem ser aplicadas em:

– Sites e aplicativos para web. Existem muitos frameworks que podem ser usados para diversos aplicações.
– Softwares de Gestão. Python é a linguagem ideal para ser usada neste tipo de desenvolvimento porque é moderna, provê acesso a uma ampla variedade de frameworks e bibliotecas que agilizam muito o desenvolvimento.
– Python é tão versátil que permite o desenvolvimento de aplicações para os mais diversos tipos de arquiteturas. Atualmente Python pode ser usada desde os grandes mainframes até os menores celulares.
– Aplicações multimídia e entretenimento (entre eles o de desenvolvimento de jogos).

Python é amigavel e conversa com outras linguagens.
Ja pensou você poder escrever um código em C ou Java e incrementa-lo com alguma outra linguagem? Com Python isso é possível. No próximo post vou demonstrar alguns exemplos de como pode ser feito isso.

Existe emprego para os programadores Python?
Sim existe e muito, e a procura por programadores Python só aumenta.

Essa foi uma breve introdução a linguagem e seu potencial. No próximo post mostrarei alguns códigos comentados e explicados passo a passo.

Um ótimo livro sobre a linguagem: Download

Referencias.
Porque Python? Apresentação da Palestra, FISL 9.
Python, porque não usei isso antes.
Pyscience Brasil
Python Brasil Impressione -se