Computação Física – Scratch 2.0 para Raspberry Pi

4 04UTC julho 04UTC 2018 — Deixe um comentário

Este é um dos meus quatro tutoriais com foco em Scratch e “Physical Computing”. Em relação a esse tópico, já publiquei aqui em meu blog:

Aprendendo eletrônica com o Arduino e a linguagem Scratch 2.0

Existem mais dois tutoriais em ingles, (um para o Arduino e outro para o Raspberry), onde exploro a versão 1 do Scratch:

Aqui, exploraremos projetos usando a versão mais recente do Scratch disponível para o Raspberry Pi, a 2.0.

Em resumo,

Aprenderemos:

  • O que é o Scratch 2.0 e suas diferenças com o Scratch 1.4
  • Como interagir com LEDs, botões de pressão e campainha
  • Como criar blocos especiais
  • Como lidar com variáveis
  • Como integrar animações com o mundo físico.

Vamos lá!

1. Lista de materiais – BoM

Para as experiências neste tutorial, você precisará de pelo menos,  os seguintes componentes:

  • Raspberry Pi (V2 ou V3)
  • LEDs (vermelho, amarelo e verde)
  • 1 botão de pressão
  • 1 campainha (“Active Buzzer”)
  • Resistores: 3 x 220 ohms
  • Cabos
  • BreadBoard do tipo “Full”

2. O Scratch 2.0

Como sabemos, o Scratch é uma ótima ferramenta para ensinar a iniciantes como codificar, mas antes de iniciar nosso tutorial, eu realmente recomendo que você se familiarize com a linguagem Scratch 2.0, seguindo alguns tutoriais básicos. Isto o ajudará a entender melhor como usar um Raspberry Pi no mundo da Computação Física.

Existem 2 maneiras de fazer isso:

Uma versão offline do Scratch 2 é fornecida com o sistema operacional Raspbian, com recursos que o ajudarão a criar uma codificação bem profissional.

Abrindo o programa:

Quando você estiver na área de trabalho do Pixel, vá para o menu de aplicativos do canto superior esquerdo (icono com o “logotipo do Raspberry Pi”) e abra-o. Você encontrará uma das opções: “ Programação ”.

  • Abra e clique em “ Scratch 2 ” (note que a versão antiga do Scratch 1.4 (chamada “ Scratch ”) também está lá.
  • Depois de abrir o programa Scratch, você verá a tela mostrada acima.
  • Clique em ” Mais Blocos “
  • Clique em ” Adicionar uma extensão “. A opção “Pi GPIO” Library estará disponível. Selecione e clique em [ OK ]
  • A biblioteca do PI GPIO será instalada e o “led verde” mostrará que a mesma está sendo executado corretamente.
  • 2 blocos estarão agora disponíveis para serem usados ​​com seus programas de Computação Física.

O primeiro bloco:

set gpio  to [output high]

possue 3 parâmetros possíveis:

  • saída alta
  • saída baixa
  • entrada

O segundo bloco:

gpio <GPIO number> is high?

retornará:

  • “True ” ou “ False ” dependendo do nível digital do GPIO (“True = 1” e “False = 0”).

O Scratch 2.0 disponibiliza a criação de blocos personalizados, permitindo assim que o código seja encapsulado e usado (possivelmente várias vezes) em um projeto. Vamos ver como fazer isso nos exemplos. Isto se chama em programação uma “função”.

3. A numeração de pinos do GPIO

Nós não vamos cobrir aqui como preparar e inicializar o Raspberry Pi, mas se você precisar de alguma ajuda, por favor consulte este link: Instalando o Raspbian com o NOOBS.

Nosso Raspberry Pi estará executado uma versão do Raspbian como Sistema Operacional, tendo o PIXEL como seu desktop (GUI).

Uma vez que iremos interagir com o mundo físico, é bom lembrar que nossa porta de entrada para ele será o conector GPIO do Raspberry Pi. A foto acima mostra o conector, onde desenhei alguns componentes ficcionais em vermelho e abaixo sua representação gráfica:

Numeração dos pinos

É importante mencionar que usaremos a numeração de pinos “Broadcom” (BCM) para os pinos GPIO, ao contrário da numeração física (BOARD). Qualquer pino marcado “GPIO” (em amarelo) no diagrama acima pode ser usado levando-se em conta seu “número” de pino. Por exemplo, se um LED estiver conectado a “GPIO13” (pino físico 33), você deve especificar o número do pino como 13 e não como “33”.

4. Piscando um LED

É hora do “Hello World” da Computação Física, o “piscar um LED”!

Comecemos conectando um LED ao GPIO 13 de nosso Raspberry Pi (RPi, abreviado).

Para começar, arraste 2 novos blocos do tipo “set gpio” para a ÁREA DE SCRIPTS,

set gpiot <13> to [output high]
set gpio <13> to [output low]

Clicando nesses blocos você irá “ligar” ou “desligar” o LED

Agora, criemos um código real do tipo “blink” usando o Scratch 2.

  • Comece seu programa quando a “Bandeira Verde” for clicada, para isso você precisará do bloco:
  • When “bandeira verde” clicked (é o primeiro bloco no “menu Evento” – em marrom)
  • Arraste o bloco de loop ” Forever ” (você vai encontrá-lo no “menu de controle” – em amarelo)
  • Dentro do loop Forever, coloque os blocos que você testou anteriormente.
  • Executando seu código verá que nada acontece, ou melhor, o LED será ligado e desligado tão rapidamente que você não o perceberá. Então, você deve adicionar algum “atraso”, digamos 1 segundo após cada bloco.

E é isso!

A imagem acima mostrará o programa final e abaixo um vídeo com nosso LED piscando:

5. Usando Blocos Personalizados – Múltiplos LEDs Piscando

Agora, que sabemos como controlar um LED, instalemos 2 mais, porém com cores diferentes (como um semáforo):

  • VERMELHO
  • AMARELO
  • VERDE

Repita o que você fez anteriormente, conectando os LEDs como mostrado acima:

  • RED ==> GPIO 13
  • AMARELO ==> GPIO 19
  • VERDE ==> GPIO 26

Suponha que agora queremos que os 3 LEDs pisquem independentemente em freqüências diferentes. A primeira coisa que você pode fazer é copiar o conjunto de blocos desenvolvido no último capítulo, alterando o número do GPIO e os atrasos para cada um dos blocos, digamos:

  • Blink Block para GPIO 13 ==> delay: 1 segundo
  • Blink Block para GPIO 19 ==> delay: 2 segundos
  • Blink Block para GPIO 26 ==> delay: 4 segundos

Isto funcionaria bem, mas aproveitemos a oportunidade para introduzir um novo recurso do Scratch 2, o “Custom Blocks” (“ou “funções”).

Primeiramente, criaremos um bloco personalizado, chamado “setup”, que será usado para desligar todos os LEDs.

  • Vá para o menu “Mais Blocos”
  • Selecione “Fazer um bloco”
  • Digite o nome “setup” e clique em OK

Você verá que um novo bloco aparecerá “ define [ setup ] ”, abaixo dele, podemos adicionar 3 blocos configurando os GPIOs para LOW como mostrado na tela de impressão acima. Agora, este bloco personalizado “setup” (que é, na verdade, uma “função”), poderá ser chamado a qualquer momento durante a execução do programa. Vamos chamá-lo no início, sob a bandeira verde, assim sempre que o programa for executado, garantiremos que os LEDs iniciarão sempre DESLIGADOS.

Agora, criaremos um bloco personalizado mais elaborado. Vamos criar um tipo que pode receber parâmetros permitindo uma maior generalização e reutilização de blocos de código. A ideia é criar um “Blink block” genérico, onde os parâmetros serão o número do GPIO e o tempo de “piscagem”. Nosso bloco final será como:

blink <GPIO> <time>

Faça o seguinte:

  • Vá para o menu “Mais Blocos”
  • Selecione “Fazer um bloco”
  • Digite o nome “Blink” e clique no submenu “Opções”
  • Clique na primeira opção: “Adicionar entrada numérica” e digite “GPIO”
  • Clique novamente na mesma opção e digite “time”
  • Digite OK

Agora, um novo bloco aparecerá:

define [Blink] [GPIO] [time]

Sob esse bloco, adicionaremos os blocos que usamos para fazer o LED piscar, mas, em vez de valores específicos para o GPIO ou tempo de delay, adicionaremos os parâmetros genéricos e “azuis”: “GPIO” e “time”

Agora, se queremos piscar os LEDs, é suficiente usar blocos como estes:

Blink <13> <1>
Blink <16> <2>
Blink <26> <4>

O código para este exemplo está aqui: blink_V2.sb2

6. Apresentando um botão de pressão e variáveis

Programar um botão com o Raspberry Pi e o Scratch 2 é uma tarefa bem simples. Para isso, vamos implementar uma “lógica direta”:

  • Se o botão for pressionado (fechado)             ==> GPIO = “1“  (3.3V)
  • Se o botão não estiver pressionado (aberto) ==> GPIO = “0”  (0V)

Conectemos o botão como mostrado no diagrama acima.

AVISO: você deve utilizar a saída de 3,3V (número de pino físico # 1). O RPi não suporta 5V em seus GPIOs

Para ler nosso botão de pressão, criaremos uma nova variavel chamada “button” (“botão”), a qual será associada ao seu estado corrente:

  • Se o botão for pressionado ==> “button = ON”
  • Se o botão de pressão NÃO FOR PRESSIONADO ==> “botton = OFF”

Os blocos para isso serão:

if <20> is high?> then
    set[button] to 
else
    set[button] to 

Incluiremos esses blocos em um “novo bloco” que chamaremos de “gpioStatus” e a propósito, faremos o mesmo para os LEDs, criando variáveis ​​associadas a cada um deles:

  • vermelho
  • amarelo
  • verde

E associaremos valores a essas variáveis, agindo de acordo com o GPIO correspondente:

  • Se o LED vermelho estiver ligado ==> variável “red = ligado” ==> GPIO 13 ==> “alto”
  • Se o LED amarelo estiver ligado ==> variável “yellow = ligado” ==> GPIO 19 ==> “alto”
  • Se o LED verde estiver ligado ==> variável “green = ligado” ==> GPIO 26 ==> “alto”

E, claro, o oposto para os LEDs apagados.

Toda a lógica acima também deve ser incluída na função “gpioStatus”, que estará em execução durante todo o tempo. Então, não precisaremos mais nos preocupar com os GPIOs. Em vez disso, usaremos as variáveis ​​para construir nossa lógica de programa.

Por exemplo, criemos um programa que:

  • Execute os LEDs em uma seqüência fixa em uma determinada freqüência como um semáforo normal:
  • VERMELHO
  • AMARELO
  • VERDE

E assim por diante. Se um botão é pressionado, a frequência é alterada, digamos, cerca de 3 vezes mais rápido.

A primeira coisa a fazer é criar uma nova variável, chamada “time”, que terá um valor, digamos:

  • 1 segundo se a variável “button” estiver em OFF e
  • 0,3 segundos se “button” estiver ON.

Como você pode ver, na verdade estamos controlando o valor do tempo atuando em um botão físico, mas aqui apenas as “variáveis” são usadas.

Podemos fazer o mesmo para a sequência de LEDs. Configuremos as variáveis red (​​vermelho), yellow (amarelo) e green (verde), ON ou OFF, mantendo-as ON utilizando agora da variável “time”. A tela de impressão acima mostra como ficará o programa.

O vídeo abaixo lhe dará uma ideia real sobre o que está acontecendo:

Aqui o código usado no exemplo: 3LED_button_V2.db2

7. “Vamos animar a festa”!

Uma das grandes características do Scratch é a animação. Incluiremos algumas animações muito simples em nossos projetos para começar.

Mudemos o último projeto um pouquinho. Agora, os semáforos realizarão sua seqüência somente quando o botão for pressionado. Se não for pressionado, todas as luzes devem ficar apagadas. O código é muito simples. Tente fazer isso antes de ver a minha solução.

OK, agora tornemos as coisas mais interessantes. Criaremos um novo sprite, um “Botão Azul” (eu o deixei com seu nome padrão, sprite 1. Você pode mudá-lo). Este Sprite  terá 2 trajes possíveis:

  • botão OFF
  • botão ON

Eu utilizei o editor interno do Scratch para criar os figurinos (ou trajes). Vamos querer que este sprite apareça sempre com o seu traje “button OFF” se o botão estiver solto (variável = OFF) e claro, com o traje “button ON” se o botão for pressionado.

Criemos um bloco que deverá “ficar rodando” o tempo todo (como uma rotina de fundo).

Agora criemos um semáforo que mostrará o status do LED. Podemos fazer isso criando um novo Sprite, ou criando novos cenários. Vamos utilizar a segunda opção, assim você poderá ver dois exemplos diferentes de criação de animação aqui (animando o sprite e o cenário).

Com o editor interno, criei 3 círculos vazios, que eu chamei de “OFF”. Copiando e colando este cenário 3 vezes, preenchi em cada um deles, um dos círculos com uma das cores dos LEDs (Vermelho, Amarelo e Verde) nesta sequência. Eu os nomeio (SURPRESA!): RED, YELLOW e GREEN (VERMELHO, AMARELO e VERDE).

Então, na aba Script do Backdrop eu incluí um pedaço de código que irá rodar para sempre, mudando o pano de fundo de acordo com as variáveis ​​do LED (veja acima). Muito simples e direto.

E é isso! Como você pode ver, o projeto final apesar de complexo, é um grupo de várias partes simples, o que também o torna muito simples de entender.

NOTA: O segredo aqui é ser ORGANIZADO com o código.

Abaixo um vídeo com nosso projeto e animação em execução:

O código pode ser baixado aqui: Traffic Lights V2.sb2

8. É hora do show!

Nesta última parte, nos divertiremos criando animações simples e misturando-as com coisas físicas, fazendo um projeto mais elaborado.

Antes de entrarmos na parte de animação, ompletemos o HW. Este projeto será um semáforo para pedestres e, portanto, incluiremos uma Campainha a qual produzirá um som (“Bip”), durante o tempo permitido para que os pedestres atravessarem uma rua. A campainha será instalada no GPIO 16. Como fizemos antes, para simplificar as coisas, criaremos uma nova variável “beep” que ativará o GPIO 16 High ou Low. A lógica será incluída no gpioStatus, o mesmo que fizemos para os LEDs.

Levemos nosso pequeno amigo, o MJRoBot, para conhecer Londres, o berço do Raspberry Pi!

Para começar, devemos definir a especificação geral relativa ao nosso projeto:

  • Nosso amiguinho iniciará sua jornada por Londres, movendo-se da direita para esquerda, percorrendo toda a área do palco.
  • Quando ele toca na borda esquerda do Palco, devemos mudar para o próximo pano de fundo de Londres.
  • Quando ele chega a Abbey Road, ele deve parar porque há um cruzamento para pedestres lá (Sim! o famoso cruzamento da capa do disco dos Beatles de 70!)
  • Suponha que foi instalado lá um semáforo de pedestres para proteger os turistas. O robozinho nos pedirá ajuda para que apertemos o botão físico para ele, então ele poderá atravessar a rua, como Paul, John, George e Ringo o fizeram anos atrás), mas em uma direção oposta 😉

Vamos desta vez criar dois novos sprites:

  • Um semáforo (em frente ao uso de vários cenários) com 3 fantasias (vermelho, amarelo e verde)
  • O pequeno robô, o MJRoBot que tem dois trajes para ajudá-lo a andar (ou algo que se assemelhe a andar). 😉

Nós teremos 4 cenários. 3 para Londres e o mais importante: Abbey Road.

É isso aí!

Tente codificá-lo sozinho e só depois, compare sua solução com a minha! Existem várias maneiras diferentes de fazer isso.

Aproveite!

Um rápido vídeo sobre o trabalho final do projeto:

Minha solução de código aqui: MJRoBot em torno de Londres V1.sb2

9. Conclusão

Como sempre, espero que este projeto possa ajudar a outros a encontrar seu caminho no excitante mundo da eletrônica, robótica e IoT!

Por favor, visite meu GitHub para arquivos atualizados: Scratch 2.0 – Raspberry Pi .

Para mais projetos, visite meu blog: MJRoBot.org

Saludos desde el sur del mundo!

Vejo vocês em meu próximo projeto!

Obrigado,

Marcelo

Anúncios

Nenhum Comentário

Seja o primeiro a iniciar uma conversa!

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s