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

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:

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

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

Arduino_blink.sb2

Tente algumas variacões no programa. Explore!

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.

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.

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

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!

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.

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]

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.

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

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.

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

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

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

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

[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

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.

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:

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

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.

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.

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.

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

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!

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

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)

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.

Ó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

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

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!

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

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.

Abra o Aquino base abaixo:

• Base_Playground.sb2

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.

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

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.

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

É 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! 😉