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:
- Computação Física – Scratch for Arduino (Scratch 1.0)
- Computação Física – Scratch for Raspberry Pi (Scratch 1.4)
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
mjrobot.org 