Guia 2 - Programando um LED com a Labrador

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:

Guia 2

Apps e Bibliotecas Necessárias:

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

Introdução

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

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

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

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

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

Preparando o Ambiente de Desenvolvimento".

Ao final deste experimento você será capaz de:

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

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

Observação 1

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

reiniciar a sua placa.

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

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

Observação 2

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

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

 pip3 install -U caninos-sdk

Componentes necessários

• 1 Placa Labrador de 32 bits
• 1 LED
• 1 Resistor de pelo menos 330 Ω (no exemplo utilizamos 1kΩ)
• 2 Cabos MxF

Descrição do experimento

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

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

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

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

Desta forma, você deverá:

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

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

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

segundo e então o LED apague.

Discutindo a montagem do circuito

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

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

(Figura 1. GPIOs disponíveis na placa labrador)

Se aprofundando um pouco mais…

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

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

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

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

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

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

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

Discutindo a montagem do programa

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

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

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

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

            import caninos_sdk as k9
            import time

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

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

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

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

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

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

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

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

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

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

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

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

            labrador.led_status.high()

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

            labrador.led_status.low()

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

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

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

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

            time.sleep(0.5)

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

Montagem do Circuito

(Figura 2. Conexão dos pinos na Labrador)

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

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

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

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

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

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

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

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

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

(Figura 3. Conexão dos pinos da Labrador na Protoboard)

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

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

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

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

extremidade do nosso led.

Código do Experimento

              #importamos as bibliotecas necessárias para utilizarmos a labrador
              import caninos_sdk as k9
              #esta biblioteca permite gerar uma pausa na labrador (um delay)
              import time

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

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

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

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

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

>>>>>>>>>>>Guia 3 - Controlando um led com um botão