Caninos Loucos - Contribuições do usuário [pt-br]

Garra Fischertecnik

2024-06-21T21:52:50Z

Ivan:

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

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador Guia - 2]

Configuração de um pino PWM:

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_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.

<div style="height:30em; overflow:auto; border: 2px solid #088">
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...')

</div>

Vocẽ também pode clonar o projeto já pronto no github: [https://github.com/ZoahZoah/garra_labrador 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: [https://www.youtube.com/@cfbcursos 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.

Garra Fischertecnik

2024-06-21T21:30:32Z

Ivan:

'''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.

<hr>

=='''Preparando o ambiente de desenvolvimento'''==
Para o projeto utilizaremos os seguintes itens:

'''Sistema:'''

- Labrador 32 bits

- Debian

- Python == 3.7 (latest version)

- caninos_sdk == 0.5 (latest version)

- gpiod == 1.5.4 (latest version)

'''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

<hr>

'''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.

<hr>

=='''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.

<hr>

=='''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:

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador Guia - 2]

Configuração de um pino PWM:

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM Guia - 4]

Nestes guias são comentados como utilizar os dois tipos de pino da labrador, boa sorte!

É recomendado criar o código 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.

<div style="height:40em; overflow:auto; border: 2px solid #088">
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...')

</div>
<hr>

=='''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: [https://www.youtube.com/@cfbcursos cfbcursos]

<hr>

=='''Recomendações'''==
Caso deseje ver algo mais aprofundado, fiz com que a garra funcionasse de maneira remota a partir de uma conexão local.

Se estiver interessado, acesse o projeto em meu github [https://github.com/ZoahZoah/garra_labrador Garra_fischertecnik} e clone o projeto.

<hr>

=='''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.

Garra Fischertecnik

2024-06-21T21:29:52Z

Ivan:

'''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.

<hr>

=='''Preparando o ambiente de desenvolvimento'''==
Para o projeto utilizaremos os seguintes itens:

'''Sistema:'''

- Labrador 32 bits

- Debian

- Python == 3.7 (latest version)

- caninos_sdk == 0.5 (latest version)

- gpiod == 1.5.4 (latest version)

'''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

<hr>

'''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.

<hr>

=='''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.

<hr>

=='''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:

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador Guia - 2]

Configuração de um pino PWM:

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM Guia - 4]

Nestes guias são comentados como utilizar os dois tipos de pino da labrador, boa sorte!

É recomendado criar o código 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.

<div style="height:10em; overflow:auto; border: 2px solid #088">
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...')

</div>
<hr>

=='''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: [https://www.youtube.com/@cfbcursos cfbcursos]

<hr>

=='''Recomendações'''==
Caso deseje ver algo mais aprofundado, fiz com que a garra funcionasse de maneira remota a partir de uma conexão local.

Se estiver interessado, acesse o projeto em meu github [https://github.com/ZoahZoah/garra_labrador Garra_fischertecnik} e clone o projeto.

<hr>

=='''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.

Garra Fischertecnik

2024-06-21T19:29:47Z

Ivan:

'''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.

<hr>

=='''Preparando o ambiente de desenvolvimento'''==
Para o projeto utilizaremos os seguintes itens:

'''Sistema:'''

- Labrador 32 bits

- Debian

- Python == 3.7 (latest version)

- caninos_sdk == 0.5 (latest version)

- gpiod == 1.5.4 (latest version)

'''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

<hr>

'''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.

<hr>

=='''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.

<hr>

=='''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:

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador Guia - 2]

Configuração de um pino PWM:

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM Guia - 4]

Nestes guias são comentados como utilizar os dois tipos de pino da labrador, boa sorte!

É recomendado criar o código 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.

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...')

<hr>

=='''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: [https://www.youtube.com/@cfbcursos cfbcursos]

<hr>

=='''Recomendações'''==
Caso deseje ver algo mais aprofundado, fiz com que a garra funcionasse de maneira remota a partir de uma conexão local.

Se estiver interessado, acesse o projeto em meu github [https://github.com/ZoahZoah/garra_labrador Garra_fischertecnik} e clone o projeto.

<hr>

=='''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.

Garra Fischertecnik

2024-06-21T19:26:57Z

Ivan:

'''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.

<hr>

=='''Preparando o ambiente de desenvolvimento'''==
Para o projeto utilizaremos os seguintes itens:

'''Sistema:'''

- Labrador 32 bits

- Debian

- Python == 3.7 (latest version)

- caninos_sdk == 0.5 (latest version)

- gpiod == 1.5.4 (latest version)

'''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

<hr>

'''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.

<hr>

=='''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.

<hr>

=='''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:

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador Guia - 2]

Configuração de um pino PWM:

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM Guia - 4]

Nestes guias são comentados como utilizar os dois tipos de pino da labrador, boa sorte!

É recomendado criar o código 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.

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...')

<hr>

=='''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: [https://www.youtube.com/@cfbcursos cfbcursos]

<hr>

=='''Recomendações'''==
Caso deseje ver algo mais aprofundado, fiz com que a garra funcionasse de maneira remota a partir de uma conexão local.

Se estiver interessado, acesse o projeto em meu github [https://github.com/ZoahZoah/garra_labrador Garra_fischertecnik} e clone o projeto.

<hr>

=='''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.

Garra Fischertecnik

2024-06-21T18:56:23Z

Ivan:

Garra Fischertecnik

2024-06-21T13:31:34Z

Ivan:

Garra Fischertecnik

2024-06-21T13:30:09Z

Ivan: Adicionando o processo de montagem

Guia 3 - Controlando um LED com um botão

2024-05-28T15:42:01Z

Ivan: Formatando o texto

'''Guia 3 - Controlando um LED com um botão'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o desenvolvimento

de soluções que envolvem a programação de sistemas embarcados.

Neste terceiro guia, você aprenderá a controlar um LED com um botão, para isso, utilize o Guia 3 disponibilizado abaixo:

[https://docs.google.com/document/d/1x-oHMVUgGkuBOEtTRprQuQrdooxK83x-/edit?usp=sharing&ouid=107464440979458243615&rtpof=true&sd=true Guia 3]

== '''Introdução''' ==

Neste documento você encontra o passo a passo para aprimorarmos o projeto que iniciamos no Guia 2 - Programando um LED com a Labrador. Para isso,

utilizaremos a '''Linguagem de Programação Python''', com os recursos disponibilizados na '''Caninos SDK'''. No Guia 2, verificamos como podemos

controlar as '''GPIOs''' para garantir que seja possível enviar sinais digitais para o mundo real, por meio do uso de um LED.

Neste Guia adaptaremos nossa solução anterior para que seja possível incluir um botão no processo de controle de um LED, fazendo com que ao invés

de controlarmos diretamente o LED, sejamos capazes de garantir que o LED acenda sempre que um botão for pressionado, ou apague sempre que este

botão não esteja pressionado.

'''Ao final deste experimento você será capaz de:'''

1. Ligar e Desligar um '''LED''' utilizando um botão

2. Realizar a leitura de um botão utilizando a Linguagem de Programação '''Python'''

3. Programar uma '''GPIO''', lendo um sinal digital em uma porta de sua escolha

== Descrição do Experimento ==

Quando programamos nosso LED, utilizamos o pin15 para controlar os estados de "ligado" ou "desligado" de acordo com uma rotina lógica que

pré-estabelecemos. Neste experimento vamos adaptar a solução anterior, para que seja possível ligar um LED sempre que um Botão for pressionado,

ou apagar o mesmo LED sempre que o Botão não estiver pressionado.

'''Observação I:'''
Para programar as GPIOs, enquanto a Caninos SDK estiver em modo de desenvolvimento, será necessário executar o Código 1 toda vez que você

reiniciar a sua placa.

Código 1. Definição de permissões para o uso das GPIOs:

sudo chown caninos /dev/gpiochip*
sudo chmod g+rw /dev/gpiochip*

'''Observação II:'''
Sempre mantenha a biblioteca atualizada, para isso, execute o Código 2 no terminal antes de começar a desenvolver novas soluções com sua labrador.

Código 2. Definição de permissões para o uso das GPIOs:

pip install -U caninos-sdk

'''Desta forma, você deverá:'''

1. Incluir no circuito do Guia 2 um '''botão''', garantindo que:

* O circuito necessário para conectá-lo junto a labrador seja adequadamente montado e;

* pin18 seja a '''gpio''' utilizada para a leitura deste '''botão'''.

2. Em seguida, você deve escrever um código em '''Python''', utilizando a '''Caninos SDK''', para que o '''LED''' acenda sempre que o '''botão''' seja

pressionado, ou para que o '''LED''' apague enquanto o '''botão''' não estiver pressionado.

'''Discutindo a montagem do circuito'''

[[Arquivo:figura_1_guia_2.png|thumb|400px|Figura 1]]

Para lhe auxiliar no processo de montagem, utilize as portas destacadas na Figura 1. Esta figura consiste em um mapeamento de cada uma das GPIOs

disponíveis na sua placa Labrador. Na hora de montar o seu circuito revise pelo menos duas vezes!

'''Discutindo a montagem do programa'''

Para programarmos a Labrador em Python precisaremos importar a Caninos SDK. Esta biblioteca foi desenvolvida para que possamos programar de forma mais

simples nossa labrador, e desenvolver projetos compartilháveis.

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, habilitar a GPIO (pin18) que deverá ser

definido como uma porta de entrada. Veja o Código 3.

Código 3. Criando uma variável do tipo Labrador para controlar o pin18.:
labrador = k9.Labrador()
labrador.pin18.enable_gpio(k9.Pin.Direction.INPUT, alias="button1")

Note que de acordo com o Código 3 realizamos duas operações distintas. A primeira, conforme explicado no Guia 2, permite acessar as operações básicas da labrador.

Já a segunda, nos permite definir que o pin18, associado a esta variável '''labrador''', foi ativado como uma '''gpio''' para uso no programa (por meio da função '''enable_io''').

Além disso, definimos que a '''GPIO''' será uma porta de '''entrada''', por meio da constante '''k9.Pin.Direction.INPUT'''. Por fim, definimos que ela receberá o apelido de

'''button1'''. Este apelido permite que você utilize o '''button1''' deste ponto em diante do código, o que torna um pouco mais fácil controlar seu código, certo?

Para que seja possível realizar a leitura do sinal enviado para placa, quando clicamos no botão, podemos utilizar o '''apelido''' que atribuímos anteriormente a nossa '''GPIO'''.

Para realizar a leitura do estado do botão, podemos utilizar a operação apresentada no Código 4

Código 4. O button1 (pin18) receberá um sinal HIGH (5V) se for pressionado, ou de LOW (0V) enquanto não for pressionado:

labrador.button1.read()

Com estas novas instruções já somos capazes de adaptar completamente nosso código!

 Caso tenha alguma dúvida, consulte a seção '''Código do Experimento'''.
 '''Montagem do circuito'''

Quando elaboramos um projeto que envolve o uso de microcontroladores é importante identificarmos que dois projetos distintos devem ser realizados (i) para a montagem dos recursos físicos do projeto (hardware) e (ii) a montagem do código de programação que permitirá o controle e acesso aos recursos disponibilizados pelo projeto físico.

O projeto físico neste experimento consiste em acender um LED utilizando a labrador como controlador, e permitindo que toda vez que um botão for pressionado um LED acenda. Nesta montagem especificamos uma GPIO para sinal de referência GND, uma GPIO (pin15) para conexão com o LED e uma GPIO (pin18) para conexão do botão.

Veja a Figura 2 para observar a montagem do circuito que incluí o botão que será acessado durante nosso experimento.

[[Arquivo:figura_2_guia_3.jpg|thumb|400px|Figura 2]]

Na Figura 2 adicionamos ao nosso circuito um botão. Em um dos terminais de entrada do botão conectamos o sinal de 5V da Labrador, e no outro, adicionamos um resistor, que estará em série com o sinal GND (para garantir estabilidade do botão). Na extremidade de saída, conectamos o terminal com a GPIO da labrador (pin18). Para que este circuito seja otimizado, também alteramos a montagem do LED, garantindo que o sinal de 5V seja transmitido a uma trilha de acesso comum da protoboard, para que assim, possa ser distribuído por todos os componentes tanto quanto necessário. Fazemos o mesmo com o GND.

#importamos as bibliotecas necessárias para utilizarmos a labrador
import caninos_sdk as k9

#criamos nossa variável labrador, para uso dos recursos da placa
labrador = k9.Labrador()

#ativamos o pino 15 (da labrador), como saída e definimos um apelido para ele
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

#ativamos o pino 18 (da labrador), como entrada e definimos um apelido para ele
labrador.pin18.enable_gpio(k9.Pin.Direction.INPUT, alias="button1")

#um laço de repetição para 6 iterações
while True:
#verificamos o estado do botão, caso seja ALTO, ligamos o LED
# se não, delsigamos o LED
if labrador.button1.read() == 1:
labrador.led_status.high()
else:
labrador.led_status.low()

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM >>>>>>>>>>>Guia 4 - Controlando um led por PWM]

Guia 3 - Controlando um LED com um botão

2024-05-28T15:21:09Z

Ivan: Adicionando a página do próximo guia ao final da página.

'''Guia 3 - Controlando um LED com um botão'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o desenvolvimento de soluções que envolvem a programação de sistemas embarcados.

Neste terceiro guia, você aprenderá a controlar um LED com um botão, para isso, utilize o Guia 3 disponibilizado abaixo:

[https://docs.google.com/document/d/1x-oHMVUgGkuBOEtTRprQuQrdooxK83x-/edit?usp=sharing&ouid=107464440979458243615&rtpof=true&sd=true Guia 3]

== Introdução ==

Neste documento você encontra o passo a passo para aprimorarmos o projeto que iniciamos no Guia 2 - Programando um LED com a Labrador. Para isso, utilizaremos a '''Linguagem de Programação Python''', com os recursos disponibilizados na '''Caninos SDK'''. No Guia 2, verificamos como podemos controlar as '''GPIOs''' para garantir que seja possível enviar sinais digitais para o mundo real, por meio do uso de um LED.

Neste Guia adaptaremos nossa solução anterior para que seja possível incluir um botão no processo de controle de um LED, fazendo com que ao invés de controlarmos diretamente o LED, sejamos capazes de garantir que o LED acenda sempre que um botão for pressionado, ou apague sempre que este botão não esteja pressionado.

Ao final deste experimento você será capaz de:

1. Ligar e Desligar um '''LED''' utilizando um botão

2. Realizar a leitura de um botão utilizando a Linguagem de Programação '''Python'''

3. Programar uma '''GPIO''', lendo um sinal digital em uma porta de sua escolha

== Descrição do Experimento ==

Quando programamos nosso LED, utilizamos o pin15 para controlar os estados de "ligado" ou "desligado" de acordo com uma rotina lógica que pré-estabelecemos. Neste experimento vamos adaptar a solução anterior, para que seja possível ligar um LED sempre que um Botão for pressionado, ou apagar o mesmo LED sempre que o Botão não estiver pressionado.

'''Observação I:'''
Para programar as GPIOs, enquanto a Caninos SDK estiver em modo de desenvolvimento, será necessário executar o Código 1 toda vez que você reiniciar a sua placa.

sudo chown caninos /dev/gpiochip*
sudo chmod g+rw /dev/gpiochip*

(Código 1. Definição de permissões para o uso das GPIOs)

'''Observação II:'''
Sempre mantenha a biblioteca atualizada, para isso, execute o Código 2 no terminal antes de começar a desenvolver novas soluções com sua labrador.

pip install -U caninos-sdk

(Código 2. Definição de permissões para o uso das GPIOs)

'''Desta forma, você deverá:'''

1. Incluir no circuito do Guia 2 um '''botão''', garantindo que (i) o circuito necessário para conecta-lo junto a labrador seja adequdamente montado e (ii) que o pin18 seja a '''gpio''' utilizada para a leitura deste '''botão'''.

2. Em seguida, você deve escrever um código em '''Python''', utilizando a '''Caninos SDK''', para que o '''LED''' acenda sempre que o '''botão''' seja presisonado, ou para que o '''LED''' apague enquanto o '''botão''' não estiver pressionado.

'''Discutindo a montagem do circuito'''

[[Arquivo:figura_1_guia_2.png|thumb|400px|Figura 1]]

Para lhe auxiliar no processo de montagem, utilize as portas destacadas na Figura 1. Esta figura consiste em um mapeamento de cada uma das GPIOs disponíveis na sua placa Labrador. Na hora de montar o seu circuito revise pelo menos duas vezes!

'''Discutindo a montagem do programa'''

Para programarmos a Labrador em Python precisaremos importar a Caninos SDK. Esta biblioteca foi desenvolvida para que possamos programar de forma mais simples nossa labrador, e desenvolver projetos compartilháveis.

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, habilitar a GPIO (pin18) que deverá ser definido como uma porta de entrada. Veja o Código 3.

labrador = k9.Labrador()
labrador.pin18.enable_gpio(k9.Pin.Direction.INPUT, alias="button1")
(Código 3. Criando uma variável do tipo Labrador para controlar o pin18.)

Note que de acordo com o Código 3 realizamos duas operações distintas. A primeira, conforme explicado no Guia 2, permite acessar as operações básicas da labrador. Já a segunda, nos permite definir que o pin18, associado a esta variável '''labrador''', foi ativado como uma '''gpio''' para uso no programa (por meio da função '''enable_io'''). Além disso, definimos que a '''GPIO''' será uma porta de '''entrada''', por meio da constante '''k9.Pin.Direction.INPUT'''. Por fim, definimos que ela receberá o apelido de '''button1'''. Este apelido permite que você utilize o '''button1''' deste ponto em diante do código, o que torna um pouco mais fácil controlar seu código, certo?

Para que seja possível realizar a leitura do sinal enviado para placa, quando clicamos no botão, podemos utilizar o '''apelido''' que atribuímos anteriormente a nossa '''GPIO'''. Para realizar a leitura do estado do botão, podemos utilizar a operação apresentada no Código 4

labrador.button1.read()

(Código 4. O button1 (pin18) receberá um sinal HIGH (5V) se for pressionado, ou de LOW (0V) enquanto não for pressionado.)

Com estas novas instruções já somos capazes de adaptar completamente nosso código!

 Caso tenha alguma dúvida, consulte a seção '''Código do Experimento'''.
 '''Montagem do circuito'''

Quando elaboramos um projeto que envolve o uso de microcontroladores é importante identificarmos que dois projetos distintos devem ser realizados (i) para a montagem dos recursos físicos do projeto (hardware) e (ii) a montagem do código de programação que permitirá o controle e acesso aos recursos disponibilizados pelo projeto físico.

O projeto físico neste experimento consiste em acender um LED utilizando a labrador como controlador, e permitindo que toda vez que um botão for pressionado um LED acenda. Nesta montagem especificamos uma GPIO para sinal de referência GND, uma GPIO (pin15) para conexão com o LED e uma GPIO (pin18) para conexão do botão.

Veja a Figura 2 para observar a montagem do circuito que incluí o botão que será acessado durante nosso experimento.

[[Arquivo:figura_2_guia_3.jpg|thumb|400px|Figura 2]]

Na Figura 2 adicionamos ao nosso circuito um botão. Em um dos terminais de entrada do botão conectamos o sinal de 5V da Labrador, e no outro, adicionamos um resistor, que estará em série com o sinal GND (para garantir estabilidade do botão). Na extremidade de saída, conectamos o terminal com a GPIO da labrador (pin18). Para que este circuito seja otimizado, também alteramos a montagem do LED, garantindo que o sinal de 5V seja transmitido a uma trilha de acesso comum da protoboard, para que assim, possa ser distribuído por todos os componentes tanto quanto necessário. Fazemos o mesmo com o GND.

#importamos as bibliotecas necessárias para utilizarmos a labrador
import caninos_sdk as k9

#criamos nossa variável labrador, para uso dos recursos da placa
labrador = k9.Labrador()

#ativamos o pino 15 (da labrador), como saída e definimos um apelido para ele
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

#ativamos o pino 18 (da labrador), como entrada e definimos um apelido para ele
labrador.pin18.enable_gpio(k9.Pin.Direction.INPUT, alias="button1")

#um laço de repetição para 6 iterações
while True:
#verificamos o estado do botão, caso seja ALTO, ligamos o LED
# se não, delsigamos o LED
if labrador.button1.read() == 1:
labrador.led_status.high()
else:
labrador.led_status.low()

[https://wiki.caninosloucos.org/index.php/Guia_4_-_Controlando_um_LED_por_PWM >>>>>>>>>>>Guia 3 - Controlando um led por PWM]

Guia 1 - Preparando o Ambiente de Desenvolvimento

2024-05-28T15:18:49Z

Ivan: Adicionando a página do próximo guia ao final da página.

'''Guia 1 - Preparando o Ambiente de Desenvolvimento'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o desenvolvimento

de soluções que envolvem a programação de sistemas embarcados.

Neste primeiro guia, você aprenderá a configurar o ambiente de desenvolvimento de sua labrador, para isso, utilize o Guia 1 disponibilizado abaixo:

[https://docs.google.com/document/d/1Fbobc0WxL2OzWtLRGwHwpWkG399fbSXY/edit Guia 1]

'''Pré-Requisitos de Sistema'''

*Debian 10 (Versão do Sistema Operacional)
*Kernel 4.X ou superior
*LXTerminal (Ir em: System Tools > LXTerminal)

== Introdução ==

Neste documento você encontra o passo a passo para configurar o Ambiente de Desenvolvimento que você utilizará para programar sua placa Labrador.

Ao final deste experimento teremos:

1. Uma IDE configurada para codificação de códigos em Python e que viabilizará que criemos programas utilizando, futuramente, as GPIOs.

2. versão mais atual da Caninos SDK instalada em nossa placa.

== '''Descrição do experimento''' ==

Neste experimento temos por objetivo instalar as dependências necessárias para que seja possível desenvolver soluções embarcadas, utilizando a Labrador,

com linguagem de programação Python.

As etapas necessárias para realizar as configurações de ambiente consistem em: (i) atualizar a ferramenta de pacote avançada do nosso sistema operacional

(APT) e (ii) resolver as dependências necessários para desenvolver em linguagem Python, tal como instalar o gerenciador de pacotes padrão (pip). Além

disso, precisaremos instalar os pacotes da Caninos SDK para utilizar os recursos disponíveis para uso da placa.

'''Etapa 1 - Atualizando o APT'''

*Abra o LXTerminal (ver Figura 1) disponível em sua placa Labrador.

[[Arquivo:Figura_1_guia_1.png|thumb|400px|(FIgura 1)]]

*Digite o trecho de código do Código 1 para atualizar o gerenciador apt de sua placa. Note que ao utilizar o comando sudo será necessário informar a senha

de acesso da placa, que por padrão é caninos.

Código 1. Atualizando o APT da placa labrador:
sudo apt update

'''Etapa 2 - Instalando PIP'''

*Ainda no LXTerminal, rode o comando disponível em Código 2 para instalação do gerenciador PIP. Observação: nesta etapa serão solicitadas liberação de

espaço para que seja possível instalar alguns pacotes, para isso, pressione a tecla [y] para que seja possível avançar com a instalação.

Código 2. Instalando as dependências do Python (incluindo pip):
sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl

'''Etapa 3 - Atualizando o PIP'''
*Utilize o Código 3 para atualizar o pip em sua máquina. Caso apareça alguma mensagem de erro, significa que não foi possível realizar a instalação de

forma correta. Neste caso, verifique os procedimentos anteriores.

Código 3. Verificando a versão do pip instalada:
pip3 install --upgrade pip

'''Etapa 4 - Instalando o Pacote Caninos SDK'''
*Por fim, rode o trecho de Código 4 para instalar os recursos de acesso as GPIOs (gpiod) e o pacote da Caninos SDK.

Código 4. Instalando a ferramenta para codificação IDLE3:
pip3 install gpiod
pip3 install caninos-sdk

'''Etapa 5 - Instalando IDLE'''

*Rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE):

Código 5. Instalando a ferramenta para codificação IDLE3:
sudo apt-get install idle3

'''Etapa 6 - Executando o IDLE3'''
*E por fim, execute o Código 6 para abrir a ferramenta IDLE3:

Código 6. Abrindo a ferramenta para codificação IDLE3:
idle

[https://wiki.caninosloucos.org/index.php/Guia_2_-_Programando_um_LED_com_a_Labrador >>>>>>>>>>>Guia 2 - Programando um led com a Labrador]

Guia 2 - Programando um LED com a Labrador

2024-05-28T15:16:52Z

Ivan:

'''Guia 2 - Programando um LED com a Labrador'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o

desenvolvimento de soluções que envolvem a programação de sistemas embarcados.

Neste segundo guia você encontrará um exemplo de como programar um LED, enviando um sinal digital para uma das GPIOs disponíveis na

Labrador, para isso, utilize o Guia 2 disponibilizado abaixo:

[https://docs.google.com/document/d/1tZjkWo1yBHxC_eEfaE1qUQ8wt9h-27io/edit?usp=sharing&ouid=107464440979458243615&rtpof=true&sd=true Guia 2]

Apps e Bibliotecas Necessárias:

'''Pré-Requisito:'''
1. Guia 1 - Preparando o Ambiente de Desenvolvimento

== '''Introdução''' ==

Neste documento você encontra o passo a passo para programar um LED na placa Labrador. Para isso, utilizaremos a Linguagem de Programação

Python, com os recursos disponibilizados na Caninos SDK. A Caninos SDK consiste em um conjunto de pré-definições, elaboradas pelo time da

Caninos Education, com o objetivo de democratizar o processo de programação das GPIOs.

O processo de funcionamento é muito parecido com o que já existe em outras plataformas para desenvolvimento de sistemas embarcados. No

entanto, para que seja possível utilizar a Caninos SDK é necessário que você tenha realizado o primeiro experimento "Guia 1 -

Preparando o Ambiente de Desenvolvimento".

Ao final deste experimento você será capaz de:

1. Ligar e Desligar um LED utilizando Linguagem de Programação Python

2. Programar uma GPIO, escrevendo um sinal digital em uma porta de sua escolha

'''Observação 1'''

Para programar as GPIOs, enquanto a Caninos SDK estiver em modo de desenvolvimento, será necessário executar o Código 1 toda vez que você

reiniciar a sua placa.

Código 1. Definição de permissões para o uso das GPIOs:

sudo chown caninos /dev/gpiochip*

sudo chmod g+rw /dev/gpiochip*

'''Observação 2'''

Sempre mantenha a biblioteca atualizada, para isso, execute o Código 2 no terminal antes de começar a desenvolver novas soluções com sua
labrador.

Código 2. Definição de permissões para o uso das GPIOs:

pip3 install -U caninos-sdk

'''Componentes necessários'''
*1 Placa Labrador de 32 bits
*1 LED
*1 Resistor de pelo menos 330 Ω (no exemplo utilizamos 1kΩ)
*2 Cabos MxF

== '''Descrição do experimento''' ==

Para acendermos um LED precisamos enviar um sinal de tensão que permitia que, através de uma diferença de potencial, o LED seja capaz de

emitir um brilho. Desta forma, provocaremos esta diferença de potencial utilizando duas portas diferentes da Labrador. Uma delas será a porta

GND que permitirá uma conexão de um sinal de referência (0V) para o nosso LED. A outra será a pin15, que permitirá que programemos de fato o

LED, enviando ou não, sinais de tensão de acordo com o programa que iremos criar.

'''Desta forma, você deverá:'''

Montar o circuito necessário para conectar um LED junto a labrador, garantindo

*1. O uso adequado de um resistor na montagem do circuito com o LED;
*2. Que o pin15 seja a GPIO utilizada para a programação deste LED.

Em seguida, você deve escrever um código em Python, utilizando a Caninos SDK para que o LED acenda, seja estabelecida uma pausa de 1

segundo e então o LED apague.

'''Discutindo a montagem do circuito'''

Para lhe auxiliar no processo de montagem, utilize as portas destacadas na Figura 1. Esta figura consiste em um mapeamento de cada uma das

GPIOs disponíveis na sua placa Labrador. Na hora de montar o seu circuito revise pelo menos duas vezes!

[[Arquivo:figura_1_guia_2.png|thumb|400px|(Figura 1. GPIOs disponíveis na placa labrador)]]

'''Se aprofundando um pouco mais…'''

A placa Labrador, de acordo com a Figura 1, possuí um conjunto de portas de propósito geral, que servem tanto como entrada ou saída para sinais

digitais. No entanto, algumas delas estão reservadas para funcionalidades específicas da placa ou para que possam ser utilizadas para alimentar

circuitos que utilizaremos em nosso experimento. Por exemplo, a GPIO de número 1 está associada a uma tensão de 3.3V.

Neste experimento vamos programar um LED, acendendo-o e apagando-o em intervalos de meio segundo. Para isso, utilizaremos duas portas disponíveis

no labrador: a pin15 (ver Figura 1) que será utilizada para definir quando o LED deve acender e quando ele deve apagar. E a porta GND que será

utilizada como uma referência de tensão (0V) GND.

Você pode escolher qualquer uma das portas GND disponíveis, mas caso tenha dúvidas, confira a montagem na seção "Montagem do Circuito".

'''Discutindo a montagem do programa'''

Para programarmos a Labrador em Python precisaremos importar '''Caninos SDK'''. Esta biblioteca foi desenvolvida para que possamos programar

de forma mais simples nossa labrador, e desenvolver projetos compartilháveis. Além disso, precisaremos importar a biblioteca '''time'''

para garantir as pausas de acordo com o enunciado (ver Código 3).

Código 3. Importando as bibliotecas necessárias:

import caninos_sdk as k9
import time

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, vamos habilitar o pin15 (nosso pin15) que

deverá ser definido como uma porta de saída. Veja o Código 4.

Código 4. Criando uma variável do tipo Labrador para controlar o pin15:

labrador = k9.Labrador()
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

Note que de acordo com o Código 4 realizamos duas operações distintas. Na primeira, criamos uma variável labrador e na segunda definimos que

o pin15, associado a esta variável labrador, foi ativado como uma gpio para uso no programa (por meio da função enable_io). Além disso,

definimos que a GPIO será uma porta de saída, por meio da constante k9.Pin.Direction.OUTPUT e que ela receberá o apelido de led status. Este

apelido permite que você utilize ele como uma constante, deste ponto em diante do código.

Para enviarmos um sinal de alto para esta GPIO podemos utilizar, de agora em diante, o apelido que criamos, conforme o Código 4. Para

enviarmos um sinal de HIGH (5V), podemos utilizar o algoritmo representado no Código 5. Caso seja necessário enviar um sinal de 0V, podemos

enviar um sinal de LOW, de acordo com o Código 6.

Código 5. O led_status (pin15) receberá um sinal de tensão HIGH (5V):

labrador.led_status.high()

Código 6. O led_status (pin15) receberá um sinal de tensão LOW (0V):

labrador.led_status.low()

Veja que mantivemos o acesso a variável labrador, porém utilizamos o apelido que criamos no Código 4 para realizar as operações de acender e

apagar um led. Por fim, lembre-se que para realizar as pausas entre o comando de ligar e desligar o led, será necessário implementar um delay.

Para isso, utilize o comando disponível no Código 7.

Código 7. Comando de delay com o uso da biblioteca timer:

time.sleep(0.5)

Caso tenha alguma dúvida, consulte a seção "Código do Experimento".

== '''Montagem do Circuito''' ==

[[Arquivo:figura_2_guia_2.jpg|thumb|300px|(Figura 2. Conexão dos pinos na Labrador)]]

Quando elaboramos um projeto que envolve o uso de microcontroladores é importante identificarmos que dois projetos distintos devem ser
realizados:

1. A montagem dos recursos físicos do projeto (hardware) e;

2. a montagem do código de programação que permitirá o controle e acesso aos recursos disponibilizados pelo projeto físico.

O projeto físico neste experimento consiste em acender um LED utilizando a labrador como uma placa que permita o controle dos recursos

disponíveis no mundo real. A Figura 2 permite identificar a montagem de parte deste circuito, a que está associada a Labrador. Nesta

montagem especificamos uma GPIO para sinal de referência GND e outra GPIO (pin15) que será controlada via código de programação.

Veja a Figura 3 para observar a montagem do circuito do LED que será controlado. O LED possuí duas polaridades distintas. Visualmente,

podemos identificar a polaridade positiva com a perna do LED mais "cumprida", esta deve ser conectada em série com o resistor. Já a perna

mais "curta", de polaridade negativa, deve ser conectada em série com a conexão GND.

[[Arquivo:figura_3_guia_2.jpg|thumb|400px|left|(Figura 3. Conexão dos pinos da Labrador na Protoboard)]]

Na Figura 3 conectamos as outras pontas dos conectores que associamos à placa Labrador

na Figura 2. Após isso, conectamos nosso resistor, em série, para garantir que o sinal

enviado pela pin15 da labrador passe primeiro pelo resistor indicado na Figura 3, e

somente após isso seja transmitido ao LED. Por fim, conectamos o fio marrom na outra

extremidade do nosso led.

== '''Código do Experimento''' ==
#importamos as bibliotecas necessárias para utilizarmos a labrador
import caninos_sdk as k9
#esta biblioteca permite gerar uma pausa na labrador (um delay)
import time

#criamos nossa variável labrador, para uso dos recursos da placa
labrador = k9.Labrador()

#ativamos o pino 15 (da labrador), como saída e definimos um apelido para ele
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

#um laço de repetição para 6 iterações
for i in range(0, 6):
#na labrador, acessamos o LED habilitado como saída (led_status)
#enviamos então, um sinal de ALTO para o pin15
labrador.led_status.high()

#uma pausa de meio segundo
time.sleep(0.5)

#enviamos um sinal de BAIXO para o pin15
labrador.led_status.low()
time.sleep(0.5)

[https://wiki.caninosloucos.org/index.php/Guia_3_-_Controlando_um_LED_com_um_bot%C3%A3o >>>>>>>>>>>Guia 3 - Controlando um led com um botão]

Guia 2 - Programando um LED com a Labrador

2024-05-28T14:56:25Z

Ivan: Removida a redundância do código onde após o código 4, ele voltava a repetir o que já foi escrito.

Guia 2 - Programando um LED com a Labrador

2024-05-28T14:21:17Z

Ivan: Alteração na formatação e disposição do texto

'''Guia 2 - Programando um LED com a Labrador'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o

desenvolvimento de soluções que envolvem a programação de sistemas embarcados.

Neste segundo guia você encontrará um exemplo de como programar um LED, enviando um sinal digital para uma das GPIOs disponíveis na

Labrador, para isso, utilize o Guia 2 disponibilizado abaixo:

[https://docs.google.com/document/d/1tZjkWo1yBHxC_eEfaE1qUQ8wt9h-27io/edit?usp=sharing&ouid=107464440979458243615&rtpof=true&sd=true Guia 2]

Apps e Bibliotecas Necessárias:

'''Pré-Requisito:'''
1. Guia 1 - Preparando o Ambiente de Desenvolvimento

== '''Introdução''' ==

Neste documento você encontra o passo a passo para programar um LED na placa Labrador. Para isso, utilizaremos a Linguagem de Programação

Python, com os recursos disponibilizados na Caninos SDK. A Caninos SDK consiste em um conjunto de pré-definições, elaboradas pelo time da

Caninos Education, com o objetivo de democratizar o processo de programação das GPIOs.

O processo de funcionamento é muito parecido com o que já existe em outras plataformas para desenvolvimento de sistemas embarcados. No

entanto, para que seja possível utilizar a Caninos SDK é necessário que você tenha realizado o primeiro experimento "Guia 1 -

Preparando o Ambiente de Desenvolvimento".

Ao final deste experimento você será capaz de:

1. Ligar e Desligar um LED utilizando Linguagem de Programação Python

2. Programar uma GPIO, escrevendo um sinal digital em uma porta de sua escolha

'''Observação 1'''

Para programar as GPIOs, enquanto a Caninos SDK estiver em modo de desenvolvimento, será necessário executar o Código 1 toda vez que você

reiniciar a sua placa.

Código 1. Definição de permissões para o uso das GPIOs:

sudo chown caninos /dev/gpiochip*

sudo chmod g+rw /dev/gpiochip*

'''Observação 2'''

Sempre mantenha a biblioteca atualizada, para isso, execute o Código 2 no terminal antes de começar a desenvolver novas soluções com sua
labrador.

Código 2. Definição de permissões para o uso das GPIOs:

pip3 install -U caninos-sdk

'''Componentes necessários'''
*1 Placa Labrador de 32 bits
*1 LED
*1 Resistor de pelo menos 330 Ω (no exemplo utilizamos 1kΩ)
*2 Cabos MxF

== '''Descrição do experimento''' ==

Para acendermos um LED precisamos enviar um sinal de tensão que permitia que, através de uma diferença de potencial, o LED seja capaz de

emitir um brilho. Desta forma, provocaremos esta diferença de potencial utilizando duas portas diferentes da Labrador. Uma delas será a porta

GND que permitirá uma conexão de um sinal de referência (0V) para o nosso LED. A outra será a pin15, que permitirá que programemos de fato o

LED, enviando ou não, sinais de tensão de acordo com o programa que iremos criar.

'''Desta forma, você deverá:'''

1. Montar o circuito necessário para conectar um LED junto a labrador, garantindo (i) o uso adequado de um resistor na montagem do circuito com

o LED e (ii) que o pin15 seja a gpio utilizada para a programação deste LED.

2. Em seguida, você deve escrever um código em Python, utilizando a Caninos SDK para que o LED acenda, seja estabelecida uma pausa de 1 segundo

e então o LED apague.

'''Discutindo a montagem do circuito'''

Para lhe auxiliar no processo de montagem, utilize as portas destacadas na Figura 1. Esta figura consiste em um mapeamento de cada uma das

GPIOs disponíveis na sua placa Labrador. Na hora de montar o seu circuito revise pelo menos duas vezes!

[[Arquivo:figura_1_guia_2.png|thumb|400px|(Figura 1. GPIOs disponíveis na placa labrador)]]

'''Se aprofundando um pouco mais…'''

A placa Labrador, de acordo com a Figura 1, possuí um conjunto de portas de propósito geral, que servem tanto como entrada ou saída para sinais

digitais. No entanto, algumas delas estão reservadas para funcionalidades específicas da placa ou para que possam ser utilizadas para alimentar

circuitos que utilizaremos em nosso experimento. Por exemplo, a GPIO de número 1 está associada a uma tensão de 3.3V.

Neste experimento vamos programar um LED, acendendo-o e apagando-o em intervalos de meio segundo. Para isso, utilizaremos duas portas disponíveis

no labrador: a pin15 (ver Figura 1) que será utilizada para definir quando o LED deve acender e quando ele deve apagar. E a porta GND que será

utilizada como uma referência de tensão (0V) GND.

Você pode escolher qualquer uma das portas GND disponíveis, mas caso tenha dúvidas, confira a montagem na seção "Montagem do Circuito".

'''Discutindo a montagem do programa'''

Para programarmos a Labrador em Python precisaremos importar '''Caninos SDK'''. Esta biblioteca foi desenvolvida para que possamos programar

de forma mais simples nossa labrador, e desenvolver projetos compartilháveis. Além disso, precisaremos importar a biblioteca '''time'''

para garantir as pausas de acordo com o enunciado (ver Código 3).

Código 3. Importando as bibliotecas necessárias:

import caninos_sdk as k9
import time

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, vamos habilitar o pin15 (nosso pin15) que

deverá ser definido como uma porta de saída. Veja o Código 4.

Código 4. Criando uma variável do tipo Labrador para controlar o pin15:

labrador = k9.Labrador()
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

Para acendermos um LED precisamos enviar um sinal de tensão que permitia que, através de uma diferença de potencial, o LED seja capaz de

emitir um brilho. Desta forma, provocaremos esta diferença de potencial utilizando duas portas diferentes da Labrador. Uma delas será a

porta GND que permitirá uma conexão de um sinal de referência (0V) para o nosso LED. A outra será a pin15, que permitirá que programemos

de fato o LED, enviando ou não, sinais de tensão de acordo com o programa que iremos criar.

'''Desta forma, você deverá:'''

Montar o circuito necessário para conectar um LED junto a labrador, garantindo

*1. O uso adequado de um resistor na montagem do circuito com o LED;
*2. Que o pin15 seja a GPIO utilizada para a programação deste LED.

Em seguida, você deve escrever um código em Python, utilizando a Caninos SDK para que o LED acenda, seja estabelecida uma pausa de 1

segundo e então o LED apague.

'''Discutindo a montagem do circuito'''

Para lhe auxiliar no processo de montagem, utilize as portas destacadas na Figura 1. Esta figura consiste em um mapeamento de cada uma das

GPIOs disponíveis na sua placa Labrador. Na hora de montar o seu circuito revise pelo menos duas vezes!

'''Se aprofundando um pouco mais…'''

A placa Labrador, de acordo com a Figura 1, possuí um conjunto de portas de propósito geral, que servem tanto como entrada ou saída para

sinais digitais. No entanto, algumas delas estão reservadas para funcionalidades específicas da placa ou para que possam ser utilizadas

para alimentar circuitos que utilizaremos em nosso experimento. Por exemplo, a GPIO de número 1 está associada a uma tensão de 3.3V.

Neste experimento vamos programar um LED, acendendo-o e apagando-o em intervalos de meio segundo. Para isso, utilizaremos duas portas

disponíveis no labrador: a pin15 (ver Figura 1) que será utilizada para definir quando o LED deve acender e quando ele deve apagar. E a

porta GND que será utilizada como uma referência de tensão (0V) GND.

Você pode escolher qualquer uma das portas GND disponíveis, mas caso tenha dúvidas, confira a montagem na seção "Montagem do Circuito".

'''Discutindo a montagem do programa'''

Para programarmos a Labrador em Python precisaremos importar Caninos SDK. Esta biblioteca foi desenvolvida para que possamos programar de

forma mais simples nossa labrador, e desenvolver projetos compartilháveis. Além disso, precisaremos importar a biblioteca '''time''' para

garantir as pausas de acordo com o enunciado (ver Código 3).

Código 3. Importando as bibliotecas necessárias:

import caninos_sdk as k9
import time

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, vamos habilitar o pin15 (nosso pin15) que

deverá ser definido como uma porta de saída. Veja o Código 4.

Código 4. Criando uma variável do tipo Labrador para controlar o pin15:

labrador = k9.Labrador()
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

Note que de acordo com o Código 4 realizamos duas operações distintas. Na primeira, criamos uma variável labrador e na segunda definimos que

o pin15, associado a esta variável labrador, foi ativado como uma gpio para uso no programa (por meio da função enable_io). Além disso,

definimos que a GPIO será uma porta de saída, por meio da constante k9.Pin.Direction.OUTPUT e que ela receberá o apelido de led status. Este

apeliado permite que você utilize ele como uma constante, deste ponto em diante do código.

Para enviarmos um sinal de alto para esta GPIO podemos utilizar, de agora em diante, o apelido que criamos, conforme o Código 4. Para

enviarmos um sinal de HIGH (5V), podemos utilizar o algoritmo representado no Código 5. Caso seja necessário enviar um sinal de 0V, podemos

enviar um sinal de LOW, de acordo com o Código 6.

Código 5. O led_status (pin15) receberá um sinal de tensão HIGH (5V):

labrador.led_status.high()

Código 6. O led_status (pin15) receberá um sinal de tensão LOW (0V):

labrador.led_status.low()

Veja que mantivemos o acesso a variável labrador, porém utilizamos o apelido que criamos no Código 4 para realizar as operações de acender e

apagar um led. Por fim, lembre-se que para realizar as pausas entre o comando de ligar e desligar o led, será necessário implementar um delay.

Para isso, utilize o comando disponível no Código 7.

Código 7. Comando de delay com o uso da biblioteca timer:

time.sleep(0.5)

Caso tenha alguma dúvida, consulte a seção "Código do Experimento".

== '''Montagem do Circuito''' ==

[[Arquivo:figura_2_guia_2.jpg|thumb|300px|(Figura 2. Conexão dos pinos na Labrador)]]

Quando elaboramos um projeto que envolve o uso de microcontroladores é importante identificarmos que dois projetos distintos devem ser
realizados:

1. A montagem dos recursos físicos do projeto (hardware) e;

2. a montagem do código de programação que permitirá o controle e acesso aos recursos disponibilizados pelo projeto físico.

O projeto físico neste experimento consiste em acender um LED utilizando a labrador como uma placa que permita o controle dos recursos

disponíveis no mundo real. A Figura 2 permite identificar a montagem de parte deste circuito, a que está associada a Labrador. Nesta

montagem especificamos uma GPIO para sinal de referência GND e outra GPIO (pin15) que será controlada via código de programação.

Veja a Figura 3 para observar a montagem do circuito do LED que será controlado. O LED possuí duas polaridades distintas. Visualmente,

podemos identificar a polaridade positiva com a perna do LED mais "cumprida", esta deve ser conectada em série com o resistor. Já a perna

mais "curta", de polaridade negativa, deve ser conectada em série com a conexão GND.

[[Arquivo:figura_3_guia_2.jpg|thumb|400px|left|(Figura 3. Conexão dos pinos da Labrador na Protoboard)]]

Na Figura 3 conectamos as outras pontas dos conectores que associamos à placa Labrador

na Figura 2. Após isso, conectamos nosso resistor, em série, para garantir que o sinal

enviado pela pin15 da labrador passe primeiro pelo resistor indicado na Figura 3, e

somente após isso seja transmitido ao LED. Por fim, conectamos o fio marrom na outra

extremidade do nosso led.

== '''Código do Experimento''' ==
#importamos as bibliotecas necessárias para utilizarmos a labrador
import caninos_sdk as k9
#esta biblioteca permite gerar uma pausa na labrador (um delay)
import time

#criamos nossa variável labrador, para uso dos recursos da placa
labrador = k9.Labrador()

#ativamos o pino 15 (da labrador), como saída e definimos um apelido para ele
labrador.pin15.enable_gpio(k9.Pin.Direction.OUTPUT, alias="led_status")

#um laço de repetição para 6 iterações
for i in range(0, 6):
#na labrador, acessamos o LED habilitado como saída (led_status)
#enviamos então, um sinal de ALTO para o pin15
labrador.led_status.high()

#uma pausa de meio segundo
time.sleep(0.5)

#enviamos um sinal de BAIXO para o pin15
labrador.led_status.low()
time.sleep(0.5)

Guia 0 - Sabendo o necessário

2024-05-28T13:48:17Z

Ivan: Deixando o texto dentro do campo de visão.

== Aprendendo a usar o Linux ==

Para conseguir se orientar no Linux, é necessário que o usuário esteja familiarizado com o guia [[Linux - Aplicativos e funções úteis do Linux]]. Desta forma, o

usuário poderá navegar na internet e abrir o prompt de comando sem problemas.

== Restrições do Firefox ==

É pertinente ressaltar que o Mozilla Firefox não funciona a menos que o relógio do seu computador esteja atualizado, mas isso é corrigido automaticamente se ele

estiver conectado à internet.

Guia 1 - Preparando o Ambiente de Desenvolvimento

2024-05-22T12:33:15Z

Ivan: Ajuste na largura do texto

Guia 1 - Preparando o Ambiente de Desenvolvimento

2024-05-22T12:29:20Z

Ivan: /* Descrição do experimento */

'''Guia 1 - Preparando o Ambiente de Desenvolvimento'''

Para que você possa contribuir com a Labrador, ou conduzir projetos em sala de aula, preparamos uma série de materiais que facilitarão o desenvolvimento de soluções que envolvem a programação de sistemas embarcados.

Neste primeiro guia, você aprenderá a configurar o ambiente de desenvolvimento de sua labrador, para isso, utilize o Guia 1 disponibilizado abaixo:

[https://docs.google.com/document/d/1Fbobc0WxL2OzWtLRGwHwpWkG399fbSXY/edit Guia 1]

'''Pré-Requisitos de Sistema'''

*Debian 10 (Versão do Sistema Operacional)
*Kernel 4.X ou superior
*LXTerminal (Ir em: System Tools > LXTerminal)

== Introdução ==

Neste documento você encontra o passo a passo para configurar o Ambiente de Desenvolvimento que você utilizará para programar sua placa Labrador.

Ao final deste experimento teremos:

1. Uma IDE configurada para codificação de códigos em Python e que viabilizará que criemos programas utilizando, futuramente, as GPIOs.

2. versão mais atual da Caninos SDK instalada em nossa placa.

== '''Descrição do experimento''' ==

Neste experimento temos por objetivo instalar as dependências necessárias para que seja possível desenvolver soluções embarcadas, utilizando a Labrador,

com linguagem de programação Python.

As etapas necessárias para realizar as configurações de ambiente consistem em: (i) atualizar a ferramenta de pacote avançada do nosso sistema operacional

(APT) e (ii) resolver as dependências necessários para desenvolver em linguagem Python, tal como instalar o gerenciador de pacotes padrão (pip). Além

disso, precisaremos instalar os pacotes da Caninos SDK para utilizar os recursos disponíveis para uso da placa.

'''Etapa 1 - Atualizando o APT'''

*Abra o LXTerminal (ver Figura 1) disponível em sua placa Labrador.

[[Arquivo:Figura_1_guia_1.png|thumb|400px|(FIgura 1)]]

*Digite o trecho de código do Código 1 para atualizar o gerenciador apt de sua placa. Note que ao utilizar o comando sudo será necessário informar a senha

de acesso da placa, que por padrão é caninos.

Código 1. Atualizando o APT da placa labrador:
sudo apt update

'''Etapa 2 - Instalando PIP'''

*Ainda no LXTerminal, rode o comando disponível em Código 2 para instalação do gerenciador PIP. Observação: nesta etapa serão solicitadas liberação de

espaço para que seja possível instalar alguns pacotes, para isso, pressione a tecla [y] para que seja possível avançar com a instalação.

Código 2. Instalando as dependências do Python (incluindo pip):
sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl

'''Etapa 3 - Atualizando o PIP'''
*Utilize o Código 3 para atualizar o pip em sua máquina. Caso apareça alguma mensagem de erro, significa que não foi possível realizar a instalação de

forma correta. Neste caso, verifique os procedimentos anteriores.

Código 3. Verificando a versão do pip instalada:
pip3 install --upgrade pip

'''Etapa 4 - Instalando o Pacote Caninos SDK'''
*Por fim, rode o trecho de Código 4 para instalar os recursos de acesso as GPIOs (gpiod) e o pacote da Caninos SDK.

Código 4. Instalando a ferramenta para codificação IDLE3:
pip3 install gpiod
pip3 install caninos-sdk

'''Etapa 5 - Instalando IDLE'''

*Rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE):

Código 5. Instalando a ferramenta para codificação IDLE3:
sudo apt-get install idle3

'''Etapa 6 - Executando o IDLE3'''
*E por fim, execute o Código 6 para abrir a ferramenta IDLE3:

Código 6. Abrindo a ferramenta para codificação IDLE3:
idle