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

Guia 5 - Enviando dados da Labrador para o Arduino com I2C

2023-08-31T18:00:46Z

Nickdias:

'''Guia 5 - Enviando dados da Labrador para o Arduino com I2C'''

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 quinto guia, você aprenderá a enviar dados da Labrador para o Arduino com I2C, para isso, utilize o Guia 5 disponibilizado abaixo:

[https://docs.google.com/document/d/1YI4sLhD7B0gQaXjbJU3Mbu3auFk-8gIy/edit?usp=sharing&ouid=107464440979458243615&rtpof=true&sd=true Guia 5]

'''Observações gerais'''
*Pré-Requisito: "Guia 2 - Programando um LED com a Labrador"

== Introdução ==

Durante o desenvolvimento de soluções embarcadas é comum precisarmos estabelecer a comunicação entre dois dispositivos distintos. A comunicação entre dois dispositivos só é possível quando estabelecemos um protocolo que seja capaz de viabilizar a troca de mensagens.

Um protocolo, por sua vez, pode ser tratado como uma convenção, composta por um conjunto de regras, que viabiliza a comunicação entre duas entidades distintas. Em outras palavras, um protocolo permite que criemos um conjunto de regras de comunicação para que uma "conversa" aconteça. No dia-a-dia, por exemplo, utilizamos protocolos para conversar com outras pessoas! Geralmente iniciamos uma conversa com uma saudação, por exemplo.

No universo dos microcontroladores, utilizamos um protocolo para estabelecer a comunicação entre dispositivos de baixa velocidade de transmissão, e microcontroladores, para quando os dispositivos não estão muito distantes. Este protocolo é o I2C, que significa Inter-Integrated Circuit. Este protocolo foi desenvolvido pela Philips em 1982 e tem por objetivo permitir que dois dispositivos se comuniquem de forma adequada, desde que um deles assuma o papel de dispositivo principal, e o outro possa atuar como um dispositivo agente.

Neste Guia vamos utilizar a labrador para enviar mensagens para o Arduino utilizando o protocolo I2C.

Ao final deste experimento você será capaz de:

1. Utilizar a IDE do Arduino em conjunto com a sua placa labrador
2. Estabelecer a comunicação entre a labrador (dispositivo principal) e uma placa Arduino (dispositivo agente) utilizando I2C

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

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

pip3 install -U caninos-sdk

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

'''[NOVO] Observação 3'''

Para utilizar o protocolo I2C será necessário autorizar as permissões de acesso, para isso, rode o Código 3.

sudo chmod a+rw /dev/i2c-*

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

'''[NOVO] Observação 4'''

Além disso, é necessário instalar a biblioteca listada abaixo:

pip3 install pylibi2c

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

'''Componentes necessários'''
*1 Placa Labrador de 32 bits
*1 Placa Arduino Uno
*1 Hub USB para acesso a pelo menos três portas USB na Labrador
*3 Cabos MxF

== Descrição do experimento ==

Conforme mencionado na introduçao deste guia, um protocolo é utilizado para garantir que as regras de comunicação sejam bem estabelecidas entre dois dispositivos diferentes. Desta forma, este experimento, diferente dos anteriores, utilizará duas placas distintas.

A Labrador assumirá o papel de placa principal, sendo capaz de enviar informações para a placa arduino. Já a placa Arduino Uno, assumirá o papel de placa agente, em que eventualmente, pode utilizar as informacões proessadas pela Labrador, para que desempenhe o seu papel enquanto um microcontrolador.

Esta comunicação utilizará duas linhas de transmissão (i) o Serial Data (SDA) e (ii) o Serial Clock (SCL). O SDA é responsavel por enviar e receber os dados de uma placa para a outra, já o SCL é utilizado para estabelecerum clock que garante a sincronia entre os sistemas.

Não nos aprofundaremos neste guia a respeito das diretrizes de uso do protocolo I2C. No entanto, destacaremos como utilizar a Caninos SDK para estabelecer a comunicação entre os dois dispositivos, bem como, construiremos juntos um exemplo para ilustrar esta comunicação.

Para isso, você deverá:

1. Estabelecer uma conexão entre as duas placas, conectando as portas SDA, SCL e GND do Arduino com as GPIOs necessárias para construção da infraestrutura de comunicação entre os dois dispositivos.
2. Escrever um código em linguagem Arduino, para que seja possível receber os dados enviados pela Laborador.
3. Escrever um código em Python, utilizando a Caninos SDK para que (i) a comunicação I2C seja estabelecida entre os dois dispositivos e (ii) seja possível enviar dados para o Arduino por I2C

'''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 pelo menos duas vezes!

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

Além disso, também será necessário utilizar conexões com a placa arduino. Utilize a Figura 2, extraída do Student-Circuit (2023) como base para o mapeamento destas portas.

[[Arquivo:figura_2_guia_5.jpg|thumb|400px|Figura 2. GPIOs disponíveis na placa Arduino Uno]]

Para estabelecer a comunicação entre os dispositivos, precisamos utilizar as portas de comunicação SDA e SCL estabelecidas para cada dispositivo. Veja a Figura 3 que ilustra esta montagem.

[[Arquivo:figura_3_guia_5.jpg|thumb|400px|Figura 3. Conexões entre a Labrador e o Arduino Uno]]

== Discutindo a montagem do programa ==

'''Do lado do Arduino...'''

Para programarmos o Arduino, utilizaremos a biblioteca Wire.h. Desta forma, utilize o Código 5 para importa-la em seu programa.

#include <Wire.h>

Código 5. Importando as bibliotecas necessárias

Após isso, precisamos garantir que o preparo do Arduino, seja capaz de estabelecer as configurações mínimas para iniciar a comunicação entre os dispositivos. Note que não faremos isso manualmente, e para isso utilizamos as bibliotecas indicadas tanto para o Arduino, quanto para a Labrador.

Utilize o Código 6 para (i) definir o endereço de uso do dispositivo i2c (ii) adicionar um evento de resposta que ser "chamado" quando um dado for enviado ao Arduino (iii) iniciar a comunicação Serial.

void setup(){
Wire.begin(4);
Wire.onReceive(eventoResposta);
Serial.begin(9600);
}
Código 6. Definindo a função de Setup no Arduino

A função onReceive() espera como parâmetro o nome de um evento. Este evento não foi criado ainda. Faremos isso logo mais, ok? Mas vale destacar que o nome eventoResposta poderia ser qualquer outro, desde que respeitasse as mesmas regras para criação do nome de uma função.

O Arduino, além da função setup(), possuí uma segunda função principal que é a função loop(). Esta função é invocada continuamente para que seja possível garantir que o Arduino utilize adequadamente o seu microcontrolador. Nesta aplicação a função loop pode ficar vazia.

Por fim, precisamos criar a função que será "invocada" para responder aos chamados da nossa placa Labrador. Esta função deve ter o mesmo nome que informamos no Código 6 e deve ter como parâmetro uma variável inteira. Veja o Código 7

void eventoResposta(int quantidade){
while(Wire.available()>0){
char caractere = Wire.read();
Serial.print(caractere);
}
}
Código 7. Capturando os caracteres enviados por I2C e exibindo o resultado

Neste trecho de código estamos capturando caractere por caractere que foi enviado pela comunicação I2C, e para cada um deles, armazenamos na variável local chamada caractere. Em seguida, exibimos este caractere. No final do laço de repetição, a mensagem enviada será completamente exibida.

'''Do lado da Labrador...'''

No lado da Labrador escreveremos um código em Python para estabelecer a comunicação entre os dispositivos e enviar uma mensagem importante!

Para estabelecer a comunicação entre os dispositivos é necessário importar a biblioteca da Caninos e em seguida adicionar o dispositivo que desejamos estabelecer a comunicação, utilizando I2C. Veja o Código 8.

import caninos_sdk as k9
labrador = k9.Labrador()

labrador.i2c.add_device("arduino_i2c", 4)

Código 8. Preparando a Labrador para comunicação I2C

A terceira linha de código nos permite adicionar o arduino como um dispositivo I2C e estabelece o endereço de acesso como 4.
Para enviar uma informação para o Arduino, utilize o trecho de Código 9.

resposta = labrador.arduino_i2c.write("dados importantes\n")
print (resposta)

Código 9. Enviando uma mensagem por I2C e recebendo uma mensagem I2C

O Código 9 destaca as duas funções principais implementadas para comunicação I2C. A função write() permite enviar dados para o Arduino. Esta função retorna uma resposta que pode ser exibida para indicar o sucesso do envio dos dados.

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

== Código do experimento ==

'''Labrador'''

#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()

#adicionamos o dispositivo I2C, definindo o endereço 4 de comunicação
labrador.i2c.add_device("arduino_i2c", 4)

#enviamos uma mensagem para o Arduino
resposta = labrador.arduino_i2c.write("dados importantes\n")
#imprimimos a resposta
print (resposta)

'''Arduino'''

//importamos a biblioteca Wire
#include <Wire.h>

//função chamada quando o arduino inicializa
void setup(){
Wire.begin(4); //definimos o endereço de comunicação
Wire.onReceive(eventoResposta); //definimos a função de resposta (evento)
Serial.begin(9600); //iniciamos o serial
}
//deixar vazio, não utilizamos neste exemplo
void loop(){
}
void eventoResposta(int quantidade){ //função informada no setup
while(Wire.available()>0){ //laço de repeetição, enquanto I2C estiver comunicando
char caractere = Wire.read(); //lê dado recebido
Serial.print(caractere); //imprime dado recebido
}
}

Arquivo:Figura 3 guia 5.jpg

2023-08-31T17:55:20Z

Nickdias:

Arquivo:Figura 2 guia 5.jpg

2023-08-31T17:54:45Z

Nickdias:

Guia 5 - Enviando dados da Labrador para o Arduino com I2C

2023-08-31T17:54:22Z

Nickdias: /* Código do experimento */

Guia 5 - Enviando dados da Labrador para o Arduino com I2C

2023-08-31T17:53:06Z

Nickdias:

Guia 5 - Enviando dados da Labrador para o Arduino com I2C

2023-08-31T17:28:37Z

Nickdias:

Guia 4 - Controlando um LED por PWM

2023-08-31T17:23:29Z

Nickdias:

'''Guia 4 - Controlando um LED por PWM'''

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 quarto guia, você aprenderá a controlar um LED com um sinal PWM, para isso, utilize o Guia 4 disponibilizado abaixo:

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

'''Observações gerais'''
*Pré-Requisito: "Guia 2 - Programando um LED com a Labrador"

== Introdução ==

Neste documento você encontra o passo a passo para explorar uma variação para implementação que você fez 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 a solução anterior para que seja possível controlar um LED por meio de um sinal PWM. Este processo permitirá, por exemplo, que alteremos o intervalo de tempo no qual um sinal digital é enviado para nossa GPIO, para que seja possivel reproduzir um comportamento de variação de intensidade do sinal luminoso em nosso LED.

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 PWM na 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.

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

pip3 install -U caninos-sdk
Código 2. Definição de permissões para o uso das GPIOs

'''Componentes necessários'''
*1 Placa Labrador de 32 bits
*1 LED
*1 Resistor de 330 Ω
*2 Cabos MxF

== 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 realizar uma alteração no código de programação do nosso LED para que seja possível controlar a intensidade de sinal que será enviada para nossa GPIO.

O PWM, do inglês Pulse Width Modulation, significa modulação por largura de pulso e consiste em uma técnica utilizada na elaboração de projetos que envolvem sistemas digitais para variar o valor de uma onda, em função de um intervalo de tempo.

Para isso, mantemos a frequência de uma onda quadrada fixa (quão rápido um ciclo completo será percorrido), e alteramos a quantidade de tempo em que um sinal digital ALTO será enviado para nossa GPIO. Veja a Figura 1, ela ilustra dois cenários em que variamos o duty cycle de um sinal digital enviado para uma porta digital.

[[Arquivo:figura_1_guia_4.jpg|thumb|400px|Figura 1. Exemplo de PWM com 25% e 50% de duty cycle]]

No exemplo 1, consideramos um duty cycle de 25%, ou seja, em 25% do tempo de um ciclo, o sinal enviado para a GPIO será um ALTO (HIGH - 5V), enquanto nos outros 75% o sinal será BAIXO (LOW - OV). No segundo exemplo, também na Figura 1, alteramos o duty cycle para 50% e isso faz com que para uma onda de mesma frequência tenhamos um comportamento diferente, pois neste caso, o sinal de ALTO permanecerá ativo durante 50% do ciclo.

Na páticra, o que isso significa? Se tivermos um duty cycle pequeno, o LED ficará "menos acesa"” ou seja, passará a sensação de que a intensidade luminosa será mais fraca. Já para o caso em que o duty cycle for maior, a nossa sensação será de um LED mais brilhoso, pois ele permanecerá mais tempo com sinal de ALTO, e por consequência, nos permitirá enxergar a iluminação por mais tempo.

Desta forma, você deverá:

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.
Em seguida, você deve escrever um código em Python, utilizando a Caninos SDK para que (i) o LED deve acender, inicialmente com 25% de duty_cycle (ii) o LED deve ficar aceso por 2 segundos e então deve apagar (iii) o duty_cycle deve ser incrementado em 25% (iv) o passo ii deve ser repetido até que o duty_cycle atinja 100% e então, o LED deve ficar apagado.

'''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 pelo menos duas vezes!

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

'''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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, vamos habilitar o PWM para controlarmos nosso LED (pelo pin15). Veja o Código 4.

labrador = k9.Labrador()
labrador.pin15.enable_pwm(alias="led1", freq=50, duty_cycle=0.1)

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

Note que de acordo com o Código 4 realizamos duas operações distintas. A primeira, conforme explicado no guia 2, permite acessar as operações básicas da labrador. Já na segunda, definimos que o pin15, associado a esta variável labrador, foi ativado como PWM para uso no programa (por meio da função enable_pwm). Além disso, definimos que a frequência da onda quadrada será de 50 Hz e que o duty_cycle será de 0.1 (ou seja 10%). Por fim, definimos que o apelido desta porta será led1. Este apelido permite que você utilize ele como uma constante, deste ponto em diante do código.

Para que o envio de sinal PWM inicie-se é necessário chamarmos a função start(), conforme destacado no Código 5.

labrador.led1.pwm.start()

Código 5. Iniciando o comportamento PWM para pin15

Caso você deseje interromper o comportamento PWM bastar chamar a função stop() conforme destacado no Código 5.

labrador.led1.pwm.stop()

Código 5. Iniciando o comportamento PWM para pin15

Sabendo disso, você já consegue montar o código necessário para resolver o desafio proposto neste guia!

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

== Montagem do circuito ==

[[Arquivo:figura_2_guia_2.jpg|thumb|400px|Figura 2. Imagem 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 a intensidade deste LED seja alterada de acordo com um sinal PWM enviado para nossa GPIO. A Figura 2 permite identificar a montagem deste circuito e é a mesma representada no Guia 2!

== 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()

#criamos um contador para facilitar percorrer o laço de repetição e variar o duty_cycle
contador_tempo = 1
while contador_tempo <= 4:
#inicializamos o pin15 com o duty_cycle de 25% e a cada iteração variamos ele
labrador.pin15.enable_pwm(alias="led1", freq=100, duty_cycle=0.25*contador_tempo)
labrador.led1.pwm.start()
time.sleep(2)
labrador.led1.pwm.stop()
time.sleep(2)
#incrementamos o contador para variar o duty_cycle e sair do loop ao final do ciclo
contador_tempo = contador_tempo + 1

Arquivo:Figura 2 guia 2.jpeg

2023-08-31T17:22:31Z

Nickdias:

Arquivo:Figura 1 guia 4.jpg

2023-08-31T17:20:55Z

Nickdias:

Guia 4 - Controlando um LED por PWM

2023-08-31T17:20:17Z

Nickdias:

'''Guia 4 - Controlando um LED por PWM'''

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 quarto guia, você aprenderá a controlar um LED com um sinal PWM, para isso, utilize o Guia 4 disponibilizado abaixo:

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

'''Observações gerais'''
*Pré-Requisito: "Guia 2 - Programando um LED com a Labrador"

== Introdução ==

Neste documento você encontra o passo a passo para explorar uma variação para implementação que você fez 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 a solução anterior para que seja possível controlar um LED por meio de um sinal PWM. Este processo permitirá, por exemplo, que alteremos o intervalo de tempo no qual um sinal digital é enviado para nossa GPIO, para que seja possivel reproduzir um comportamento de variação de intensidade do sinal luminoso em nosso LED.

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 PWM na 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.

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

pip3 install -U caninos-sdk
Código 2. Definição de permissões para o uso das GPIOs

'''Componentes necessários'''
*1 Placa Labrador de 32 bits
*1 LED
*1 Resistor de 330 Ω
*2 Cabos MxF

== 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 realizar uma alteração no código de programação do nosso LED para que seja possível controlar a intensidade de sinal que será enviada para nossa GPIO.

O PWM, do inglês Pulse Width Modulation, significa modulação por largura de pulso e consiste em uma técnica utilizada na elaboração de projetos que envolvem sistemas digitais para variar o valor de uma onda, em função de um intervalo de tempo.

Para isso, mantemos a frequência de uma onda quadrada fixa (quão rápido um ciclo completo será percorrido), e alteramos a quantidade de tempo em que um sinal digital ALTO será enviado para nossa GPIO. Veja a Figura 1, ela ilustra dois cenários em que variamos o duty cycle de um sinal digital enviado para uma porta digital.

[[Arquivo:figura_1_guia_4.jpg|thumb|400px|Figura 1. Exemplo de PWM com 25% e 50% de duty cycle]]

No exemplo 1, consideramos um duty cycle de 25%, ou seja, em 25% do tempo de um ciclo, o sinal enviado para a GPIO será um ALTO (HIGH - 5V), enquanto nos outros 75% o sinal será BAIXO (LOW - OV). No segundo exemplo, também na Figura 1, alteramos o duty cycle para 50% e isso faz com que para uma onda de mesma frequência tenhamos um comportamento diferente, pois neste caso, o sinal de ALTO permanecerá ativo durante 50% do ciclo.

Na páticra, o que isso significa? Se tivermos um duty cycle pequeno, o LED ficará "menos acesa"” ou seja, passará a sensação de que a intensidade luminosa será mais fraca. Já para o caso em que o duty cycle for maior, a nossa sensação será de um LED mais brilhoso, pois ele permanecerá mais tempo com sinal de ALTO, e por consequência, nos permitirá enxergar a iluminação por mais tempo.

Desta forma, você deverá:

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.
Em seguida, você deve escrever um código em Python, utilizando a Caninos SDK para que (i) o LED deve acender, inicialmente com 25% de duty_cycle (ii) o LED deve ficar aceso por 2 segundos e então deve apagar (iii) o duty_cycle deve ser incrementado em 25% (iv) o passo ii deve ser repetido até que o duty_cycle atinja 100% e então, o LED deve ficar apagado.

'''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 pelo menos duas vezes!

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

'''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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

Após isso, precisamos criar uma variável para acessar os recursos da placa Labrador e em seguida, vamos habilitar o PWM para controlarmos nosso LED (pelo pin15). Veja o Código 4.

labrador = k9.Labrador()
labrador.pin15.enable_pwm(alias="led1", freq=50, duty_cycle=0.1)

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

Note que de acordo com o Código 4 realizamos duas operações distintas. A primeira, conforme explicado no guia 2, permite acessar as operações básicas da labrador. Já na segunda, definimos que o pin15, associado a esta variável labrador, foi ativado como PWM para uso no programa (por meio da função enable_pwm). Além disso, definimos que a frequência da onda quadrada será de 50 Hz e que o duty_cycle será de 0.1 (ou seja 10%). Por fim, definimos que o apelido desta porta será led1. Este apelido permite que você utilize ele como uma constante, deste ponto em diante do código.

Para que o envio de sinal PWM inicie-se é necessário chamarmos a função start(), conforme destacado no Código 5.

labrador.led1.pwm.start()

Código 5. Iniciando o comportamento PWM para pin15

Caso você deseje interromper o comportamento PWM bastar chamar a função stop() conforme destacado no Código 5.

labrador.led1.pwm.stop()

Código 5. Iniciando o comportamento PWM para pin15

Sabendo disso, você já consegue montar o código necessário para resolver o desafio proposto neste guia!

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

== Montagem do circuito ==

[[Arquivo:figura_2_guia_2|thumb|400px|Figura 2. Imagem 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 a intensidade deste LED seja alterada de acordo com um sinal PWM enviado para nossa GPIO. A Figura 2 permite identificar a montagem deste circuito e é a mesma representada no Guia 2!

== 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()

#criamos um contador para facilitar percorrer o laço de repetição e variar o duty_cycle
contador_tempo = 1
while contador_tempo <= 4:
#inicializamos o pin15 com o duty_cycle de 25% e a cada iteração variamos ele
labrador.pin15.enable_pwm(alias="led1", freq=100, duty_cycle=0.25*contador_tempo)
labrador.led1.pwm.start()
time.sleep(2)
labrador.led1.pwm.stop()
time.sleep(2)
#incrementamos o contador para variar o duty_cycle e sair do loop ao final do ciclo
contador_tempo = contador_tempo + 1

Arquivo:Figura 2 guia 3.jpg

2023-08-31T17:01:22Z

Nickdias:

Guia 3 - Controlando um LED com um botão

2023-08-31T17:00:53Z

Nickdias:

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

Guia 3 - Controlando um LED com um botão

2023-08-31T16:55:55Z

Nickdias:

Guia 3 - Controlando um LED com um botão

2023-08-31T16:53:57Z

Nickdias:

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

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 (

Arquivo:Figura 3 guia 2.jpg

2023-08-31T16:51:51Z

Nickdias:

Guia 2 - Programando um LED com a Labrador

2023-08-31T16:51:31Z

Nickdias: /* Montagem do Circuito */

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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)]]

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 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)]]

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)

Arquivo:Figura 2 guia 2.jpg

2023-08-31T16:48:14Z

Nickdias:

Guia 2 - Programando um LED com a Labrador

2023-08-31T16:47:45Z

Nickdias: /* Montagem do Circuito */

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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)]]

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

Figura 3. Imagem do Circuito

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 2 - Programando um LED com a Labrador

2023-08-31T16:38:28Z

Nickdias: /* Montagem do Circuito */

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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

== Montagem do Circuito ==

[[Arquivo:figura_2_guia_2.png|thumb|300px|(Figura 2)]]

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

Figura 3. Imagem do Circuito

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)

Arquivo:Figura 1 guia 2.png

2023-08-31T16:32:44Z

Nickdias:

Guia 2 - Programando um LED com a Labrador

2023-08-31T16:32:15Z

Nickdias:

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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

== Montagem do Circuito ==

Figura 2. Imagem 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 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.

Figura 3. Imagem do Circuito

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 1 - Preparando o Ambiente de Desenvolvimento

2023-08-31T16:27:12Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

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

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-31T16:21:50Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

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

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-31T16:20:37Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

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

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-31T16:19:05Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

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

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 2 - Programando um LED com a Labrador

2023-08-31T16:17:11Z

Nickdias:

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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

== Montagem do Circuito ==

Figura 2. Imagem 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 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.

Figura 3. Imagem do Circuito

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 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T19:43:56Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

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

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T19:42:49Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 2 - Programando um LED com a Labrador

2023-08-30T19:41:10Z

Nickdias:

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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

== Montagem do Circuito ==

Figura 2. Imagem 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 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.

Figura 3. Imagem do Circuito

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 2 - Programando um LED com a Labrador

2023-08-30T19:36:32Z

Nickdias:

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

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

pip3 install -U caninos-sdk

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

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

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

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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 (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.
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!

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 timer para garantir as pausas de acordo com o enunciado (ver Código 3).

import caninos_sdk as k9
import time

Código 3. Importando as bibliotecas necessárias

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.

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

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

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.

labrador.led_status.high()

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

labrador.led_status.low()

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

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.

time.sleep(0.5)

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

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

== Montagem do Circuito ==

Figura 2. Imagem 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 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.

Figura 3. Imagem do Circuito

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 2 - Programando um LED com a Labrador

2023-08-30T19:28:03Z

Nickdias:

'''Guia 2 - 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 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: "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.

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

pip3 install -U caninos-sdk

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

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

Guia 2 - Programando um LED com a Labrador

2023-08-30T19:26:59Z

Nickdias:

'''Guia 2 - 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 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: "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.

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

pip3 install -U caninos-sdk

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

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

Arquivo:Figura 1 guia 1.png

2023-08-30T19:04:51Z

Nickdias:

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T19:03:17Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T18:48:54Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T18:42:11Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-30T18:28:36Z

Nickdias:

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-23T19:20:11Z

Nickdias:

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

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''

*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-23T19:19:33Z

Nickdias:

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

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''
*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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

Guia 1 - Preparando o Ambiente de Desenvolvimento

2023-08-23T19:18:50Z

Nickdias:

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

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

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

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

sudo apt install python3-dev python3-pip python3-setuptools libffi-dev libssl-dev curl
(Código 2. Instalando as dependências do Python (incluindo 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.

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

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

pip install gpiod
pip install caninos-sdk
(Código 4. Instalando a ferramenta para codificação IDLE3)

'''Etapa 5. Instalando IDLE'''
*Por fim, rode o trecho de Código 5 para instalar nossa ferramenta de edição de código (IDLE) e execute o Código 6 para abrir a ferramenta IDLE3

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

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