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:

Guia - 2

Configuração de um pino PWM:

Guia - 4

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.