aut 2501 desenho paramétrico e fabricação digital...
TRANSCRIPT
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
Aula XX Firefly Motores de Servo e Atuador Linear
Demonstração técnica sobre o controle de dois tipos de motor, usando o aplicativo
Grasshopper – que acrescenta recursos de modelagem paramétrica ao Rhinoceros – e o plugin
Firefly, que dá ao Grasshopper ferramentas para que se comunique diretamente com placas
controladoras Arduino.
Controle digital de motores é parte do experimento desenvolvido no trabalho final de
graduação (TFG) de Stefano Mega, sob a orientação do Prof. Arthur Lara; que estuda o
desenvolvimento de dispositivos eletrônicos semelhantes a braços robóticos e sua aplicação
na arquitetura e no design.
Endereços eletrônicos importantes:
Firefly.................... http://fireflyexperiments.com/
Arduino……………….. http://arduino.cc/en/
TFG........................ http://www.stefanomega.com.br/tfg/
Arduino
Em 2005 o italiano Massimo Banzi criou uma placa controladora foi para que seus alunos – do
Interaction Design Institute de Ivrea – pudessem começar aprender eletrônica diretamente na
prática. Algum tempo depois a placa foi aperfeiçoada em coautoria com David Cuartielles,
Gianluca Martino, Tom Igoe, David Melliso e chamada de Arduino.
Por ser um hardware de design aberto, de baixo custo e de grande facilidade de uso, a
notoriedade do Arduino se espalhou rapidamente pela rede, permitindo que pessoas de
diferentes formações e níveis técnicos pudessem, pela primeira vez, construir seus próprios
dispositivos.
O IDE (Integrated Development
Environment) do Arduino – o programa
usado para escrever, compilar e enviar
o código através de um cabo USB do
computador até a placa – usa a
linguagem de programação Processing
que, desenvolvida no MIT, também é
aberta e muito simples de usar. Está
disponível na rede no endereço
http://arduino.cc/en/Main/Software
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
Firefly
Instalando o Firefly:
1. Baixe um dos arquivos disponíveis página do desenvolvedor
(http://fireflyexperiments.com/download/), de acordo com a arquitetura do seu
computador: 32 ou 64 bits. O arquivo conterá o Firefly e um firmware, ou seja, um
arquivo de código para o Arduino que precisa ser instalado na placa para que
compreenda as instruções enviadas pelo Firefly.
2. Descompacte o arquivo em uma pasta.
3. Os arquivos contidos na subpasta Firefly Installation devem ser transferidos para a
pasta de componentes que no próprio Grasshopper pode ser acessada através do
menu File > Special Folders > Components Folders. Em seguira, é necessário reiniciar o
Rhinoceros e o Grasshopper.
4. Para tornar o firmware acessível pela IDE do Arduino, o conteúdo da pasta Arduino
Code deve ser transferido para a pasta
C:\Users\[NomedoUsuário]\Documents\Arduino
Usando o Firefly: Operações Básicas
Os elementos cruciais para elaborar qualquer
programa com elementos do Firefly estão no
menu Arduino & I/O Boards, descritos a seguir
(informações mais detalhadas serão fornecidas
nas demonstrações):
1. COM Port Available: mostra portas seriais disponíveis para uso, atualmente ocupadas
por dispositivos reconhecidos pelo Firefly.
2. Open/Close Port: abre uma porta serial para que os demais componentes possam
utilizá-la. Deve estar na área de trabalho em qualquer projeto de Firefly.
3. Uno Write: Dá acesso aos pinos de saída de placas do
tipo Uno. Quando a informação é fornecida a um dos
pinos na interface do componente no Grasshopper, o
pino de saida equivalente no Arduino é comandado a
enviar um sinal elétrico.
4. Uno Read: Disponibiliza os pinos de entrada de placas
do tipo Uno. Os sinais elétricos recebidos pelos pinos de
entrada do arduino ficam disponíveis para leitura na
interface do ecomponente.
5. Mega Write: a mesma função de Uno Write, mas para placas do tipo Mega, com mais
pinos e recursos.
6. Mega Read: a mesma função de Uno Read, mas para placas do tipo Mega, com mais
pinos e recursos.
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
Usando o Firefly: Operações Extras
O Firefly tem componentes específicos para o
uso de uma ferramenta poderosa de visão
computacional que requer uma breve
introdução: o Kinect.
É o controle produzido para o console de
jogos Xbox 360 da Microsoft, que usa a
tencologia desenvolvida pela pioneira
empresa PrimeSense. Vem equipado com um
sensor de profundidade e câmera colorida e é
capaz de estimar a posição tridimensional do
esqueleto do usuário, desenhando na tela um
conjunto de pontos com coordenadas X, Y e Z, equivalentes à posição das articulações,
conectados por linhas.
Essas coordenadas podem ser usadas para que o usuário gere, com gestos, dados espaciais
para controlar dispositivos ligados ao Arduino.
1. Paint Bitmap: Exibe na área de trabalho do Firefly as modificações feitas com os filtros
modificadores de imagem (salientados em vermelho na imagem acima),
disponibilizados pelo Firefly. Funciona em qualquer elemento que produza um Bitmap
como saída de dado.
2. Load Bitmap: Lê uma imagem a partir de um componente Path, que deve conter o
contém o caminho. Abaixo uma imagem de um componente Path, ligado à um
componente Load Bitmap, filtrado por um componente Emboss, com o produto final
sendo exibido por um componente Paint Bitmap.
3. Video Player: Quando um vídeo com formato compatível é carregado neste elemento
através de um componente Path, o Video Player produz uma sequência de Bitmaps,
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
desenhados na área de trabalho do Grasshopper.
4. Webcam Video Stream: usa uma webcam para produzir imagens em sequência que
são exibidas no componente. Funciona de maneira similar ao componente Video
Player.
5. Kinect Color Stream: usa a câmera colorida do Kinect e também exibe uma
visualização das imagens. Funciona de maneira similar aos componentes Video Player
e Webcam Video Stream.
6. Kinect Depth Stream: usa sensor de profundidade do Kinect para produzir mapas de
profundidade – ou seja, uma imagem em preto e branco onde os objetos mais
próximos ficam mais claros e os mais distantes, mais escuros. O componente exibe
uma visualização da imagem – em sequência.
7. Kinect Depth to Point: Converte cada um dos pixels dos mapas de profundidade
gerados no componente Kinect Depth Stream em uma lista de pontos com dados
numéricos de profundidade.
8. Kinect Skeletal Tracker: Gera as coordenadas dos pontos da articulação do esqueleto,
descrito no parágrafo introdutório.
Exemplo
A imagem abaixo ilustra a montagem de um sistema para extrair a informação dos canais RGB
de cada um dos pixels de uma imagem. Esse é outro exemplo do que pode ser feito com
outros desses novos componentes Bitmap Info – que retorna a altura Ry e a largura Rx da
imagem – e Bitmap Sampler – que retorna a informação RGB de pixels (Pt) especificados por
coordenadas – também introduzidos em versões recentes do Firefly.
O elemento Panel exibe a lista produzida com a informação RGB (Red, Green e Blue) de cada
um dos pixels da imagem.
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
Demonstração 1: atuador linear de farol adaptado
Os motores usados nessa demonstração foram os
mesmos usados no primeiro dispositivo
(http://www.stefanomega.com.br/tfg/regDisp01/)
desenvolvido na pesquisa do TFG.
Tratam-se de atuadores de 12V, que trabalham com
movimentos lineares, empregados originalmente para
controlar a altura de faróis de automóveis.
No entanto o que chamamos de motores são, na
realidade, sistemas envoltos por uma estrutura plástica,
compostos por três partes:
um motor DC com dois terminais elétricos.
uma haste ligada à um sistema de engrenagens
redutoras, que transorma quantidade de giros do motor
DC em torque.
também havia uma placa controladora interna,
que permitia que o atuador determinasse a posição da
haste, mas foi necessário eliminá-la.
As imagens ao lado mostram o atuador aberto, com as
engrenagens e motor acomodados na estrutura plástica.
Dois os fios soldados aos terminais elétricos do motor são
usados para alimentar o sistema.
Shield e Arduino
Por causa da alta tensão do motor – incompatível com os
5V do Arduino – e porque o arduino não consegue
trabalhar com inversão de corrente/tensão de
alimentação em seus pinos, foi necessário usar um shield.
Shield é o nome dado à uma placa auxiliar que, quando acoplada ao Arduino acrescenta
funcionalidades específicas ao equipamento original. Neste caso, o shield utilizado é o 4Power,
fabricado pela empresa Lab de Garagem (http://labdegaragem.com/profiles/blogs/tutorial-
como-utilizar-o-shield-4power-com-arduino).
O 4Power é um equipamento que serve exclusivamente para controlar motores DC. Controla
até 4 deles, com uma tensão de alimentação de até 46V e corrente total de até 4A ou de até
2A por motor – ou seja, até quatro motores de 1A ou dois de 2A.
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
As imagens abaixo mostram o shield acoplado à um Arduino e um diagrama ilustrando a
função de cada um dos terminais. De cima para baixo, os oito primeiros divididos em pares de
positivo e negativo, são nomeados M1, M2, M3 e M4 e recebem os motores DC; os últimos
dois terminais – onde Vcc é o positivo e GND o negativo – recebem a alimentação externa, que
deve ser compatível com os motores usados.
O atuador está ligado aos terminais positivo e negativo M1.
Controle digital
Nesta demonstração o atuador é controlado através do IDE do Arduino.
O código na próxima página foi escrito seguindo o exemplo disponibilizado na página do
fabricante (http://www.labdegaragem.com.br/wiki/index.php?title=Shield_4Power) e deve ser
copiado e colado em um novo documento no IDE do Arduino. Em seguida, salvo na pasta
sketchbook, com o nome s4power_test_comandable.
Para que funcione, também é necessário que
a biblioteca do fabricante (http://www.
labdegaragem.com.br/loja/s4power.zip) seja
baixada e descompactada na pasta libraries,
também dentro do diretório de instalação do
IDE do Ardino.
Quando compilado e enviado para a placa, o
código permitirá que, através da ferramenta
serial monitor – localizada no menu Tools >
Serial Monitor ou através do ícone de lupa
localizado no canto superior direito, no IDE
do Arduino –, cada um dos motores possa
ter suas velocidades e sentidos de giro
modificados através da variável speed
(explicada com maiores detalhes mais
adiante). O valor dessa variável pode ser
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
alterado através da linha de comando do serial monitor, numa escala que varia de -100 a 100,
com os seguintes resultados:
Se o valor da variável speed for 0 o motor para.
Se for -100, o motor gira com potência máxima, no sentido anti-horário.
Se for 100, o motor gira com potência máxima, no sentido horário.
Todos os valores intermediários ajustam a velocidade dos motores
proporcionalmente.
Código para o arquivo s4power_test_comandable.ino (consulte http://arduino.cc/en/Tutorial/
Sketch para conhecer os elementos básicos da programação para Arduino):
/*
* ATENÇÃO: Mudar a opção 'No ending line' para 'Newline' no dropbox do Serial
Monitor.
* Referência usada:
<http://my.safaribooksonline.com/book/hobbies/9781449399368/serial-
communications/receiving_serial_data_in_arduino >
*
* Author: Stefano Mega - [email protected] - <
http://www.stefanomega.com.br >
*/
#include "S4Power.h"
S4Power s4power;//Instanciando um objeto do tipo S4Power.
int intensityValue = 0; //Atual valor de intensidade de giro do motor e brilho
do led.
int sign = 1; //Inteiro usado para estabelecer se intensityValue é positivo ou
negativo. Pode ser 1 ou -1.
void setup()
{
s4power.Config(); //Inicializando configurações internas do pacote.
Serial.begin(9600); //Inicializando a trasmissão de dados via porta USB.
}
void loop()
{
//Só receber dados quando houver algum disponível.
if (Serial.available() > 0) {
char charTemp = Serial.read(); //Ler Serial e armazenar o primeiro
caracter na variável.
if(charTemp >= '0' && charTemp <= '9') // Garantindo que o char é um
algarismo de 0 a 9.
{
intensityValue = (intensityValue * 10) + (charTemp - '0'); //Se sim,
acrescentar o char ao fim da variável intensityValue.
}
else if( charTemp == '-') //Se o caractere '-' aparecer, assinalar um
multiplicador negativo.
{
sign = -1;
}
else if (charTemp == 10) //Se o enter for precionado (new line é o ASCII
10)
{
//Limitando os valores ao intervalo de -100 a 100.
if ((intensityValue <= 100) && (intensityValue >= -100))
{
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
intensityValue = intensityValue * sign; //Aplicando o sinal, se
cabível.
changeIntensity(intensityValue); //Usando a função que informa a
4Power do valor da velocidade.
Serial.print("Nova velocidade: ");
Serial.println(intensityValue);
intensityValue = 0; //Zerando o intensityValue, para que possa receber
a nova sequência.
sign = 1; //Positivando o sinal (default)
}
else { Serial.println("Valores de velocidade devem estar entre -100 e
100."); intensityValue = 0; sign = 1;}
}
else { Serial.println("Só são permitidos caracteres de 0 a 9 ou o sinal de
-."); intensityValue = 0; sign = 1; }
}
}
void changeIntensity(int newIntensity)
{
s4power.M1.speed = newIntensity; //Mudando o valor da variável 'speed' para
o motor M1.
s4power.M1.Update(); //Mudando a velocidade com o valor de 'speed'.
s4power.M2.speed = newIntensity; //Mudando o valor da variável 'speed' para
o motor M1.
s4power.M2.Update(); //Mudando a velocidade com o valor de 'speed'.
s4power.light.intensity = newIntensity; //Mudando o valor da variável
'intensity' para o led.
s4power.light.Update(); //Mudando o brilho com o valor de 'speed'.
}
Os seguintes elementos são fundamentais de serem observados no código acima: 1. No início a biblioteca do fabricante do shield é importada em #include "S4Power.h" 2. Um objeto representado o shield do tipo S4Power é instanciado (S4Power s4power;)
para que os métodos e propriedades que controlam os motores fiquem disponíveis em nosso código.
3. Antes de ser usado, o objeto deve ser inicializado, com chamada do método s4power.Config();
4. Nas últimas linhas de código, é possível ver a variável speed sendo acessada nos dois primeiros motores, representados pelos objetos M1, M2, localizados dentro do objeto s4power.
Demonstração 2: mini servomotor Motores como os usados nesta demonstração estão
sendo empregados para desenvolver um segundo
dispositivo na pesquisa do TFG. Ainda não há registro
formal do experimento.
Todos os servomotores têm três terminais elétricos. Um
positivo – identificado pela cor vermelha –, um
negativo – preto ou marrom – e um sinal – que pode
ser amarelo ou branco. Os dois primeiros terminais são
para a alimentação elétrica do motor e o sinal é a
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
interface de controle, por onde é possível passar instruções na forma de sinais elétricos, para
que a placa controladora interna gire os eixos até a posição desejada.
O modelo de servomotor usado nesta demonstração especificamente (http://www.hobbyking
.com/hobbyking/store/__9549__turnigy_tg9e_9g_1_5kg_0_10sec_eco_micro_servo.html)
tem as seguintes características:
Amplitude angular de giro do eixo de 180°. Existem servos que giram até 360° e
servomotores de rotação contínua. 5V de potência, ou seja, compativel com a tensão nativa do Arduino. Isso quer dizer
que, diferente dos atuadores da primeira demonstração, podem ser alimentados
diretamente pelo Arduino, sem a necessidade de placas auxiliares. 1.5Kg/cm de torque, ou seja, se o motor tivesse uma carga presa numa haste
perpendicular ao eixo a uma distância de: o 10cm, suportaria levantar uma carga de até 150g. o 3cm, suportaria levantar uma carga de até 500g. o 1cm, suportaria levantar uma carga de até 1.5Kg.
Arduino
Ligar o servomotor de 5V ao Arduino é
extremamente simples. Basta usar o sistema de
cores descrito no início da demonstração para
reconhecer os terminais e liga-lo nos pinos certos.
Só é necessário tomar um cuidado extra, com o
terminal sinal.
Todos os pinos do Arduino trabalham com sinais
digitais, que podem produzir dois valores 0 (LOW)
ou 1 (HIGH).
No entanto alguns desses pinos, identificados
com os caracteres PWM (que significam Pulse
Modulation Width) são pinos especiais, capazes de produzir sinais binários modulados e assim
simular sinais analógicos com múltiplos valores – que por padrão variam de 0 a 255.
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
A imagem ao lado exemplifica o processo. Dentro de um
módulo de tempo fixado, o Arduino varia a
porcentagem ocupada pelo valor 0 (LOW) e pelo valor 1
(HIGH), criando combinações que formam padrões
elétricos distinguíveis pela placa controladora interna
do servomotor. Por exemplo, quando, dentro do
módulo de tempo, o sinal está 75% do tempo ligado e
25% do tempo desligado, o valor analógico produzido é
o resultado arredontado da operação 0,75 x 255, ou
seja, 191.
Os valores modulados podem ser interpretados de
maneiras diferentes, de forma a produzir resultados
analógicos adaptados a necessidades específicas. Por exemplo: no caso do servomotor da
demonstração que unidades angulares para marcar o deslocamento a escala necessária vai de
0 a 180. Logo quando o sinal estiver – como no exemplo anterior – ligado durante 75% do
módulo de tempo padrão, o valor analógico produzido será de 135.
Firefly
É bastante simples montar um sistema de componentes que permita operar o motor na
interface do Grasshopper:
1. O firmware deve estar intalado no Arduino (ver o início do texto).
2. Assegure-se de que o Arduino está ligado à uma entrada USB do computador.
3. No menu do Firefly, traga o elemento COM Ports Available para a área de trabalho e
conecte um elemento Panel à variável de saída P, para que as portas em uso possam
ser rapidamente visualizadas.
4. Faça o mesmo com o elemento Open/Close Ports. Neste caso o elemento Panel
exibirá mensagens relatando erro ou acerto da operação de abertura de portas.
5. Para abrir a porta pré-detectada conecte a variável P de saída de COM Ports Available,
à variável de entrada Port do elemento Open Port.
6. Ainda no elemento Open Port, crie um elemento Boolean Toggle e ligue-o à variável
Open, para que sirva como controle para abrir e fechar as portas detectadas.
AUT 2501 Desenho Paramétrico e Fabricação Digital 2013
Prof. Arthur Lara [email protected]
7. Arraste para a área de trabalho um elemento Uno Write, do Firefly. Acrescente
elementos Panel nas variáveis de saida Out – que exibirá a string de dados a ser
enviada para o Arduino – e Msg – que exibirá mensagens sobre o sucesso ou fracasso
do envio das informações.
8. Usando como parâmetro o pino do Arduino escolhido para ligar o sinal do servomotor,
conecte um elemento Number Slider ao pino correspondente no elemento Uno Write.
9. Configure o Number Slider para que tenha
apenas valores inteiros (N), com valores que se
adequem a escala do servomotor, ou seja, min 0 e
max 180.
10. Usando o segundo botão do mouse sobre o pino escolhido no
elemento Uno Write, selecione a opção Servo.
11. Um outro elemento Boolean Toggle é necessário na variável de
entrada Start do elemento Uno Write. Quando ativado, esse
elemento iniciará o envio dos dados exibidos na variável de saida
Out – desde que a variável de entrada Port esteja recebendo o
número de uma porta aberta e válida.
12. Para operar o sistema, ative os dois elementos Boolean Toggle e use o Number Slider
para variar o giro do eixo do motor entre as duas posições extremas.