Robo controlado atráves de rede wireless

E aí pessoal!

Entrei em férias da faculdade, hoje (até que enfim…) conclui todas as 7 matérias com êxito e agora estou livre de aulas por pelo menos umas duas semanas! E para comemorar as férias resolvi fazer esse tutorial para mostrar o meu mais novo projeto (mini-projeto), um robô controlado por rede wireless. Esse robô utiliza o arduino e um shield xbee para fazer a comunicação com o meu computador.

O funcionamento básico é:

O shield Xbee prove uma comunicação utilizando protocolo ZigBee especificado pela IEEE 802.15.4, esse é um padrão que especifica a camada física e efetua o controle de acesso para redes sem fio pessoais de baixas taxas de transmissão, geralmente WPANs.

O objetivo do tutorial não é mostrar como configurar uma comunicação entre o arduino e o shield xbee pois está é uma tarefa simples e existem vários tutoriais na internet de como fazer isso. Para maiores informações a respeito do assunto acesse a página oficial do arduino que fala sobre isso. LINK AQUI.

Bem o código é muito simples e fácil, veja:

/*
# Autor: Fernando Krein Pinheiro
# Data: 07/07/2012
# Linguagem: C/C++

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

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

O robo pode ser controlado pelas teclas
w,a,d,s.

       W

       ^
       |
A  <--- ---> D
       |
       v

       S
*/

#include <Servo.h>
#include <SoftwareSerial.h>

Servo motorDireita, motorEsquerda;
SoftwareSerial mySerial(2, 3);
char comando;

void setup()
{
  iniciar_Motor();
  Serial.begin(9600);
  mySerial.begin(9600);
}
void loop()
{
	if (mySerial.available())
        {
             comando = mySerial.read();
             Serial.print(comando);
             if(comando == 'a')
             {
                  rotacao_Esquerda();
             }
             else
             if(comando == 'd')
             {
                  rotacao_Direita();
             }
             else
             if(comando == 'w')
             {
                  rotacao_Frente();
             }
             else
             if(comando == 's')
	     {
                  rotacao_Re();
             }

        }
	else
            rotacao_Parado();
}

void rotacao_Parado()
{
   motorDireita.detach();
   motorEsquerda.detach();
}

void rotacao_Re()
{
   iniciar_Motor();
   motorDireita.write(0);
   motorEsquerda.write(180);
   delay(600);
   rotacao_Parado();
}

void rotacao_Frente()
{
   iniciar_Motor();
   motorDireita.write(180);
   motorEsquerda.write(0);
   delay(600);
   rotacao_Parado();
}

void rotacao_Direita()
{
   iniciar_Motor();
   motorDireita.write(180);
   motorEsquerda.write(180);
   delay(250);
   rotacao_Parado();
}
void rotacao_Esquerda()
{
   iniciar_Motor();
   motorDireita.write(0);
   motorEsquerda.write(0);
   delay(250);
   rotacao_Parado();
}

void iniciar_Motor()
{
   motorDireita.attach(10);
   motorEsquerda.attach(11);
}

Veja agora o resultado final.

Vídeo:

por ferpinheiro Postado em Arduino

Cliente – Servidor em C utilizando threads

Estou disponibilizando os fontes de um pequeno programa de cliente servidor implementado em C. Esse código utiliza threads na parte do servidor podendo controlar mais de um cliente.

Código Cliente. Para compilar utilize: gcc -lpthread -o cliente  cliente.c

/*********************************
Autor: Fernando Krein Pinheiro
Data: 04/07/2012
Linguagem: C
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
*/
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <ctype.h>
#include <string.h>

int configuracaoCliente()
{
    /*Descritor do cliente*/
    int clienteSockfd;
    /*Estrutura do Cliente*/
    struct sockaddr_in serv_addr;
    /*Tamanho da estrutura*/
    socklen_t addrlen = sizeof (serv_addr);

    /*Socket familia TCP declarado SOCK_STREAM e criado*/
    clienteSockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (clienteSockfd < 0)
	{
	    printf("Erro no Socket\n");
		exit(1);
	}
    /*Zera a estrutura*/
    bzero((char *) & serv_addr, sizeof (serv_addr));
    /*Seta a familia*/
    serv_addr.sin_family = AF_INET;
    /*Define o IP nesse caso o localhost*/
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    /*Define a porta de conexao*/
    serv_addr.sin_port = htons(6881);
   /*Faz a conexao com o servidor*/
   if(connect(clienteSockfd,(struct sockaddr *)&serv_addr, addrlen) < 0)
     {
        	printf("Erro no Socket\n");
		exit(1);
	}
        return clienteSockfd;
}

void Cliente(int clienteSockfd)
{
  /*Buffer de dados a ser mandado para o servidor*/
  char buffer_para_servidor[256];
  printf("Digite uma mensagem para o servidor: ");
   do {

        scanf("%s",buffer_para_servidor);
        fflush(stdin);
        /*Escreve para o servidor*/

        write(clienteSockfd, buffer_para_servidor, sizeof (buffer_para_servidor));

      /*Mensagem para sair*/
    } while (strcmp(buffer_para_servidor, "sair") != 0);
    /**Encerra o descritor*/
    close(clienteSockfd);
}

int main()
{
    system("clear");
    /*Estrutura cliente*/
    struct sockaddr_in serv_addr;
    /*Tamanho da estrutura*/
    socklen_t addrlen = sizeof (serv_addr);
    /*Define o descritor cliente*/
    int descritorCliente;
    descritorCliente = configuracaoCliente();
    /*chama funcao do cliente passando o descritor*/
    Cliente(descritorCliente);
    exit(0);
}

Código Servidor. Para compilador utilize: gcc -lpthread -o servidor  servidor.c

/*********************************
Autor: Fernando Krein Pinheiro
Data: 04/07/2012
Linguagem: C
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <pthread.h>

void* Servidor(void* arg)
{
    /*Buffer de entrada (armazena buffer do cliente)*/
    char buffer_do_cliente[256];
    /*Cast do ponteiro*/
    int sockEntrada = *(int *) arg;
    /*Loop "infinito"*/
    printf("Aguardando as mensagens... ");
    for (;;)
    {
        /*Le o que vem do cliente*/
        read(sockEntrada, buffer_do_cliente, sizeof (buffer_do_cliente));
        if (strcmp(buffer_do_cliente, "sair") != 0)
        {
            /*Se buffer == sair cai fora*/
            printf("%s\n",buffer_do_cliente);
        }
        else
             {
                 /*Encerra o descritor*/
                 close(sockEntrada);
                 /*Encerra a thread*/
                 pthread_exit((void*) 0);
             }
    }
}

int configuracaoServidor()
{
    /*Cria o descritor*/
    int sockfd;
    /*Declaracao da estrutura*/
    struct sockaddr_in serverAddr;
    /*Cria o socket*/
    if ((sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
	{
	  printf("Erro no Socket\n");
	  exit(1);
	}
    /*Zera a estrutura*/
    memset(&serverAddr, 0, sizeof (serverAddr));
    /*Seta a familia*/
    serverAddr.sin_family = AF_INET;
    /*Seta os IPS (A constante INADDR_ANY e todos os ips ou qualquer ip) htonl -> conversao*/
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    /*Define a porta*/
    serverAddr.sin_port = htons(6881);
    /*Faz a bindagem (cola, gruda, conecta seja o que for)*/
    if (bind(sockfd, (struct sockaddr *) & serverAddr, sizeof (serverAddr)) < 0)
    {
	  printf("Erro no Socket\n");
	  exit(1);
     }
    /*Fica na escuta de ate 5 clientes*/
    if (listen(sockfd, 5) < 0)
    {
	  printf("Erro no Socket\n");
	  exit(1);
    }
    return sockfd;
}

int main()
{
    system("clear");
    /*Declaracao da estrutura*/
    struct sockaddr_in serverAddr;
    /*Retorna da funcao e o descritor*/
    int sockfd = configuracaoServidor();

    /*Loop "infinito"*/
    while (1)
    {
    	int clienteSockfd;
    	struct sockaddr_in clienteAddr;
        /*tamanho da estrutura*/
    	unsigned int clntLen;
        clntLen = sizeof (clienteAddr);
        /*declara uma thread*/
	pthread_t thread;
	/*Fica no aguardo da conexao do cliente*/
        if ((clienteSockfd = accept(sockfd, (struct sockaddr *) & clienteAddr, &clntLen)) < 0)
        {
	  printf("Erro no Socket\n");
	  exit(1);
	}
        /*Inicializa a thread*/
        if (pthread_create(&thread, NULL, Servidor, &clienteSockfd) != 0)
       {
            printf("Erro na Thread\n");
            exit(1);
       }

        pthread_detach(thread);
    }
    exit(0);
}
por ferpinheiro Postado em C/C++

Automação residencial com Arduino – Parte I

E aí pessoal…

Vocês já pensaram em algum dia poder controlar a casa de vocês através da internet? Sim ou Não. Pois bem isso não é coisa do futuro, já existem diversos projetos de casas e ambientes que podem ser controlados dessa forma, porem, para se ter uma casa assim é preciso desembolsar alguma centenas de reais para ter todo o conforto e comodidade que essa tecnologia pode lhe proporcionar.

Na verdade, você teria que desembolsar se não existisse a plataforma arduino, pois com ela você pode ter um ambiente como esse citado acima, usando apenas a criatividade e algumas linhas de código.

Estou desenvolvendo um ambiente assim na minha casa, para aprendizagem e testes com a plataforma. O sistema é baseado utilizando linguagem C, PHP, e Python, através dele eu consigo ligar e desligar lampadas, monitorar a temperatura ambiente e outras funções ainda não implementadas.

Veja o vídeo que gravei e confira o resultado:
Para uma melhor visualização, use o modo tela cheia…

Simples não?!!

Com o projeto concluído será possível controlar a casa de qualquer aparelho que possua um browser e conexão com a internet. Continuem acompanhando o blog!

Até mais….

Utilizando Arduino para criação de Tecnologias Assistivas – Parte II

Continuando o projeto da nossa tecnologia assistiva para deficientes visuais, resolvi acoplar o prototipo em um boné para fazer alguns teste, também tive que fazer algumas modificações no código, principalmente na leitura do sensor ultrasonico, essa modificação teve que ser feita para melhorar a leitura e o tempo de resposta do sensor ultrasonico e consequentemente para o acionamento do motor de vibração.

Código:

/*********************************
Autor: Fernando Krein Pinheiro
Data: 23/05/2012
Linguagem: C (Wiring)
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
********************************/

#include <Ultrasonic.h>
#define echoPin 13
#define triggerPin 12

Ultrasonic ultrasonic(12,13);
int motorPino =  9;

void setup()
{

  Serial.begin(9600);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
  digitalWrite(motorPino, LOW);
}

void loop() {

  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  long tempo = pulseIn(echoPin, HIGH);

  //trunca o valor e faz com que seja um inteiro
  int distancia = calculoDistancia(tempo);

  if(distancia < 100)
  {
    digitalWrite(motorPino, HIGH);
  }
  else
   digitalWrite(motorPino, LOW);
   delay(100);
}

float calculoDistancia(long tempo){

  float segundos = (float) tempo / 1000000.0;
  float distancia = segundos * 340;
  distancia = distancia / 2;
  distancia = distancia * 100;
  return distancia;
}

Imagens do Prototipo:

Vídeo demonstrativo:

Repare que no eixo do motor existe uma pequena placa de cor vermelha e azul. Colei essa placa no eixo penas para uma melhor visualização, pois em alguns casos não era possível ver através do vídeo o acionamento do motor. A distancia mínima para o acionamento do motor no vídeo é de 30 centímetros.

As distancias utilizadas para testes foram:

2 metros.
1 metro.
50 centímetros.
30 centímetros.
20 centímetros.

Embora tenha sido curto o período de testes o prototipo mostrou-se bastante eficiente na leitura de todas as distancia e em momento algum houve erros de leitura pelo sensor ou de funcionamento do motor de vibração.

Conclusões sobre o trabalho:

A criação desse prototipo deve servir como um incentivo para a criação de tecnologias que auxiliem pessoas portadoras de necessidades especiais. O prototipo em questão não substitui de forma alguma as bengalas brancas usadas pelas pessoas com deficiência visual, pois os obstáculos como, degraus e muros com alturas inferiores a faixa da cintura de uma pessoa não são detectados por esse prototipo.

O uso de um motor de vibração menor é aconselhável, pois o que foi usado no projeto, além de ser grande e com uma estética ruim, ficará difícil de ser acoplado em uma placa. Aconselho então o uso de um motor de vibração menor que pode ser o mesmo encontrado em celulares.

O prototipo poderá ser construido utilizando dois sensores de ultrasom, um na altura da cabeça acoplado em um boné e outro em um cinto, pois assim poderá ser detectado obstáculos menores que a faixa da cintura de um individuo.

por ferpinheiro Postado em Arduino

Utilizando Arduino para criação de Tecnologias Assistivas – Parte I

“Tecnologia Assistiva é uma área do conhecimento, de característica interdisciplinar, que engloba produtos, recursos, metodologias, estratégias, práticas e serviços que objetivam promover a funcionalidade, relacionada à atividade e participação de pessoas com deficiência, incapacidades ou mobilidade reduzida, visando sua autonomia, independência, qualidade de vida e inclusão social” (ATA VII – Comitê de Ajudas Técnicas – CAT). Fonte. http://www.assistiva.com.br/

Agora que você já sabe o que é uma tecnologia assistiva, vamos ao projeto.

O objetivo desse tutorial é demonstrar como fazer o uso do Arduino para criação de um prototipo de tecnologia assistiva para auxilio a deficientes visuais.

O projeto consiste em monitorar a distancia de um obstáculo e avisar ao deficiente visual o quão próximo ele está do mesmo. Para isso utilizarei um motor de vibração e um sensor ultrasonico

O principio básico de funcionamento será: O deficiente visual utilizara o o prototipo junto a seu corpo, que poderá ser fixado tanto em forma de capacete, luva, ou cinto. Quando o usuário do protótipo estiver a uma distancia X de um obstáculo o motor de vibração será acionado indicando proximidade de algo.

Componentes utilizados para a criação do prototipo:

1 Arduino.
1 Motor de Vibração (Pode ser encontrado em controles de vídeo game ou celulares).
1 Diodo IN 4004.
1 Transistor TIP 122.
1 Resistor 2.2k ou equivalente.
1 Sensor Ultrasonico.

O motor de vibração retirei de um controle remoto de um vídeo game XBOX 360 que estava danificado, os demais componentes como diodo, resistor, e transistor retirei de uma lanterna e de uma fonte de computador. Algumas fotos da bagunça toda:

Esquema de montagem na protoboard:

Código fonte:

/*
# Autor: Fernando Krein Pinheiro
# Data: 20/05/2012
# Linguagem: C/C++

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

#include <Ultrasonic.h>
#define echoPin 13
#define trigPin 12

Ultrasonic ultrasonic(12,13);
int ledPin =  9;

void setup()
{
  Serial.begin(9600);
  pinMode(echoPin, INPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(ledPin, OUTPUT);

}
void loop()
{
   digitalWrite(ledPin, LOW);
   int valor = func_distancia_ultrasonico();
    if(valor <=15)
    {
        digitalWrite(ledPin, HIGH);
        delay(100);
    }
  delay(500);
}
int func_distancia_ultrasonico()
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);

  digitalWrite(trigPin, LOW);
  int distancia = (ultrasonic.Ranging(CM));
  Serial.print("Distancia em CM: ");
  Serial.println(distancia);
  return distancia;
}

O vídeo abaixo demonstra o prototipo usando o sensor para medir a distancia. Caso a distancia seja menor ou igual a 15 CM (centímetros) o motor de vibração fica ativo indicando obstáculo a frente.

Repare como o motor vibra aos 1:10 minutos/segundos de vídeo quando removo a fita que segura o mesmo na bancada.

Esse é um exemplo prático de como irá funcionar o prototipo

Aguarde a parte II do tutorial que será para a montagem e testes...

por ferpinheiro Postado em Arduino

Controlando Motores DC com Arduino

Hoje vou demonstrar um protejo rápido e fácil de como controlar um motor DC utilizando arduino. Motores DC são motores que funcionam com corrente elétrica continua e são utilizados nas mais diversas áreas. Para controlar um motor desse tipo precisamos de uma corrente maior do que o Arduino pode fornecer, para conseguir amplificar a corrente vou utilizar um transistor TIP 122. Tambem usarei um diodo que servirá como proteção para a placa do Arduino, pois quando carregamos eletricamente o motor, uma parte dessa carga poderá voltar para o pino de controle e danifica-lo.

Vamos aos componentes:

1 Arduino.
1 Motor DC 5v.
1 Transistor TIP 122 (Pode ser TIP 120).
1 Resistor 2.2k (ou algum outro equivalente).
1 Diodo IN4004. (Ou IN4007).
Alguns Jumpers.

A alimentação do motor poderá ser feita através de fonte externa (pilhas ou bateria) que é o recomendável, ou pela própria placa Arduino no pino 5v. Alimenta-lo pela própria placa não é uma boa prática, mas quando não se tem outra alternativa, poderá ser feito dessa maneira.

Veja a ligação dos componentes:

Código para o funcionamento:

Repare que esse é o mesmo código que vem como exemplo na IDE do arduino com pequenas modificações. (Código Blink). Utilizei esse código apenas como demonstração pratica, você poderá altera-lo da forma que quiser.

int MotorPin =  9;

void setup()
{
  pinMode(MotorPin, OUTPUT);
}

void loop()
{
  digitalWrite(MotorPin, HIGH);
  delay(1000);
  digitalWrite(MotorPin, LOW);
  delay(1000);
}

Vídeo:

É isso então, até a próxima...

Bloqueando sites com IPtables

Esse tutorial foi feito por dois colegas de trabalho que encontravam alguns problemas em bloquear o site de relacionamento Facebook em sua rede wirelless. Após alguns dias de estudo e quebra cabeças eles conseguiram resolver o problema e me enviaram a dica que segue abaixo:

Tutorial criado por: Jocemar Luis Wammes com participação de Vitor Hugo de Souza.

Imagem simulando a rede:

Bloqueando Facebook por HTTPS (porta 443).

Como todo o administrador de rede sabe, o bloqueio de alguns sites é regra, até mesmo para o bom andamento do trabalho. Se for o caso de uma empresa ou a sobrecarga que as redes sociais como o facebook podem trazer quando nós nos referimos a uma instituição de ensino que é o nosso caso. Para começar vou descrever a situação que a gente enfrentava até poucos dias atrás.

Temos em nosso servidor de REDE o OS Suse , ótimo sistema operacional, e para controlar o bloqueio de sites optamos por instalar o Squid, até ai tudo bem não fizemos nada mais que redirecionar a porta 80 e a 8080 para a 3128(porta do Proxy), criamos também uma lista de sites de bloqueio que o squid analisa antes de rotear e duas ACLs dentro do Squid para liberar alguns IPs que poderiam acessar qualquer site. De um tempo para cá percebemos que o Facebook não obedecia a essa restrição simplesmente passava nosso Proxy (que é transparente), podemos observar então que a rede social passou a usar criptografia o HTTPS que sai pela porta 443, tentamos bloquear a porta 443, porém voltamos atrás devido ao pessoal que necessitava acessar sites de banco, começamos a buscar conteúdos e tutoriais até que encontramos algo que nos deu uma luz, então fizemos o seguinte.

1- Como nossa rede é separada fisicamente (diferentes placas de rede), a idéia é bloquear somente as redes wireless distribuídas para os alunos, optamos por bloquear pelo IPTABLES começamos com uma linha de comando mesmo, no SHELL:

Após isso desse mesmo computador que recebeu esse ip pingamos para esse servidor do Facebook e observamos que os pacotes não chegavam, tínhamos conseguido fazer a restrição, então apenas melhoramos a idéia.

2- Criamos um arquivo dentro de /etc/init.d chamado face, que nada mais é do que uma lista de servidores do facebook que estamos negando, a lista ficou gigantesca pois o facebook parece ter mais servidores do que habitantes na terra(hahaha). A lista ficou assim:

A regra toda:

*OBS: Por vezes percebemos que não bastava apenas dar um REJECT mas sim DROP para um mesmo IP,o memso aconteceu com o FORWARD
por vezes ele não bastava então aplicávamos INPUT E OUTPUT. Essa lista necessita ser atualizada frequentemente, pois com toda a certeza a facebook irá adquirir mais servidores.

3- Faça o arquivo se tornar um executável através do comando chmod +x nome_do_arquivo. Então no SHELL vá em /etc/init.d e digite o comando para reiniciar o arquivo ./nome_do_arquivo restart

4- Faça o arquivo iniciar junto com o SO quando for reiniciado através do comando. chkconfig nome_do_arquivo

5- Por final crie uma associação desse arquivo com o seu Firewall para que quando você reinicia-lo ele reiniciar junto.

Para restringir outros acessos como o twitter, Orkut é só implementar a lista com os determinados ips dos servidores dessas redes sociais ou qualquer outro site que você quiser bloquear. Se você quiser bloquear para toda a rede sem especificar faixa de rede é só fazer o seguinte:

Iptables -A OUTPUT -d 66.220.149.11 -j REJECT
Iptables -A INPUT -d 66.220.149.11 -j DROP

Bom é isso ai! Espero que esse tutorial ajude a todos que passam pela mesma situação que nós enfrentamos.

Para entrar em contato com o autor utilizem o email abaixo:

jocemarwammes[arroba]hotmail[ponto]com

por ferpinheiro Postado em Redes

Arduino em rede usando sockets

E aí galera! Passado o tempo de provas na faculdade e com algum tempo livre, resolvi criar um tutorial demonstrando como interligar o arduino a uma rede interna e poder controla-lo de qualquer computador interligado a essa rede.

Basicamente a implementação desse projeto consiste em um servidor onde o arduino será conectado e um cliente que através da conexão com o servidor poderá controlar o arduino remotamente. Veja a figura abaixo:

Essa figura representa o funcionamento básico do projeto. Como vocês podem ter vistos o tipo de datagrama usado será o TCP por prover uma conexão segura e confiável através do Three Way Handshake, para quem ainda não sabe como funciona uma conexão usando TCP aí vai uma rápida explicação: Na conexão TCP o cliente requisita uma conexão usando uma flag SYN (Synchronization) ativa, indicando um inicio de conexão. Então o servidor irá responder para o cliente com a mesma flag SYN ativa e também uma flag ACK (Acknowledgement) de reconhecimento, logo após isso o cliente responde ao servidor novamente com a flag ACK e então é feito um “aperto de mão em três vias” e assim é selada a comunicação entre os dois. Apartir daí a troca de dados é iniciada. a figura abaixo ilustra a explicação:

Bem, chega de teoria e vamos ao que interessa. A nossa implementação do cliente e servidor será através da linguagem Python, pois prove de forma simples uma conexão usando sockets.

Código do Servidor:

# ********************************************
# Autor: Fernando Krein Pinheiro
# Data: 12/05/2012
# Linguagem: Python
# ========= IMPORTANTE ===========
# O código esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
#
# Código fonte baseado nos originais
# de Marcio Minicz encontrado em:
# http://www.python.org.br/wiki/SocketBasico
#
#********************************************

import socket
import thread
import os
import serial

HOST = ''
PORTA = 7000
PORTA_SERIAL = '/dev/ttyUSB1'
BAUD_RATE = 9600

conSerial = serial.Serial(PORTA_SERIAL, BAUD_RATE)
os.system("clear")

def conecta(conexao, cliente):

    print "IP conectado | Porta",   cliente

    while True:
        dados = conexao.recv(1024)
        if not dados: break
        print "Cliente para Arduino: ", dados
        conSerial.write(dados)
        mensagem = conSerial.readline()
	print "Arduino Diz: ", mensagem

    print 'Cliente encerrou conexao', cliente
    print "Terminando..."
    conSerial.close()
    conexao.close()
    thread.exit()
    sys.exit()

tcpSOCKET = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conexaoORIGEM = (HOST, PORTA)
tcpSOCKET.bind(conexaoORIGEM)
tcpSOCKET.listen(1)

while True:

    conexao, cliente = tcpSOCKET.accept()
    thread.start_new_thread(conecta, tuple([conexao, cliente]))

tcpSOCKET.close()

Código do Cliente:

# ********************************************
# Autor: Fernando Krein Pinheiro
# Data: 12/05/2012
# Linguagem: Python
# ========= IMPORTANTE ===========
# O código esta livre para usar,
# citar e compartilhar desde que
# mantida sua fonte e seu autor.
# Obrigado.
#
# Código fonte baseado nos originais
# de Marcio Minicz encontrado em:
# http://www.python.org.br/wiki/SocketBasico
#
#********************************************

import socket
import os
import serial

HOST = '127.0.0.1'
PORTA = 7000

tcpSOCKET = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
destinoCONEXAO = (HOST, PORTA)
tcpSOCKET.connect(destinoCONEXAO)

os.system("clear")
print "|====================================|"
print "|    Arduino na rede usando Python   |"
print "|====================================|"
print "| Digite SAIR para teminar a conexao |"

dados = raw_input()

while dados != 'SAIR':
    tcpSOCKET.send (dados)
    dados = raw_input()
tcpSOCKET.close()

Código Arduino:

/*********************************
Autor: Fernando Krein Pinheiro
Data: 12/05/2012
Linguagem: C (Wiring)
========= IMPORTANTE ===========
O código esta livre para usar,
citar e compartilhar desde que
mantida sua fonte e seu autor.
Obrigado.
*********************************
*/
void setup()
{
  Serial.begin(9600);
}

void loop()
{
    char dados;
     if (Serial.available() > 0)
     {
       dados = Serial.read();
       mensagem();
     }

}

void mensagem()
{
    Serial.println("Recebi seus dados Cliente");
}

Vídeo de demonstração:

Referencias:

http://olinux.uol.com.br/artigos/370/1.html

http://docs.python.org/library/socket.html

http://docs.python.org/howto/sockets.html

http://www.python.org.br/wiki/SocketBasico

por ferpinheiro Postado em Arduino

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 é:

x2 + 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

por ferpinheiro Postado em Python