Garra Fischertecnik
Garra Fischertecnik
Introdução
Este projeto foi desenvolvido por Vitor Luiz Bortoloti Pereira e adaptado por Ivan Aguiar Mendonça. A adaptação desse projeto
consiste em rodar a garra com um código Python através de uma página HTML, utilizando como biblioteca principal a caninos_sdk
e a socketIO, e o mini-computador Labrador-32bits como host do servidor.
Vale ressaltar também que essas peças utilizadas nesse projeto são exclusivas da Fischertecnik, então para obtê-las será mais dificultoso.
Preparando o ambiente de desenvolvimento
Para o projeto utilizaremos os seguintes itens:
Sistema:
- Labrador 32 bits
- Debian 10
- Python == 3.7 (latest version)
- Para facilitar, as bibliotecas deverão ser instaladas via requirements.txt, o tutorial ensinando a instalar estará logo após o código.
Componentes:
- 6 botões fischertecnik
- 8 resistores
- 2 Motores 9v CC Enconder da Fischertecnik
- 2 Motores 9v CC da Fischertecnik
- 2 Driver de motor L298N
- 1 Protoboard
- 1 Fonte externa de 9v
Explicação rápida sobre os componentes
Switch:
O switch nada mais é que um botão disponibilizado para mandar um sinal INPUT para a labrador, através desse sinal podemos realizar
algumas ações, como definir o limite de movimentação da garra e a contagem de rotações realizadas pelos motores da garra (projeto).
Motor CC 9v:
Este motor é usado para movimentar a garra para frente e para trás, e para esticar e retrair a garra, permitindo assim pegar objetos.
Motor Enconder 9v CC da Fischertecnik:
Este motor é responsável por rotacionar, subir e descer a garra. Ele também possui um codificador que ajuda a realizar a contagem
das rotações do motor, e por conta disso, possui 3 terminais a mais que o motor anterior.
Driver de motor L298N:
O driver de motor L298N é uma peça que possibilitar receber uma quantidade maior de energia proveniente de uma fonte externa, além
disso ela permite acoplar dois componentes. Neste projeto trabalharemos com duas, um a cada dois motores.
Montagem:
Switch:
O positivo do switch pode receber diretamente a voltagem de 3.3v liberada pelo pino 1 da Labrador, porém o retorno dele deve ser
ligado a um resistor que será conectado ao ground e outro fio a um pino de INPUT que será responsável por receber um sinal caso
o botão seja pressionado.
Motor Enconder 9v da Fischertecnik:
A montagem deste motor é um pouco mais complexa, ela exige uma fonte externa de 9v, apesar do driver de motor suportar uma carga
maior como a de 12v, o motor enconder exige uma alimentação de 9v em um de seus terminais, além da alimentação já proveniente de
seu lado positivo, então caso utilize uma carga superior a 9v, lembre-se de usar uma peça para reduzir a potência enviada.
Vamos começar pelo lado positivo e negativo, o v1 e v2 do motor devem ser ligados no OUT 1 e OUT 2 do driver de motor (não há
problema se inverter, mas corrija o código de acordo com sua vontade), enquanto o segundo motor será ligado no OUT3 e OUT4. Feito
isso, ligaremos os terminais deste motor, começando pelo GND (ground) que deverá ser aplicado no GND do driver de motor que terá
um fio conectado ao GND da Labrador; o VDD corresponde a potência do motor, ele quem receberá os 9v proveniente da fonte externa,
para que isso ocorra você deve conectá-lo no mesmo local que provê energia para o driver de motor, no nosso caso será na entrada
de 12v; por fim, o terceiro terminal receberá uma energia de 3.3v proveniente da Labrador que passará por um resistor enquanto
outro fio partindo do mesmo circuito levará a informação para um pino de INPUT na Labrador. Seguido os mesmos passos com o outro
motor, agora devemos configurar 4 pinos OUTPUT da Labrador, sendo dois para cada motor que deverá ser colocado nos pinos IN1, IN2,
IN3 e IN4, sendo o IN1 e IN2 correspondente ao motor conectado no OUT1 e OUT2 e, o IN3 e IN4 correspondente aos motores conectados
no OUT3 e OUT4, esses serão os fios responsáveis por enviar um sinal da Labrador para o driver de motor fazer com que os motores
realizem alguma ação. Por fim, o driver de motor será alimentado pela fonte externa de energia, sendo o lado positivo de 9v
acoplado na primeira entrada, onde o terminal VDD do motor foi colocado, ou seja, a entrada de 12v do driver; o lado negativo da
bateria deverá ser aplicado no GND do driver de motor, no mesmo local de onde os grounds dos motores estão conectados.
Motor 9v CC da Fischertecnik:
A montagem destes motores é bem semelhante ao Motor Enconder, mas bem mais simples, já que esses motores não possuem terminais.
Aqui você conectará os motores nos pinos OUT do driver de motor, e os pinos OUTPUT da Labrador nos IN do driver de motor. A fonte
externa poderá ser de 9v ou 12v e o lado positivo será conectado na entrada de 12v enquanto o lado negativo na entrada GND que
deverá estar conectador com o GND da Labrador.
Código
Se você está aqui, acredito que já saiba como funciona a configuração dos pinos, caso não saiba, sugiro que siga os guias disponibilizados.
Configuração de um pino GPIO:
Configuração de um pino PWM:
Nestes guias são comentados como utilizar os dois tipos de pino da labrador, boa sorte!
É recomendado criar a base do código que está a seguir em um arquivo separado com a extensão .py, assim você poderá chamar o arquivo
sempre que quiser, sem precisar ficar reescrevendo o código e poderá usar em outras aplicações que desejar.
import caninos_sdk as k9 #biblioteca caninos para configuração dos pinos
class Garra: # Criando a classe Garra __is_moving = False # Variável responsável por verificar se há movimento na garra
def __load_pwm_engine(self): # Configurando os pinos PWM dos motores
Habilita PWM
time_count = 1
while time_count <= 4:
self.labrador.pin32.enable_pwm( # Motor de avanço
alias="engine_foward", freq=25, duty_cycle=0.25*time_count)
self.labrador.pin36.enable_pwm( # Motor de recuo
alias="engine_backward", freq=25, duty_cycle=0.25*time_count)
self.labrador.pin28.enable_pwm( # Motor de esticar a garra
alias="engine_stretch", freq=25, duty_cycle=0.25*time_count)
self.labrador.pin24.enable_pwm( # Motor de retrair a garra
alias="engine_retract", freq=25, duty_cycle=0.25*time_count)
self.labrador.pin31.enable_pwm( # Motor de subir
alias="engine_uplift", freq=25, duty_cycle=0.1*time_count)
self.labrador.pin29.enable_pwm( # Motor de descer
alias="engine_lower", freq=25, duty_cycle=0.1*time_count)
self.labrador.pin11.enable_pwm( # Motor de girar para a esquerda
alias="engine_turn_left", freq=25, duty_cycle=0.25*time_count)
self.labrador.pin7.enable_pwm( # Motor de girar para a direita
alias="engine_turn_right", freq=25, duty_cycle=0.25*time_count)
time_count = time_count+1
def __load_gpio_engine(self): # configurando os switchs do projeto
self.labrador.pin26.enable_gpio( # Define o limite de recuo
k9.Pin.Direction.INPUT, alias="stop_button_x") # o "x" corresponde ao eixo de movimentação
self.labrador.pin18.enable_gpio( # Conta as voltas dadas pelo motor
k9.Pin.Direction.INPUT, alias="count_button_x") # o "x" corresponde ao eixo de movimentação
self.labrador.pin21.enable_gpio( # Define o limite de abertura da garra
k9.Pin.Direction.INPUT, alias="stop_button_claw")
self.labrador.pin37.enable_gpio( # Conta as voltas dadas pelo motor
k9.Pin.Direction.INPUT, alias="count_button_claw")
self.labrador.pin33.enable_gpio( # define o limite de altura
k9.Pin.Direction.INPUT, alias="stop_button_y")
self.labrador.pin35.enable_gpio( # Botão de contagem ebutido dentro do motor 9v CC encoder
k9.Pin.Direction.INPUT, alias="encoder_button_y")
self.labrador.pin13.enable_gpio( # define o limite da volta
k9.Pin.Direction.INPUT, alias="stop_button_turn")
self.labrador.pin3.enable_gpio( # Botão de contagem ebutido dentro do motor 9v CC encoder
k9.Pin.Direction.INPUT, alias="encoder_button_turn")
def __init__(self) -> None: #ao definir um __init__, toda vez que instanciarmos a classe:
self.labrador = k9.Labrador() # ela instanciará a biblioteca caninos_sdk
self.__load_pwm_engine() # ativará os pinos PWM dos motores
self.__load_gpio_engine() # ativará os pinos GPIO dos switchs
def stretch_claw(self): # Classe definida para esticar a garra
if not self.__is_moving:
self.labrador.engine_stretch.pwm.start() # ativando o pino pwm
self.labrador.engine_retract.pwm.stop() # desativando o pino pwm
limit = self.labrador.stop_button_claw.read() # se o botão mandar um sinal, a garra para
if limit == True:
self.labrador.engine_stretch.pwm.stop()
print('Limite atingido')
else:
self.__is_moving = True
print("Abrindo a garra...")
def retract_claw(self):
if not self.__is_moving:
self.labrador.engine_stretch.pwm.stop()
self.labrador.engine_retract.pwm.start()
self.__is_moving = True
print("Fechando a garra...")
def foward_claw(self):
if not self.__is_moving:
self.labrador.engine_foward.pwm.start()
self.labrador.engine_backward.pwm.stop()
self.__is_moving = True
print("Avançando...")
def backward_claw(self):
if not self.__is_moving:
self.labrador.engine_foward.pwm.stop()
self.labrador.engine_backward.pwm.start()
limit = self.labrador.stop_button_x.read()
print(limit)
if limit == True:
self.labrador.engine_backward.pwm.stop()
self.__is_moving = False
print('limite atingido')
else:
self.__is_moving = True
print("Recuando...")
def uplift(self):
if not self.__is_moving:
self.labrador.engine_uplift.pwm.start()
self.labrador.engine_lower.pwm.stop()
limit = self.labrador.stop_button_y.read()
print(limit)
if limit == True:
self.labrador.engine_uplift.pwm.stop()
self.__is_moving = False
print('limite atingido')
else:
self.__is_moving = True
print("Subindo...")
def lower(self):
if not self.__is_moving:
self.labrador.engine_uplift.pwm.stop()
self.labrador.engine_lower.pwm.start()
self.__is_moving = True
print("Descendo...")
def turn_right(self):
if not self.__is_moving:
self.labrador.engine_turn_right.pwm.start()
self.labrador.engine_turn_left.pwm.stop()
limit = self.labrador.stop_button_turn.read()
print(limit)
if limit == True:
self.labrador.engine_turn_right.pwm.stop()
self.__is_moving = False
print('limite atingido')
else:
self.__is_moving = True
print("Girando sentido horário...")
def turn_left(self):
if not self.__is_moving:
self.labrador.engine_turn_right.pwm.stop()
self.labrador.engine_turn_left.pwm.start()
self.__is_moving = True
print("Girando sentido anti-horário...")
def stop_claw(self):
self.__is_moving = False
for pin in self.labrador.enabled_features:
if pin.pwm is not None:
pin.pwm.stop()
print('Parando a garra...')
Vocẽ também pode clonar o projeto já pronto no github: Garra_fischertecnik. Lembre-se
de rodar os comando:
Para instalar o virtualenv:
pip3 install virtualenv
Para criar uma virtualenv você precisa estar dentro da pasta que deseja criar e digitar:
python3 -m venv venv
Depois que seu venv estive ativo, instale as bibliotecas digitando:
pip3 install -r requirements.txt
Pronto, você instalou todas as dependências. E agora rode o comando:
uvicorn --reload async_app:app
A partir disso, você deve entrar no link 'http://localhost:8000' e abrirá uma tela para controlar a garra, ela é responsiva ao seu teclado.
Referências
Este projeto é uma adaptação do projeto não publicado do Vitor Luiz Bortoloti Pereira.
Para utilização do funcionamento do driver L298N, utilizei o seguinte canal: cfbcursos
Agradecimentos
Gostaria de agradecer a:
Hadassa Onisaki, por ter me apresentado ao projeto e auxiliado durante o processo;
Lucas Mata, por auxilio no funcionamento das peças;
Christian de Oliveira Bueno, por me ajudar no desenvolvimento do código;
Irene Ficheman, por ajudar na motivação da finalização do trabalho.