ACESSE www.fisicarduino.com

Não quero parecer redundante mas este é o mesmo projeto anterior em termos de Arduino e Processing. Eu revisitei este projeto com o objetivo de implementar uma interface de controle mais dinâmica usando o mouse. Eu redesenhei a interface gráfica fazendo uso do objeto canvas, da biblioteca Tk. É possível agora, clicar sobre o grid e arrastar o mouse na direção que quiser e então a webcam segue o movimento do mouse.

Para baixar os códigos fonte clique no link ao lado: WebCam – Servo C. – FisicArduino – Nova versao de controle

Foto do projeto:

Assista ao vídeo!

Código python:

##############################################################################################################
#                                                                                                            #
# Programa que controla uma webCAm usando dois servo motores que sao controlados pelo Arduino.               #
# O programa se comunica com o Arduino atraves da porta serial.                                              #
# A visualizacao da imagem da webCam e feita atraves de um programa na linguagem PROCESSING                  #
# Ha um trabalho em equipe das linguagens: PYTHON, C++ ( ARDUINO ) e PROCESSING                              #
# Muita atencao na hora de usar os fontes pois o codigo para o Arduino tem a mesma extensao para PROCESSING  #
# Autor: Marcelo Rocha - www.fisicarduino.wordpress.com                                                      #
#                                                                                                            #
##############################################################################################################

from Tkinter import * # Importa a biblioteca grafica
import serial # Importa o modulo para a comunicacao serial
import time # Importa a biblioteca para trabalhar com temporizacao

# Configuração da porta serial

ser = serial.Serial("COM3",9600); # Define porta e a velocidade de comunicação
print ser.portstr; # Imprime a porta em uso
print ('aguarde, incializando a porta...');
time.sleep(2); # Aguarda 2 segundos

# Obs. A variável valor é enviada pelo Scale implicitamente e contém o valor atual da posição do Scale
def servo_A(valor): # Funcão que envia o valor do Slide_A para o Servo_A, através da porta serial
   ser.write('a') # parte do protocolo de comunicação. Ex.: a100
   ser.write(chr(int(valor))) # Converte a variável valor de str para int e de int para char ( byte )

def servo_B(valor): # Funcão que envia o valor do slide A para o Servo_A, através da porta serial
   ser.write('b') # parte do protocolo de comunicação. Ex.: b100
   ser.write(chr(int(valor))) # Converte a variável valor de str para int e de int para char ( byte )

def clica_Move( event ):
   if (event.x >= 0 and event.x = 0 and event.x       scale2.set(179 - event.y) # Envia os valores da posicao do mouse para o scale, e consequentemente chama a funcao servo_B

def sair(): # Função que destrói a Janela principal, antes fecha a porta serial
   ser.close() # Fecha a porta serial
   print('Fechando a porta serial...')
   time.sleep(1)
   print('Fechando a janela..')
   time.sleep(1)
   root.destroy() # Destrói a janela

# processo de criação da UI com TKinter

root = Tk() # Cria a janela
root.title('WebCam_Servo') # Define o títula da janela
root.geometry('380x290') # Define o tamanho da janela principal
Meu_Canvas = Canvas(root, width=180, height=180) # Cria um objeto tipo canvas e define o tamanho do Canvas
Meu_Canvas.place(x=30,y=30) # Posiciona o Canvas na janela pricipal

# Desenha o retangulo preto mais o grid ( Azul ) no Canvas

Meu_Canvas.create_rectangle(0, 0, 180, 180, fill="black")
coords = 1 # São 10 linhas horizontais e 10 verticais
while (coords    Meu_Canvas.create_line(0, 18*coords, 179, 18*coords, fill="blue") # linha horizontal
   Meu_Canvas.create_line(18*coords, 0, 18*coords, 179, fill="blue") # linha vertical
   coords = coords+1 # Mais uma linha, mais uma coluna

Meu_Canvas.bind("", clica_Move) # Anexa ao Meu_Canvas, a função que trata o clicar e arrastar do mouse sobre o Canvas

# Cria dois objetos Scale que pode variar de 0 a 179, e associa-o à função servo_A e servo_B respectivamente

# Pega os valores do scale1 e
scale1 = Scale( root, from_=0, to=179, command = servo_A, width=15, length=179 )
scale1.place(x=250,y=30)
scale2 = Scale( root, from_=0, to=179, command = servo_B, width=15, length=179 )
scale2.place(x=310,y=30)

# Cria os Labels na tela.
label = Label(root, text='WEBCAM - Servo Controller - FisicArduino')
label.place(x=10, y=5) # Posiciona o label
label = Label(root, text='Y_Spin')
label.place(x=260, y=210) # Posiciona o label
label = Label(root, text='X_Spin')
label.place(x=320, y=210) # Posiciona o label

# Cria um objeto botão

b = Button(root, text ='     Exit     ', command = sair) # Anexa a funcao Sair a evento de clique do botao
b.place(x=90, y=240) # Posiciona o botao

root.mainloop() # Coloca o programa em execução

Código do Arduino:

// Controle WebCAm, com dois servo motores usando Python e TK

#include <Servo.h>

Servo servo_A, servo_B; // Cria dois objetos do tipo Servo.
int eixo =0 , bytelido = 0; // Cria duas variaveis do tipo int.

void setup (){
Serial.begin(9600); // Configura a velocidade da comunicação serial.
servo_A.attach(9); // Anexa o objeto x_servo ao pino 9 do arduino.
servo_B.attach(10); // Anexa o objeto y_servo ao pino 10 do arduino.
servo_A.write(0); // posiciona x_servo no angulo zero grau.
servo_B.write(0); // posiciona y_servo no angulo zero grau.
}

void loop(){
while (Serial.available() > 0){ // Enquanto houver algum byte na entrada serial.
eixo = Serial.read(); //Lê um byte e armazena na variável eixo.
if ( eixo == 'a' ) { // Verifica se eixo é igual ao caractere a.
delay(10); // Espera 10ms
bytelido = Serial.read(); // Como eixo igual a 'a', bytelido recebe o valor do 'slider a' da UI em python.
servo_A.write(bytelido); // Passa para o servo_A o valor de bytelido.
}
if ( eixo == 'b' ) { // Verifica se eixo é igual ao caractere b.
delay(10); // Espera 10ms
bytelido = Serial.read(); // Como eixo igual a 'b', bytelido recebe o valor do 'slider b' da UI em python.
servo_B.write(bytelido); // Passa para o servo_B o valor de bytelido.
}
}
}

Código Processing:

/**
 * Lendo e exibindo uma imagem da camera ( Dispositivo de captura ) anexada ao computador
 */

import processing.video.*; // importa a biblioteca de video

Capture cam; // Cria um objeto do tipo Capture

void setup() {
  size(640, 480); // Define o tamanho da janela principal

  cam = new Capture(this, 480, 400); // Tamanho da imagem capturada

  // Para usar uma outra camera, isto e, se o dispositivo padrao gerar um erro,
  // lista todos os dispositivos disponiveis no console para achar sua camera
  String[] devices = Capture.list();
  println(devices);

  // Use devices[x] para usar a camera desejada
  cam = new Capture(this, width, height, devices[1]); // No meu notebook, devices[0] e' minha WebCam onboard, devices[1] 'e minha WebCam usb

}

void draw() {
  if (cam.available() == true) { // Verifica se a camera esta disponivel
    cam.read(); // Le a imagem
    image(cam, 0, 0,width,height); // Exibe a imagem
  }
}