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

12 12UTC agosto 12UTC 2017 — 1 Comentário

Electronic Playground With Arduino and Scratch 2

Este é o meu quarto tutorial procurando integrar o aprendizado da eletrônica com a linguagem SCRATCH e o primeiro que publico em português.

Anteriormente, já havia publicado, tanto no site do Instructables.com, quanto no Hackster.io:

  1. Physical Computing – Scratch 2.0 for Raspberry Pi
  2. Physical Computing – Scratch for Raspberry Pi   (Scratch V.1.4)
  3. Physical Computing – Scratch for Arduino   (S4A / Scratch V1.4)

Neste novo tutorial, desenvolveremos novos projetos e idéias integrando o Scratch 2.0 com o Arduino, verdadeiros “campeões” quando se fala sobre o ensino de eletrônica e programacão para crianças, educadores e iniciantes.

Existem poucas iniciativas disponíveis na web abrangendo Scratch 2 para Arduinos, sendo mais conhecidas as que foram desenvolvidas com foco em kits suportados oficialmente pelo site do Scratch, tais como Lego WeDo, PicoBoard, ou o alternativo editor mBlock , etc.

Como uma opção pessoal e para não ficar amarrado a nenhum fabricante ou solução proprietária, escrevi este tutorial com base no “s2aio“, uma extensão de hardware gratuita e aberta, criada por MrYsLab,  para ser utilizada com o o editor offline do Scratch 2.0.

Obrigado, Alan Yorinks, criador do MrYsLab por esta grande iniciativa!

Legal! Neste tutorial, aprenderemos como utilizar o Scratch 2.0 na programação de um ARDUINO de maneira a que possamos interagir com o mundo físico!

Em suma, aprenderemos como:

  • Ler entradas digitais tais como botões e sensores de movimento
  • Ler sensores analógicos como LDR (para medir luz) e temperatura
  • Gerar saídas digitais, ligando e desligando LEDs
  • Atuar em dispositivos analógicos controlando, por exemplo, o brilho de um LED usando-se de técnicas de modulação de pulso (PWM)
  • Gerar tons musicais utilizando-se de uma campainha (buzzer)
  • Controlar um servo motor
  • Medir distâncias com um sensor de ultra-som (como os morcegos)
  • Construir um “Playground eletrônico virtual” para interagir com dispositivos reais
  • Misturar animação com dispositivos do mundo real
  • Construir um radar

O diagrama acima mostra todos os sensores e atuadores conectados ao nosso Arduino. Mas não se preocupe, iremos passo a passo em cada componente.

Neste vídeo você poderá ver um radar de verdade desenvolvido a partir do Scratch 2 e do Arduino. Desenvolveremos este projeto juntos ao longo deste tutorial:

Beleza! Mãos a obra galera!

1: Lista de materiais (BoM)

Bill of Material (BoM)
  1. Arduino UNO
  2. LEDs (vermelho e azul)
  3. 1 Push-Button
  4. 1 LDR
  5. 1 LM35 – Sensor de Temperature
  6. 1 HC-SR501 – Passive infrared sensor (PIR)
  7. Resistors: 2x 10Kohm and 1x 220 ohm
  8. Buzzer
  9. 1 HC-SR04 Ultrasonic Sensor
  10. 180 Degrees 9G Micro Servo
  11. Cabos
  12. Breadboard

2: O Scratch 2.0

The Scratch 2.0
Como sabemos, o Scratch é uma ótima ferramenta para ensinar a iniciantes em computação, a como codificar seus programas, mas antes de começar a brincar com Arduinos e componentes eletrônicos, recomendo que você se familiarize com a linguagem Scratch 2.0, fazendo alguns tutoriais básicos disponíveis no site oficial do Scratch .

Outra dica legal é acompanhar o curso de programação Scratch do Code IOT, oferecido pela Samsung em parceria com o Laboratório de Sistemas Integráveis Tecnológico (LSI-TEC)

Isto ajudará você a entender melhor a como usar um Arduino na “Computação Física”.

Se você trabalhou com o S4A, baseado no Scratch versão 1.4, você já deverá estar familiarizado com o básico da linguagem, mas a versão 2.0 possui novos recursos, que aprimorarão e simplificarão nossos projetos, tais como:

  • Clones (para serem usados em conjunto com os atores (Sprites)
  • Blocos personalizados (muito útil para escrever “funções”)
  • Seção “Mais Blocos”: Onde encontraremos os blocos especiais para controlar os pinos do Arduino.
  • Editor vetorial para Sprites e Panos de fundo (Backdrops)
  • Editor de som
  • Bloco “Nome do pano de fundo”, etc.

Para usar o s2aio, necessitaremos do Editor Offline para Scratch 2, acesse o link e siga as instruções, instalando-o em sua área de trabalho. Além disso, baixe o Get Starting Guide for Scratch 2.0, assim voce irá se familiarizando com o editor.

Este tutorial foi escrito utilizando-se do editor em inglês, mas vários idiomas estão disponíveis. O editor possue um icone em forma de “globinho”, ao lado do logo do SCRATCH (canto superior esquerdo), onde você poderá selecionar o idioma de sua preferencia. Se o português for selecionado, automaticamente todos os blocos passarão a este idioma.

3: Instalando o S2aio

Installing S2aio

Instalando o Python 3.5 (ou superior)

O s2aio necessita que você tenha uma versão do Python 3.5 (ou superior) instalado em seu computador, para que o editor offline possa trabalhar com o Arduino. Caso voce não o tenha, por favor vá ao site oficial da linguagem Python e siga as instuções de instalação do compilador adequado ao seu sistema operacional (MacOS, Windows ou Linux).

Instalando o FirmataPlus

Ao usar o s2aio, seu Arduino precisará executar o FirmataPlus, que é uma versão aprimorada personalizada do StandardFirmata, o qual oferecerá suporte para:

  • HC-SR04 (sonar para medida de distância)
  • Codificador rotatório (Rotary Encoder)
  • Stepper Motor
  • Geracão de tons sonoros (“Piezo tone generation”).

Você poderá fazer o download do FirmataPlus diretamente do link: MrYsLab GitHub.

Siga o procedimento normal para instalar esta biblioteca ao seu IDE para o Arduino. Uma vez instalado, vá em Exemplos / FirmataPlus / FirmataPlus em seu IDE e abra-o.

Instalando o s2aio

Agora é hora da instalação do s2aio. Siga as instruções abaixo com cuidado.

Certifique-se de ter uma conexão com a internet.

O comando abaixo irá instalar o s2aio e todas as bibliotecas necessárias em seu computador:

Para usuários do Windows, abra uma janela de comando e digite:

pip install s2aio

Para usuários de Linux e Mac, abra uma janela de Terminal e digite:

sudo pip3 install s2aio

Note que vários arquivos do tipo “Base Scratch files”, serão instalados sob o diretório: s2aio-master:

/s2aio-master/s2aio/ScratchFiles/ScratchProjects

Para Inglês, por exemplo, você deve abrir:

s2aio_base.sb2

Observe que existe um arquivo “base” para cada idioma suportado. Para português o arquivo base que voce deverá abrir será:

s2aio_base_PT.sb2

Uma vez aberto, vá para a seção “Mais blocos”. Você perceberá que agora existem vários novos “blocos negros”, os quais usaremos para controlar os pinos do Arduino.

coco

Note que provavelmente você verá um LED vermelho logo acima desses novos blocos. Isso significa que o Arduino não está conectado ao editor Scratch e que você deverá executar o s2aio primeiro.

Executando o s2aio

Um arquivo executável será instalado automáticamante em seu computador, para uma fácil inicialização. Abra uma janela em seu terminal (no caso do Mac) ou uma janela de comando para o Windows e digite:

s2aio

Em meu caso (Mac), criei um “arquivo tipo batch” o qual chamo através de um ícone em minha área de trabalho. Assim, não preciso abrir uma janela do Terminal em todo o momento que queira executar o s2aio.

As etapas abaixo são opcionais e explicam como criei este batch:

Criando um arquivo do tipo batch para o Mac OS:

Acesse um editor de texto (por exemplo o nano)

Note que tenho o diretório: s2aio-master instalado segundo o caminho:  /documents/Scratch2_Arduino

#!/bin/bash
# call s2aio from desktop
cd .. /documents;
cd Scratch2_Arduino;
cd s2aio-master;
s2aio;
exit;

Defina um nome para o arquivo (por ex.: s2aio_connect), salve o arquivo e o transforme em executável:

chmod +x ~/Desktop/s2aio_connect

Caso queira que este arquivo batch (script) seja executado por um click de mouse, adicione ‘.command’ ao final de seu nome:

Por ex.: s2aio_connect.command

Eu também incluí um ícone com o logo do s2aio (não oficial) para facilitar a localização do arquivo em minha área de trabalho (veja no canto superior esquerdo do Print-Screen acima).

Uma vez que o s2aio esteja funcionando, você perceberá que o LED na seção “Mais Blocos” estará agora, verde.

Em suma, para iniciar um novo projeto Scratch 2 usando s2aio, siga sempre a seqüência:

  • Conecte a placa Arduino ao seu computador via USB
  • Abra o IDE Arduino e faça o upload do FirmataPlus em sua placa
  • Abra um dos projetos base (inglês ou português) ou um que você já tenha salvado anteriormente (abrir o editor offline do Scratch2 original não funciona com as extenções)
  • Execute s2aio através do Terminal ou pelo arquivo em batch.

É isso aí! O print-screen acima mostra como ficou minha area de trabalho no Mac.

4: Piscando um LED

Blinking a LED

Começemos por conectar um LED ao pino 13 de nosso Arduino UNO.

Ao entrar no menu “Mais Blocos” do editor, você encontrará os blocos especiais projetados para o Arduino. Nós usaremos 2 deles para criar nossa função de piscar um LED (Blink).

A primeira coisa a fazer é informar ao Arduino que um pino digital específico (em nosso caso será o 13) deverá ser artivado [Enable] (Ativar) e deve funcionar como [output] (saída). Arraste este bloco para a área de codificar (Script Area).

[Enable] Digital Pin ( ) for [output]

Observe que no mesmo bloco você pode selecionar [Enable] ou [Desable], o número do pino digital a ser usado e se este pino será uma saída, entrada, PWM, Servo, Tom ou SONAR

Apenas clicando neste bloco, já estaremos habilitando o pino 13 como uma saída. Agora

Agora arraste 2 dos blocos do tipo “DigitalWrite”, para a area de Scripts:

DigitalWrite Set Pin ( ) to [1]

Observe que no mesmo bloco você pode inserir o número do pino digital a ser utilizado e se este pino se configurará como [1] ou [0].

Se você clicar em cada um  dos blocos individualmente, você poderá ligar ou desligar o LED, tente fazê-lo.

Agora, criaremos um verdadeiro código para piscar nosso LED permanentemente com o Scratch 2, seguindo os passos abaixo:

  1. Comece seu programa quando a “Bandeira Verde” for clicada, para isso você precisará do bloco:
    • Quando a “bandeira verde” clicou (é o primeiro bloco do menu Controle – Amarelo)
  2. Arraste o bloco de loop “Forever” (repete para sempre)
  3. Dentro do loop Forever, coloque os blocos que você testou anteriormente.
  4. Se você executar o seu código, verá que nada acontece, ou melhor, o LED será LIGADO e DESLIGADO tão rapidamente que você não vai nem perceber. Para corrigir isso, necessitaremos de uma pequena espera entre os comandos:
    • Você deve atrasar, digamos 1 segundo após cada bloco.

E pronto! Abaixo você pode ver como fica o programa completo:

Ou se estiver utilizando o programa base em português:

coco

A captura de tela abaixo mostra o programa final e como eu iniciei o s2aio, utilizando o Terminal.

blink_Screen.png

No link abaixo você poderá fazer o download do  programa acima:

Arduino_blink.sb2

Tente algumas variacões no programa. Explore!

5: O Playground eletrônico

The Electronic Playground

A partir de agora, criaremos um por um, Sprites (atores) específicos para cada um dos componentes eletrônicos abaixo:

  • LED ==> Saída digital: ON / OFF
  • PwmLED ==> Saída analógica: usando o PWM, variamos o brilho do LED
  • Push-Button ==> Entrada digital: ON / OFF
  • LDR ==> Entrada analógica: medição de luz
  • Temp ==> Entrada analógica: medição de temperatura
  • PIR ==> Entrada digital: sensor de movimento (ON / OFF)
  • Buzzer ==> Saída analógica: criando tons musicais
  • Sonar ==> Entrada / Saída: medição de distância
  • Servo ==> Controle de movimento para um servo motor de 180o

Cada Sprite será responsável pela configuração inicial dos pinos do Arduino e monitorará ou atuará em conformidade com a tarefa designada. Além disso, cada uma dessas tarefas estará associada a uma variável para que não mudemos os blocos específicos do Sprite, independentemente de nosso programa.

Sprites.png

No próximo ítem, começaremos com o LED e espero que a idéia se torne mais clara.

Para o desenvimento dos projetos, utilizarei tanto o  programa base quanto o editor offline, no idioma inglês. Mas voce poderá adaptá-lo facilmante ao português.

6: O ator (sprite) LED

The LED Sprite and a New Blink Program

Para começar, iremos ao menu Data (laranja) e criamos uma nova variável: “led“, que funcionará para todos os Sprites (isso é muito importante). Esta variável será ajustada para “0” se quisermos que o LED seja desligado e configurada em “1” quando quisermos que o LED esteja ligado.

Além disso, criaremos um novo Sprite  o qual chamaremos de “LED”. No editor, criaremos 2 “fantasias” (costumes) diferentes para o LED: LED OFF e LED ON.

O sprite LED (e todos os demais componentes do nosso playground) serão sempre programados com 2 grupos específicos de blocos, um para configuração de  sua condição inicial e outro que será executado para sempre (em um loop), onde monitoraremos ou atuaremos no pino do Arduino correspondente. Os dois grupos de blocos (ou “funções”) são descritos abaixo:

  • Criaremos um bloco específico chamado “setup” para inicializar o LED:
define (setup)
  [Enable] Digital Pin (13) for [Output]
  DigitalWrite Set Pin (13) to [0]
  switch costume to [LED OFF]
  set [led] to (0)
  • Crearemos nossa função principal, a qual chamará a função setup e executará outros s comandos. No caso usará um bloco específico para ativação do pino 13 do Arduino em função do valor armazenado na variável led.
when GREEN FLAG clicked
  setup
  forever
    if  = (1) then
      DigitalWrite Set Pin (13) to [1]
      switch costume to [LED OFF]
    else
      DigitalWrite Set Pin (13) to [0]
      switch costume to [LED OFF]

Observe que neste momento, quando você executar o programa, clicando na bandeireinha verde (GREEN FLAG), nada acontecerá, MAS de fato, a partir de agora, basta  você escrever na variável led,  “1” ou “0”, que o LED conectado ao pino 13 do Arduino acenderá ou apagará!

blink_LED block.png

Criaremos agora um novo Sprite, que será quem realmente fará toda a ação para nós. Usaremos nosso pequeno amigo, o MJRoBot para isso. Associado a este Sprite (“MJRoBot”), desenvolveremos um novo programa para piscar o LED, porem sem alterar os Scripts associados ao LED.

Na área de Script associada ao MJRoBot, arrastemos os blocos abaixo, mantendo os mesmos desconectados entre si:

set [led] to (0)
set [led] to (1)

Ao clicar nesses blocos, você verá que o LED físico conectado ao pino 13 do Arduino acenderá ou apagará, dependendo de que bloco você clique.

Poderemos agora utilizar somente a variável led, criando um script para piscar o LED como fizemos na última etapa:

when GREEN FLAG clicked
  forever
    set [led] to (1)
    wait (1) secs
    set [led] to (0)
    wait (1) secs

Pronto!

Voce poderá fazer o download de nosso primeiro competente através do link: Arduino_blink_V2.sb2

Novamente, tente algumas mudanças, explore o código, associe o LED a uma animação. Instale mais LEDs com nomes diferentes (associando a novas variáveis), etc.

Boa sorte!

7: Saída Analógica: Controlado o brilho do LED (Dimmer)

dimmer working

Exploremos agora um novo componente, que será um LED conectado à uma saída PWM, escrevendo um script um pouco mais complexo para podermos explorar o potencial do Arduino.

Para começar, iremos ao menu laranja Dados (Data) e criemos uma nova variável: “pwmLED”, que funcionará para todos os Sprites. Esta variável poderá receber valores de “0” a “255”, o que fará com que o brilho do LED mude do mínimo para o máximo.

Criaremos agora um novo Sprite, ao qual chamaremos: “pwmLED”. No editor, criaremos 6 “Costumes” diferentes, simulando diferentes brilhos para o LED.

LED_Pin13_and_9

Siga o diagrama acima e adicione um novo LED ao nosso circuito. Devemos conectar o cátodo do LED (a perna mais curta) ao terra (GND) através de um resistor de 220 ohm e o ânodo (perna mais longa) ao pino 9 da Arduino UNO.

O Arduino UNO pode fornecer em vários de seus pinos, um sinal PWM (modulação por Largura de Pulso). Veja este link para mais detalhes: Tutorial/PWM.

Em suma, você pode “emular” um sinal analógico utilizando uma saída digital.

E como fazer isto?

A primeira coisa a se fazer é informar ao Arduino que um de seus pinos (em nosso caso será o 9) será ativado ([Enable]) e deverá funcionar como [PWM]. Arraste este bloco para a área de scripts.

[Enable] Digital Pin (9) for [PWM]

Apenas clicando neste bloco, você já estará habilitando o pino 9 como uma saída PWM.

Agora arraste os blocos de escrita analógica:

AnalogWrite Set Pin (9) to (0)

Altere o valor (0) para outros valores entre 0 e 255. Você verá que com 0, o LED estará desligado e com 255, o LED estará no seu brilho máximo. Experimente com valores intermediários e veja o que acontece.

dimmer1

Como fizemos com o sprite LED, o novo sprite pwmLED será também programado com 2 grupos específicos de blocos, um para sua configuração inicial (que será executado uma única vez) e outro que será executado para sempre (em um loop), onde monitoraremos / atuaremos em seu pino específico.

  • Criemos a função “setup”  para a inicialização do script pwmLED
define (setup)
  [Enable] Digital Pin (9) for [PWM]
  AnalogWrite Set Pin (9) to [0]
  switch costume to [pwmLED 0]
  set [pwmLED] to (0)
  • Criemos  nossa função “principal”, a qual “chamará” a função “setup” e enviará ao pino 9 um valor PWM e também definindo qual fantasia nosso sprite usará para simular o “brilho” (animação).
when GREEN FLAG clicked
  setup
  forever
    AnalogWrite Set Pin (9) to (pwmLED)
    if <(pwmLED) > 50> then
      switch costume to [pwmLED 64]
    if <(pwmLED) > 100> then
      switch costume to [pwmLED 128]
    if <(pwmLED) > 150> then
      switch costume to [pwmLED 180]
    if <(pwmLED) > 200> then
      switch costume to [pwmLED 210]
    if <(pwmLED) > 250> then
      switch costume to [pwmLED 255]
    if <(pwmLED) < 50> then
      switch costume to [pwmLED 0]

dimmer2

Associado ao Sprite “MJRoBot”, desenvolveremos um programa (ou “Script”) que:

  • Alterará o valor PWM de 0 para 255, retornando para zero depois disso.
  • Quando o brilho pwmLED (LED azul) estiver em seu máximo, acenderemos o LED (LED vermelho) por 1 segundo:
when GREEN FLAG clicked
  forever
    repeat until <(pwmLED) > (255)>
      change [pwmLED] by (10)
      wait (0.1) secs
    set [led] to (1)
    wait (1) secs
    set [led] to (0)
    set [pwmLED] to (0)

Abaixo o código:

Arduino_dimmer_LED.sb2

As saídas analógicas podem ser usadas para controlar velocidade de motores ou a posição de servo motores.

8: Entrada Digital: Push-Button

Digital Input: Push-Button
Comecemos por conectar um Push-button ao pino 2 do Arduino como mostrado no diagrama elétrico abaixo.
LED_Button
De agora em diante, poderemos ir mais rápido. Você já “pegou” a idéia!
Para entradas digitais, usaremos o mesmo bloco de configuração que usamos com o LED, porém mudando seu parâmetro para “entrada”:
[Enable] Digital Pin (2) to [input]

E para ler seu valor usaremos o bloco:

Read Digital Pin (2)

Este bloco retornará “1” se no pino D2 tivermos um nível lógico “1” e “0” se for um “0”.

Arraste ambos os blocos para a área de Script e clique primeiro no bloco Ativar ([Enable]) e depois no bloco Ler Digital (Read Digital).

Pressione o botão (push-button físico) e verifique se o status mudou (um “balão branco” aparecerá sobre o bloco com seu valor).

button1

Criaremos uma nova variável “button”, que será configurada em “1” ou “0”, dependendo da condição do botão e também 2 novos “costumes” para este novo Sprite, que chamaremos de Push-Button. Experimente você mesmo e depois confirme com o código no final desta etapa.

Mais uma vez, criaremos 2 grupos de blocos, o setup e o “loop principal“. Apenas observe que aqui a variável “button” será “carregada” com o status real do botão físico conectado ao pino 2 do Arduino:

set [button] to (read Digital Pin (2))

Um excelente recurso do editor do Scratch que ajuda muito quando você está testando um código é poder acompanhar o valor da variável no “stage (palco)”. Para isto, marque uma variável (com uma marca “v”) no menu Dados. Ao fazê-lo, o valor da variável será mostrado no stage, conforme mostrado nas capturas de tela.

button2

Desafio:
Crie um código associado ao sprite MJRoBot, o qual variará o pwmLED desde seu mínimo (0) até o máximo (255), mas somente durante o tempo em que se pressione o botão. Além disso, se o botão for pressionado, o LED VERMELHO (associado à variável led) deverá estar LIGADO. Experimente desenvolver sua solução antes de olhar a minha, que está no link: Arduino_Push_Button_LED.sb2

9: Entrada Analógica – LDR

Analog Input - LDR
Para saber como usar as entradas analógicas do Arduino, conectaremos a seu pino A0, um resistor variável por luminosidade ou simplesmente, LDR (Light Dependent Resistor).

LDR_PinA0

Mas, o que é um LDR?

LDR, também conhecido como “ Fotoresistor“, é um dispositivo que tem sua resistência elétrica variando com a luz. Como você pode ver no diagrama acima, quanto maior a luz incidente, menor sua resistência elétrica. Montando o LDR e um resistor adicional como um “divisor de tensão”, teremos no pino A0 do Arduino, um sinal analógico inversamente proporcional à variação de luz:

  • Luz alta    ==> menor resistência interna ==> maior entrada de tensão em A0
  • Luz baixa ==> maior resistência interna  ==> entrada de tensão mais baixa em A0

Desta forma, o pino A0 do Arduino UNO receberá um sinal variando de quase 0 a cerca de 5V.

Os 6 entradas analógicas do UNO (A0 a A5) estão conectadas internamente a um conversor analógico digital de 10bits, o qual por sua vez é um dispositivo que, como o nome explica, converterá o valor analógico em um valor digital que pode ser lido internamente pelo processador (ADC de 10 bits  gera valores de 0 a 1023).

Então, em um limite:

  • LUZ BAIXA ==> LDR com ALTA RESISTÊNCIA   ==> 0V no pino A0 ==> ADC: 0
  • LUZ ALTA   ==> LDR com BAIXA RESISTÊNCIA ==> 5V no pino A0 ==> ADC: 1023

Claro que na prática, os valores serão entre esses extremos.

Vejamos isso funcionando:

O bloco a ser usado para configurar um pino analógico é:

[Enable] Analog Pin (A) (0) for Input

E para “ler” o valor desse pino, usaremos o bloco:

Read Analog Pin (A) (0)

Esse bloco retornará um valor inteiro de 0 a 1023.

Arraste ambos os blocos para a área de Script e clique primeiro no bloco Ativar (Enable) e depois no bloco de leitura analógica. Cubra o LDR com a mão e verifique se o valor relatado pelo bloco mudou (um “balão branco” aparecerá sobre o bloco com seu valor).

Em meu caso, obtive os valores abaixo:

  • Luz normal: mais de 900
  • Escuro (cobrindo o sensor com a mão): Menos de 50

ldr1

Criemos um novo Sprite, o qual denominaremos “LDR” e uma nova variável “light“, que receberá um valor dependendo da luminosidade do ambiente.

O problema aqui é que 800, 900, 50, etc., que são os valores que retornam do ADC, não significam muito para nós. O que precisamos é algo como:

  • Máxima luminosidade: 100%
  • Completamente escuro: 0%

Então, se obtivermos uma luminosidade de “30%”, por exemplo com certeza saberemos que é o fim do dia.

Precisamos então “MAPEAR” nossa variável, de uma forma que:

  • Se a saída do ADC é por exemplo 30 ==> queremos que seja 0%
  • Se a saída do ADC é por exemplo 1000 ==> queremos que seja 100%
  • E qualquer valor intermediário entre 0 a 1000 deverá ser proporcional a um valor entre 0% e 100%:

Para isso, criaremos um bloco genérico que irá mapear (“MAP”) os valores mínimos e máximos da entrada analógica:

Vamos criar nomes:

  • Entrada mínima  ==> fromLow
  • Entrada máxima ==> fromHigh
  • Saída mínima      ==> toLow
  • Saída máxima     ==> toHigh

e

  • Valor de entrada genérico                   ==> value
  • Resultado genérico do mapeamento ==> mapReturn

Usando “proporções”, podemos criar uma equação:

mapReturn = ((value – fromLow) * (toHigh – toLow)) / ((fromHigh – fromLow) + toLow))

Parece um pouco complicado, mas na verdade é bem simples e útil. O importante aqui é que esse “bloco de mapa” que você criou funcionará sempre para qualquer programa. Além disso, note que usamos o operador “Round” que, como seu nome diz, arredondará o valor final.

No final, você só precisará usar o bloco:

map (value at A0) (fromLow) (fromHigh) (toLow) (toHigh)

Que no nosso exemplo especifico:

map (Read Analog Pin (A) (0)) (30) (1000) (0) (100)

Definiremos a nossa variável “light” a partir do retorno deste novo bloco de mapeamento. Para mais detalhes sobre o “MAP”, visite o link:  Arduino map().

ldr2

Vamos ao nosso MJRoBot Sprite e utilizando esta nova luz variável, criemos um código simples onde, se a luz for inferior a 30%, devemos ligar o LED vermelho (associado a variável led) caso contrário, deixaremos o LED desligado. Isso é exatamente o que acontece com as luzes automáticas de sua rua, as quais ligam automaticamente ao final do dia, quando a luz é baixa.

Crie seu código e depois confira sua solução com a minha:  Arduino_LDR.sb2

Desafio:

Modifique seu código para ativar automaticamente uma luz externa de sua casa (aqui o LED vermelho) quando estiver escuro, mas você somente se estiver viajando, ou seja, você deverá ligar ou desligar seu projeto, usando para isso o push-button. Pense sobre como você deve trabalhar com as variáveis de uma forma que, quando “pressionar o botão”, manteremos seu status (como uma memória, ou o interruptor de luz de sua casa). Se o pressionarmos novamente, o status será “alternado” (do ingles “toggle”).

10: Entrada Analogica – Temperatura

LM35 working

Exploremos outro dispositivo que também fornece uma saída analógica, o sensor de temperatura LM35.

Os LM35 series são circuitos integrados que englobam sensores de temperatura de alta precisão, cuja tensão de saída é linearmente proporcional à temperatura Celsius e, portanto, não precisam de calibração externa. Sua saída é de 10mV / oC. Assim, para uma temperatura de 19 oC, por exemplo, o LM35 gerará 190mV.

LM35_PinA1

Como fizemos anteriormente, criaremos um novo Sprite (LM35) e definiremos uma nova variável, “tempC” a qual receberá o valor da entrada analógica A1. A configuração é bem semelhante à que fizemos com o LDR, apenas mudaremos (A) (0) para (A) (1) no bloco abaixo:

[Enable] Analog Pin (A) (1) for Input

E leremos o valor desta entrada com o bloco:

Read Analog Pin (A) (1)

Com no caso anterior, este bloco retornará um valor de 0 a 1023. Vamos clicar no bloco e ver o encontramos.

Ops! Quando clicamos neste bloco, percebemos que a temperatura não é realmente a correta, por exemplo o sensor mostra “39”, mas sei que a temperatura aqui em meu laboratório é de fato 19oC.

O que está errado?

Lembre-se de que cada entrada analógica variará de 0 a 5V (ou de o a 5.000mV). Então, vamos calcular para 19oC qual deve ser o resultado do ADC interno:

Fazendo a proporção, teremos:

  • 5,000 [mV] ==> 1024
  •    190 [mv] ==> x

x = (190 [mV] x 1023) / 5,000 [mV] = 39

Isso é exatamente o que estamos recebendo internamente de A1. Mas o que devemos fazer para ler corretamente a temperatura em Celcius?

Devemos tomar a leitura, encontrando a porcentagem do intervalo (1024), multiplicando-a pelo intervalo em si (5000 mV) e dividindo por dez (10 mV por grau Celcius, de acordo com a folha de dados):

A temperatura em Celcius será assim calculada:

tempC = (5V x A1_Value x 100%) / 1024 =

tempC = A1_Value (500/1024)

tempC = A1_Value / 2.048

O bloco abaixo faz este cálculo para nós:

set[tempC] to ((Read Analog Pin (A) (1)) / (2.048))

Clicando nele,  “19oC” aparecerá agora associado a variável “tempC”.

Para mais detalhes, visite o link: Arduino and LM35

temp1

Observe que o código final usará round () para “arredondar” o resultado do cálculo, desprezando-se o valor após o ponto decimal.

Igual ao que fizemos com o LDR teremos a variável tempC constantemente atualizada com o valor do sensor, e poderemos agora criar um código associado ao nosso Sprite MJRoBot, tendo em mente a seguinte lógica:

if <(tempC) > (30)> then
  set [pwrLED] to (255)
else
  set [pwmLED] to (0)

Observe que em meu exemplo, estaremos mantendo o código anterior, que ativará o “LED vermelho” se a luz for inferior a 30% adicionando agora um “alarme” usando o “LED azul”, relacionado com a nossa variável pwmLED. Ambos os sensores funcionarão de forma independente.

Em realidade, o Arduino UNO possui apenas um ADC interno que está multiplexando suas 6 entradas analógicas. Devido a isto, é recomendável não efetuar medidas imediatamente uma após uma outra, sendo aconselhável deixar ao menos 300 ms de espera entre as medidas.

temp2

Voltando ao nosso projeto, você poderia imaginar que o mesmo seja utilizado em dias quentes, para ligar automaticamente um equipamento elétrico como um ventilador por exemplo (aqui representado pelo LED azul). Coloque o dedo sobre o sensor, você deverá ver a temperatura subir, acendendo o LED azul.

Aqui do código completo para download: Arduino_Temp.sb2

Desafio:

bulb_TermometerCrie um código que desenhe um “termômetro de mercúrio”, onde a coluna de mercúrio irá subir e descer de acordo com a temperatura (veja a imagem acima como exemplo).

11: Detector de movimentos

Motion Detector

Sensores do tipo PIR  permitem que você detecte movimentos, geralmente utilizados em alarmes domésticos para detectar se um intruso se moveu dentro de sua faixa de monitoramento. Eles são pequenos, baratos, de baixa potência, fáceis de usar e não se desgastam. Eles são freqüentemente designados por sensores PIR, “infravermelho passivo”, “piroelétrico” ou “movimento IR”.

Eles são “Sensores Digitais”, e portanto muito fáceis de serem utilizados em seus projetos:

Como funcionam?

Se você executar um “movimento” na frente do sensor, este gerará 5V em sua saída e o Arduino o entenderá como nível lógico “1”.

Com “nenhum movimento”, um 0V será aplicado ao pino digital do Arduino, o que significa um nível lógico “0”.

Você pode “pensar” que o sensor é um “botão”, o que significa que o que aprendemos antes se aplicará a ele.

PIR_Pin3

Comecemos por conectar o sensor PIR ao pino 3 do Arduino. Siga o diagrama acima e faça as conexões apropriadas.

De igual maneira ao Push-Button, criaremos um Sprite (PIR), desta vez com 2 “costumes” representando a detecção de um “movimento” e uma nova variável chamada “motion”.

Use um bloco digital de ativação para configurar o pino:

[Enable] Digital Pin (3) to [input]

E o bloco de leitura digital:

Read Digital Pin (3)

Este bloco retornará “1” se no pino D3 tivermos um nível lógico “1” e “0” se for um “0”.

Precisaremos agora configurar a variável “movimento”, com 1 ou 0, dependendo da condição PIR:

set [motion] to ((Read Digital Pin (3))

Como fizemos anteriormente, a variável “motion” receberá o status do pino D3. Vamos incluí-lo no “Forever Loop”, o qual faz parte da função “principal”. Neste loop, devemos testar se há movimento (movimento = 1) e mudar corretamente o “costume” do Sprite.

PIR1

Agora, pensemos sobre algo útil one podemos usar esse sensor. Como mencionado anteriormente, o PIR é comumente utilizado em alarmes domésticos. Se uma pessoa entrar em sua casa, o sensor irá detectá-lo e disparará um alarme, por exemplo. No nosso caso, esse alarme é representado pelo LED vermelho. O código é semelhante ao desenvolvido para os últimos sensores.

PIR2

Tente você, variações ao meu código: Arduino_Motion_Detector.sb2

Desafio:

Modifique seu código para ativar automaticamente uma luz externa em sua casa (aqui o LED vermelho) quando estiver escuro, considerando incluir no código o sensor de movimento e o botão para ligar ou desligar o projeto.

12: Blocos especiais do S2aio – Gerando sons

S2aio Special Block - Playing Tones

Até agora, os Sprites que desenvolvemos usavam uma abordagem “direta”:

  • Pinos digitais recebendo sinais de sensores, tais como Push-Button e PIR,
  • Pinos analógicos recebendo sinais de luz (LDR) e temperatura (LM35)
  • “Atuando” em pinos digitais (LED)
  • “Atuando” em pinos analógicos (LED PWM)

De agora em diante, exploraremos blocos mais complexos que fazem parte do s2aio, os primeiros serão relacionados à “Geração de som”:

Esses blocos gerarão em um determinado pino digital, uma onda quadrada a uma freqüência especifica (com ciclo de trabalho de 50%). A duração deverá ser especificada em milissegundos, caso contrário, a onda continua até usarmos um bloco noTone. O pino será conectado a um buzzer do tipo piezo para gerar os tons. Siga o diagrama acima e conecte o pino “+” do buzzer ao pino digital 6 do Arduino.

Você deverá configurar o pino para operação de tom utilizando-se do bloco de configuração de pino digital, antes de gerar um som propriamente dito.

[Enable] Digital Pin (6) for [Tone]

Para enviar um tom específico ao buzzer use o bloco Play Tone. Por exemplo, para gerar no pino 6 um tom de 1KHz e 500ms:

Play Tone on Pin (6) HZ: (1000) ms: (500)

Utilizando-se uma duração de 0 ms, não produzirá um som, mas deixará o tom ativado. Use o bloco de comando Turn Tone Off para desativar-lo:

Turn Tone Off for Pin (6)

Buzzer1

O mesmo em componentes anteriores, devemos:

  1. Crie um Sprite (“Buzzer”) e defina suas fantasias (“costumes”)
  2. Defina as variáveis a serem utilizadas com este componente. Neste caso 2:
    • ToneHz ==> freqüência em Hz
    • ToneMs ==> duração em milissegundos
  3. Ativar o pino digital (aqui será o 6) com o bloco [Tone]
  4. Configure o Buzzer, começando com nenhum som e costume “sem som”.
  5. Associar em uma função “principal” as variáveis toneHZ e toneMs com o bloco Play Tone

Ótimo! Voce se lembra do dispositivo anterior onde trabalhamos com o detector de movimento? Associemos agora um alarme sonoro (Buzzer) quando um intruso for detectado! Em meu exemplo, utilizei duas frequências diferentes para simular um alarme. Experimente outras ideias!

Buzzer2

Aqui, meu código para o alarme: Arduino_Buzzer .sb2

13: Blocos especiais do S2aio – Sonar

S2aio Special Block - Sonar

Um dispositivo muito interessante que pode ser utilizado para medições de distância é o “Sonar”. Estaremos utilizando em nosso playground, o sensor ultra-sônico, HC-SR04.

Basicamente, este dispositivo emula o que os morcegos fazem para medir distâncias. Eles emitem um pulso de ultra-som (“Chirp”) e contam o tempo para que o eco (“Echo”) seja recebido de volta. O vídeo abaixo mostra uma animação que criei para mostrar como funciona o “radar interno” do morcego. Se você quiser conhecer como a animação foi criada, veja meu projeto no site do Scratch: Simulador de Radar

Voltando a física, sabendo-se o momento de emissão do pulso (“Chirp” ou “Trigger”), o tempo que demorou para que o eco (“Echo”) alcance o sensor novamente e conhecendo-se a velocidade do som (340m s), podemos dividindo o tempo resultante da diferença “Echo -Chirp” por 2, facilmente calcular a distância entre sensor e obstáculo (veja o diagrama acima).

Distância = 340 [m/s] x (T_chirp-T_echo) [s] /2

O HC-SR04 fornece medidas entre 2 e 400 cm com uma precisão de alcance que pode atingir até 3 mm. Cada módulo HC-SR04 inclui um transmissor ultra-sônico, um receptor e um circuito de controle.

O HC-SR04 tem 4 pinos:

  • VCC (Power),
  • Trig (Trigger),
  • Echo (Receiver), e
  • GND (Ground).

Em nosso caso, o s2aio desenvolveu o seu bloco levando-se em consideração que os pinos de Trigger e Echo são conectados a um único fio ligado a uma entrada digital do Arduino.

Sonar_Pin12

Observe no diagrama acima, que ambos os pinos estão curto-circuitados (jump laranja)  e conectados ao pino D12 do Arduino.

O pino D12 deve ser habilitado usando-se do bloco de Configuração Digital, selecionando-se o modo “Sonar”.

[Enable] Digital Pin (12) for [Sonar]

Os dados do Sonar serão monitorados utilizando-se do bloco “Read Digital”.

Read Digital Pin (12)

Sonar1

Executando os mesmos procedimentos criados para os componentes anteriores, deveremos:

  • Criar um Sprite (“Sonar”) e definir seus “costumes”
  • Definir uma variável a ser usada com este componente. Neste caso, “distance”
  • Ativar o pin digital correspondente (aqui será o 12) como [SONAR]
  • Configurar a variável de distância, começando com a distância “0” e sua fantasia (costume) correspondente.
  • Associar em uma função “principal” a variável “distance” com o valor medido pelo Sonar conectado fisicamente ao pino 12

Se você fizer o descrito acima, o sensor funcionará, MAS você perceberá que às vezes,  acontecerão erros nos valores (medições ou muito grandes ou muito baixas). Isso ocorrerá porque outros sons ou ecos refletidos em diferentes obstáculos podem gerar respostas “falsas” ao sensor. Uma maneira de minimizar este efeito, é criarmos uma variável temporária (“temp”), a qual receberá a leitura direta do pino digital. Porém somente passaremos esse valor medido para nossa variável”distância” se a medida estiver entre os limites definidos (veja a tela de impressão acima). Por exemplo, eu determinei uma área em meu laboratório para “medir coisas” que irão de um mínimo de 3 cm até um máximo de 40 cm.

Sonar2

Ótimo! Voce se lembra de nosso último projeto, onde desenvolvemos um alarme de som com nosso detector de movimento? Vamos agora associar o alarme de som (Buzzer) e um alarme visual (LED) quando um intruso é detectado, mas SOMENTE em distâncias inferiores a 30 cm (SONAR)! Experimente outras ideias, como também incorporar o sensor de movimento (PIR) mais LEDs, luz, etc.

Aqui meu código para o alarme de distância: Arduino_Sonar.sb2

14: Blocos especiais do S2aio – Servo Motor

S2aio Special Block - Servo Motors

O último dispositivo a ser incluído em nosso Playground eletrônico, será um servo motor, utilizando-se de outro bloco de comando especial do s2aio para definir sua posição entre 0 e 180 graus.

Mas antes de tudo, construiremos uma “torre” onde montaremos conjuntamente o Sonar e o Servo Motor de 180 graus. Fazendo isso, poderemos apontar nosso sonar em diferentes direções, usando-se o servo como um controle remoto. Siga as fotos acima como uma sugestão de como construir a torre.

Servo_Pin10

Tendo a torre fixada em uma mesa (usei fita durex para isso), conecte os cabos do servo no protoboard conforme mostra o diagrama acima. Existem apenas 3 fios, + VCC, GND e Dados (geralmente laranja) que em nosso caso deve ser conectado ao pino D10 do Arduino.

O pino 10 deve ser habilitado utilizando-se o bloco de Configuração para pinos digitais, selecionando-se o modo “Servo”.

[Enable] Digital Pin (10) for [Servo]

O comando para posicionamento do Servo em um ângulo específico é obtido com o bloco “Move Servo”. Abaixo, um exemplo movendo-o para 20 graus:

Move Servo on Pin (10) Deg: (20)

Faça alguns testes, alterando ângulos de 0 a 180 (você deve ajustar quais serão os valores extremos, pois o servo motor pode ter problemas com ângulos perto de 0 ou 180o.

Servo1

Nesta altura do campeonato, você já estará craque na adição de novos componentes ao “playground eletrônico”.

Vamos lá:

  • Crie um Sprite (“Servo”) e defina suas fantasias
  • Defina uma variável a ser utilizada com este componente. Neste caso, “angle”
  • Ativar o pino digital correspondente (aqui será o 10) como [Servo]
  • Posicionar o Servo em sua “posição inicial de ângulo “zero” (no meu caso será 20)
  • Configure a variável “angle”, iniciando-a com “0” e seu traje adequado
  • Associe em uma função “principal” a variável “angle” com o valor a ser enviado para posicionamento do servo.

Se você fizer o descrito acima, você conseguirá que o servo de trabalho, MAS é importante evitar que esse ângulo variável seja definido por outros Sprites com valores fora do alcance do servo (em meu caso 20 – 180). Então, vamos fazer uma “limitação” ou “CONSTRAIN”, limitando os valores angulares a serem enviados ao servo. Assim, apenas moveremos o servo se a variável “angle” estiver entre 20 e 180. Se o ângulo for inferior a 20, o manteremos 20 e  para valores superiores a 180, manteremos 180.

Um bom procedimento será criar um bloco dedicado e genérico para a “função CONSTRAIN”, o mesmo que fizemos para o “MAP”. Tente!

Servo2

Vamos criar uma função “SWAP”, onde o servo se moverá em todas as direções. Incluiremos um botão, para que o Servo só execute a varredura quando o mesmo for pressionado.

Aqui meu código para a função SWAP: Arduino_Servo.sb2

15: Projeto: o Radar básico

fm7othnj5sfy8nx-medium

Agora, o nosso “MJRoBot Electronic Playground” está completo. Temos um Sprite para cada um de nossos componentes. Ademais, cada componente tem uma variável associada a ele.

Podemos definir um projeto e trabalhar em seu código apenas alterando o Script associado ao MJRoBOt ou a qualquer outro, sem modificar os scripts associados aos componentes e sem se preocupar com a interação do Scratch com o HW.

Vamos então criar um projeto completo utilizando-se do Playground eletrônico.

Project: the Basic Radar

Abra o Aquino base abaixo:

Você verá que a área do Script para o nosso Sprite MJRoBot está vazia.

Para criar um novo projeto, vá para o MENU do editor offline do Scratch 2 e usando a opção “Salvar como”, crie um novo arquivo: “Arduino_Radar_Basic.sb2”.

Não altere o arquivo Base_Playground.sb2.

Utilizando o que aprendemos até agora, criaremos um código básico para um radar, o qual deverá obedecer a seguinte especificação:

  • A torre com Servo / Sonar irá varrer uma área à procura de obstáculos em uma faixa de 40 cm.
  • Se um obstáculo for encontrado em uma distância inferior a 10 cm, um alarme deve ser disparado.
  • O alarme deve usar som e luz.

Basic_Radar

Isso aí! O vídeo abaixo mostra como o projeto deverá funcionar:

E aqui, o link para o código final: Arduino_Radar_Basic.sb2

16: Projecto Final: Radar com PPI

Project: Radar With PPI

Para nosso último projeto, utilizaremos o  projeto do Radar básico, incluíndo alguma animação para que uma “Tela de Radar” (ou PPI – “Plan Position Indicator”) apareça em nosso vídeo.

Criemos 2 novos Sprites:

  • A tela do radar
  • O Radar Scanner (com 2 “costumes”: varredura normal e alvo encontrado)

radar2

A tela do radar Screen será apenas um “fundo” e será estático. Mas o “Radar Scanner” será uma linha que irá varrer a tela do Radar da esquerda para a direita (de 0 a 180 graus), seguindo a varredura física do Servo.

radar1

Para sincronizar a animação e a varredura real do servo, você deve adicionar ao último script do MJRoBot, duas “chamadas de eventos”

A primeira,  a ser enviada sempre que o servo volte a sua posição inicial:

broadcast [startScan]

A segunda, durante a varredura normal:

broadcast [draw]

E uma terceira, informando que o alvo foi encontrado e o alarme disparado:

broadcast [target]

No Sprite “Radar Scanner”, esses 3 eventos desencadearão funções específicas:

  • Quando recebido [startScan], vá para a posição zero
  • Quando recebido [draw] alterar a posição do sprite, girando 3,5 graus (o mesmo que usamos na função de SWAP), executando também o som e o costume corretamente
  • Quando recebido [target] mude o som e o traje adequadamente

Abaixo um rápido filminho mostrando o projeto final em funcionamento:

O código final, você encontrará aqui: Arduino_Radar_V2.sb2

17: To Boldly Go Where No One Has Gone Before……

To Boldly Go Where No One Has Gone Before......

É a sua vez, agora!

Seja criativo! Misture os sensores, incluindo novas idéias, componentes, etc!

Lembre-se! O céu não é o limite! O homem já chegou à Lua!

Depois de aprender sobre como controlar “coisas” usando um Arduino e o Scratch 2, tente fazer o mesmo usando o IDE Arduino.

“Vida longa e próspera”

Boa sorte! 😉

18: Conclusão

Como sempre, espero que este projecto possa ajudar outros a encontrarem o seu caminho no emocionante mundo da electrônica, robótica e do IoT!

Visite o meu depositário de arquivos no GitHub para obter os arquivos atualizados:

 Scratch_2

Não deixem também de visitar e seguir minha página: MJRoBot.org no Facebook

Saludos desde el sur del mundo!

Até o próximo post!

Obrigado

Marcelo

Anúncios

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

  1. 

    Como sempre muito completo. Parabéns !

    Curtir

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 )

Imagem do Twitter

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

Foto do Facebook

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

Foto do Google+

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

Conectando a %s