O que é um Microcontrolador?

Transcription

O que é um Microcontrolador?
Guia do estudante
VERSÃO 3.0
GARANTIA
Troca em decorrência de defeito funcional
O consumidor terá, nos casos de vício ou defeito do produto, o prazo de até 90 dias para bens
duráveis para solicitar a assistência técnica ou troca do mesmo.
Se o produto adquirido apresentar defeito funcional, será feito o reparo ou a substituição do
produto por outro igual ao descrito em sua nota fiscal. A BS Educacional tem até trinta (30)
dias corridos, a contar da data do recebimento do seu produto em nossa fábrica. Após esse
prazo, você poderá optar pela troca por outro produto similar, em perfeita condições de uso
ou restituição corrigida do valor pago.
Troca por conta de avaria no produto
Se você receber o produto adquirido, avariado no transporte, será feita a substituição do
produto avariado por outro produto igual ao descrito em sua nota fiscal.
Preferencialmente recuse a entrega se notar que o mesmo encontra-se avariado. Caso
contrário entre imediatamente em contato com a BS Educacional.
Recebimento de produto em desacordo com o pedido
Caso você receber um produto diferente do adquirindo, será feita a substituição desse
produto por outro produto igual ao que foi solicitado no pedido.
Se você detectar no ato da entrega que o produto está em desacordo com o que foi
solicitado, recuse a entrega imediatamente e contate a BS Educacional. Caso contrário, o
produto deverá ser devolvido sem manuseio, com todos os itens e acompanhado de cópia
da nota fiscal. A troca do produto acontecerá somente após o recebimento e análise das
condições do produto devolvido.
GARANTIA DE 7 DIAS COM SEU DINHEIRO DE VOLTA
Asseguramos o direto de devolução contemplado no código de defesa do consumidor que
permite a desistência da compra no prazo de 7 dias a contar do ato de recebimento do
produto. Se o prazo citado vencer em um dia não útil, será automaticamente prorrogado
para o primeiro dia útil seguinte, não sendo aceitas solicitações realizadas além desse
prazo.
Para sua segurança, certifique-se que o produto recebido atende suas expectativas antes
de violar a embalagem. Você poderá devolver o produto apenas se ele estiver em sua
embalagem original, sem indícios de uso e com o manual e todos os acessórios que o
acompanham. Constatada divergência, como utilização indevida, ausência de manual,
acessório ou embalagem, a BS Educacional não poderá aceitar a devolução do produto.
Para devolver o produto entre em contato com a BS Educacional explicando o motivo da
devolução e informando o número do pedido ou Nota Fiscal. A BS Educacional enviará
as instruções para o envio do produto a nossa fábrica. A troca do produto ou restituição
do valor, excluindo custos de envio e manuseio, acontecerá somente após o recebimento e
análise das condições do produto devolvido.
Em compras pagas por meio de cartão de crédito, solicitaremos o respectivo estorno
obedecendo o procedimento da administradora de cada bandeira.
Em compras pagas por meio de boleto bancário, a restituição será creditada sempre na
conta corrente de titularidade do cliente que efetuou a compra e em até dez (10) dias úteis
a contar da data de confirmação que o produto devolvido atende os requisitos.
DIREITOS AUTORAIS E MARCAS
Esta documentação está protegida pela Leis de Direitos Autorais 2003-2009 pela Parallax
Inc. Ao fazer o download ou obter uma cópia impressa desta documentação ou software,
você concorda que é para uso exclusivo dos produtos Parallax. Quaisquer outros usos não
são permitidos e podem representar uma violação de direitos autorais para Parallax,
legalmente puníveis de acordo com as leis de direitos autorais e leis de propriedade
intelectual. É expressamente proibido pela Parallax Inc. qualquer duplicação desta
documentação para fins comerciais. A duplicação para uso educacional, no todo ou em
parte, é permitida sujeita às seguintes condições: o material é permitido somente para ser
usado em conjunto com produtos da Parallax, e o usuário pode reaver do aluno somente o
custo da duplicação. Antes de duplicar quaisquer de nossas documentações, em parte ou
na totalidade, para qualquer outro uso, faz-se necessário a aprovação da Parallax.
BASIC Stamp, Board of Education, Boe-Bot, Stamps in Class, e SumoBot são marcas
registradas da Parallax Inc. Assim como, HomeWorkBoard, PING))), Parallax, o logotipo
da Parallax, Propeller e Spin. Se você desejar usar qualquer uma dessas palavras em seu
material eletrônico ou impresso, você deve afirmar que é uma marca registrada da
Parallax Inc. Outros nomes de marcas e produtos aqui mencionados são marcas
comerciais ou marcas registradas de seus respectivos proprietários.
ISBN 9781928982531
3.0.1-11.08.04-HKTP
ISENÇÃO DE RESPONSABILIDADE
A Parallax Inc. não é responsável por danos especiais, acidentais ou consequências,
resultantes de qualquer violação da garantia, ou sob qualquer fundamento jurídico,
inclusive lucros cessantes, tempo de inatividade, fundo de comércio, danos ou
substituição de equipamentos ou propriedade, ou quaisquer custos de recuperação,
reprogramação ou reprodução de quaisquer dados armazenados ou utilizados com
produtos Parallax. A Parallax também não é responsável por qualquer dano pessoal,
inclusive o de vida e saúde, resultante do uso de qualquer um dos nossos produtos. Você
assume a responsabilidade total para a sua aplicação BASIC Stamp, não importando o
risco de vida.
ERRATA
Apesar dos esforços para garantir a precisão dos nossos textos, os erros podem existir.
Ocasionalmente uma folha de errata com uma lista de erros conhecidos e correções para
um determinado texto será postada na página do produto relacionado na
www.parallax.com. Se você encontrar um erro, por favor, envie um e-mail para
[email protected] ou para [email protected].
Página - 5
Índice Analítico
Prefácio ....................................................................................................................... 7
Sobre a versão 3.0 ......................................................................................................... 7
Público ............................................................................................................................ 7
Fóruns de Suporte .......................................................................................................... 8
Recursos para Educadores ............................................................................................ 8
Traduções em Linguas Extrangeiras .............................................................................. 9
Sobre o Autor.................................................................................................................. 9
Colaboradores Especiais ................................................................................................ 9
Capítulo 1: Introdução ............................................................................................. 11
Quantos Microcontroladores Você Viu Hoje? ............................................................... 11
BASIC Stamp 2 – Seu Novo Módulo Microcontrolador ................................................ 11
Invenções Incríveis com Microcontroladores Basic Stamp .......................................... 12
Hardware e Software .................................................................................................... 14
Atividade #1: Obtendo o Software ................................................................................ 14
Atividade #2: Usando a Ajuda Para Configuração do Hardware .................................. 19
Sumário ........................................................................................................................ 21
Capítulo 2: Luzes Acesas e Apagadas (On e Off) ................................................. 24
Luzes Indicadoras......................................................................................................... 24
Fazendo um Diodo Emissor de Luz (LED) Emitir Luz .................................................. 24
Atividade #1: Construindo e Testando um Circuito DE LED ........................................ 25
Atividade #2: Controle de ON/OFF com o BASIC Stamp ............................................. 31
Atividade #3: Contando e Repetindo ............................................................................ 36
Atividade #4: Construindo e Testando o Segundo Circuito DE LED ............................ 39
Atividade #5: Usando a Direção da Corrente para Controlar o LED Bicolor ................ 42
Sumário ........................................................................................................................ 48
Capítulo 3: Entrada Digital – Botões ...................................................................... 52
Encontrados em Calculadoras, Jogos Portáteis e Aplicativos...................................... 52
Recebimento vs. Envio de Sinais de HIGH e LOW ...................................................... 52
Atividade #1: Testando um Botão com um Circuito de LED......................................... 52
Atividade #2: Leitura do Botão com o BASIC Stamp................................................... 55
Atividade #3: Controle por Botão de um Circuito de LED............................................. 58
Atividade #4: Dois Botões Controlando Dois dos Circuitos de LED ............................. 61
Atividade #5: Teste de Tempo De Reação ................................................................... 65
Sumário ........................................................................................................................ 73
Capítulo 4: Controle de Movimento ........................................................................ 77
Movimento Microcontrolado.......................................................................................... 77
Sinais de On/Off e Movimentos do Motor ..................................................................... 77
Introduzindo o Servo..................................................................................................... 77
Atividade #1: Conectando e Testando o Servo ............................................................ 79
Atividade #2: Programa de Teste de Controle do Servo .............................................. 84
Atividade #3: Controle de Tempo de Espera do Servo ................................................ 93
Atividade #4: Controlando Posições com seu COMPUTADOR ................................... 98
Atividade #5: Convertendo Posição de Movimento .................................................... 105
Atividade #6: Servo Controlado Por Botão ................................................................. 108
Sumário ...................................................................................................................... 111
Capítulo 5: Medindo a Rotação ............................................................................. 116
Ajustando os Mostradores e Máquinas de Monitoramento ........................................ 116
O Resistor Variável Sob o Seletor - um Potenciômetro.............................................. 116
Atividade #1: Construindo e Testando o Circuito do Potenciômetro .......................... 117
Atividade #2: Medindo A resistência Ao medir o tempo ............................................. 119
Atividade #3: Lendo um Seletor com o BASIC Stamp................................................ 124
Atividade #4: Controlando o Servo com um Potenciômetro ....................................... 129
Sumário ...................................................................................................................... 136
Capítulo 6: Display Digital ..................................................................................... 140
O Display Digital Cotidiano ......................................................................................... 140
O Que é um Display de 7 Segmentos? ...................................................................... 140
Atividade #1: Construindo e Testando O Display de LED de 7 Segmentos ............... 141
Atividade #2: Controlando o Display de LED de 7 Segmentos .................................. 144
Página - 6
Atividade #3: Exibindo Dígitos .................................................................................... 146
Atividade #4: Exibindo a Posição de um Dial ............................................................. 152
Sumário ...................................................................................................................... 156
Capítulo 7: Medição de Luz ................................................................................... 160
Dispositivos que Contém Sensores de Luz ................................................................ 160
Introdução Do Fototransistor ...................................................................................... 162
Atividade #1: Construindo e Testando o Medidor de Luz ........................................... 163
Atividade #2: Rastreando Eventos de Luz.................................................................. 166
Atividade #3: Medições Gráficas de Luz (Opcional) ................................................... 173
Atividade #4: Simples Medidor de Luz ....................................................................... 175
Atividade #5: Saídas ON/OFF do Fototransistor ........................................................ 184
Atividade #6: Para Diversão - Meça a Luz Externa com um LED .............................. 191
Sumário ...................................................................................................................... 195
Capítulo 8: Frequência e Som ............................................................................... 200
O Seu Dia e Bips Eletrônicos ..................................................................................... 200
Microcontroladores, Alto-Falantes e Sinais On/Off..................................................... 200
Apresentando o Speaker Piezoelétrico ...................................................................... 200
Atividade #1: Criando e Testando o Alto-Falante ....................................................... 200
Atividade #2: Sons de Ação........................................................................................ 202
Atividade #3: Notas Musicais e Canções Simples...................................................... 207
Atividade #4: Música com Microcontrolador ............................................................... 211
Atividade #5: Toques com RTTTL .............................................................................. 222
Sumário ...................................................................................................................... 232
Capítulo 9: Construindo Blocos Eletrônicos ....................................................... 236
Esses Pequenos CHIPS Pretos ................................................................................. 236
Expanda Seus Projetos com Circuitos Periféricos Integrados ................................... 237
Atividade #1: Controle do Fluxo Atual com um Transistor.......................................... 237
Atividade #2: Introdução ao Potenciômetro Digital ..................................................... 240
Sumário ...................................................................................................................... 247
Capítulo 10: Protótipos De Suas Próprias Invenções ........................................ 252
Aplicando o que Você Sabe com Outras Peças e Componentes ............................. 252
Protótipo de um Micro Sistema de Segurança ........................................................... 253
Atividade #1: Da Ideia a Prova de Conceito ............................................................... 254
Atividade #2: Construir e Testar Cada Circuito Individualmente ................................ 256
Atividade #3: Organizar a Codificação de Tarefas em Pequenos Pedaços ............... 257
Atividade #4: Documentar o Seu Código!................................................................... 261
Atividade #5: Dê ao Seu App uma Surpreendente Nova Funcionalidade .................. 263
Atividade #6: Superando Obstáculos do Projeto ........................................................ 264
Atividade #7: Qual Será a Próxima?........................................................................... 269
Sumário ...................................................................................................................... 272
Apêndice A: Lista de Peças e Opções de Kit ...................................................... 274
Opções de Kit Completo ............................................................................................. 275
Apêndice B: Mais Informações Sobre Eletricidade ............................................ 278
Atividade Bõnus: Lei de Ohm, Voltagem e Corrente .................................................. 279
Apêndice C: Sumário do Formato RTTTL............................................................ 285
Página - 7
Prefácio
Esse texto responde a pergunta “O que é o Microcontrolador”, mostrando aos alunos
como eles podem projetar suas invenções de modo personalizado e inteligente com o
módulo microcontrolador BASIC Stamp®. da Parallax Inc. As atividades deste texto
incorporaram uma variedade de divertidas e interessantes experiências projetadas para
trabalhar à imaginação do aluno, utilizando movimento, luz, som e feedback tátil para
explorar novos conceitos. Essas atividades apresentam aos alunos uma série de
princípios básicos nas áreas de programação de computadores, eletricidade e eletrônica,
matemática e física. Muitas destas atividades facilitam a apresentação prática de
projetos utilizados por engenheiros e técnicos na criação de máquinas e aparelhos
modernos, usando peças genéricas baratas O que é um microcontrolador? é a porta de
entrada de dados para os programas Stamps in Class. Para ver a série completa, que
inclui títulos como Robótica com o Boe-Bot, sensores inteligentes e aplicações, controle
de processos, e muito mais, visite www.parallax.com/Education.
SOBRE A VERSÃO 3.0
Esta é a primeira revisão deste título desde 2004 cujas principais alterações incluem:
•
•
•
•
A substituição
do fotoresistor sulfureto de cádmio por um sensor de luz
compatível com RoHs de um tipo que vai ser mais comum no design do produto
daqui me diante. Isso exigiu revisões dos capítulos 7 e 10, e ajustes em outros
capítulos.
Aperfeiçoamento das atividades e ilustrações de controle do servo no Capítulo 4.
Mover parte do capítulo 1 “Configurações e Testes", e os apêndices de hardware
e solução de problemas para o arquivo de ajuda. Isso foi feito para suportar
conexões de hardware Serial e USB, e outras conexões de programação em
nossos produtos e na expansão de tecnologias. Isto também permite uma
manutenção dinâmica do hardware e resolução de problemas.
A remoção de referências para o CD Parallax, excluída de nosso kits, foi no
intuito de redução e desperdício para garantir que os clientes possam baixar o
mais recente software BASIC Stamp Editor e os drivers USB disponíveis para
seus sistemas operacionais.
Além disso, foram corrigidos pequenos artigos de errata notados na versão anterior
(2.2). O material ainda aponta para os mesmos objetivos, e todos os conceitos de
programação são os mesmos e os comandos são cobertos juntamente com alguns novos.
Finalmente, para facilitar a utilização, os números das páginas foram alterados para a
página em PDF e os números das páginas físicas são os mesmos para facilidade de
utilização.
PÚBLICO
Este texto foi elaborado para ser uma porta de entrada para o aprendizado da tecnologia,
e uma curva de fácil aprendizagem para implantação de programas e introdução de
robótica. O texto é organizado para ser usado pelo maior e variado número de
estudantes possível, bem como por alunos independentes. Estudantes do ensino médio
podem experimentar os exemplos, neste texto, de uma forma guiada, basta seguir as
instruções demarcadas com a supervisão do instrutor. Por outro lado, a compreensão dos
alunos de pré-engenharia e habilidades para resolver problemas podem ser testadas com
Página - 8
perguntas, exercícios e projetos (com soluções) em cada resumo de capítulo. O aluno
independente pode trabalhar em seu próprio ritmo, e obter ajuda através dos fóruns
Stamps in Class citados abaixo.
FÓRUNS DE SUPORTE
A Parallax mantém fóruns livres e moderados para nossos clientes, cobrindo uma
variedade de temas:
• Propeller Chip: para todas as discussões relacionadas com o microcontrolador
Propeller multicore e ferramentas para desenvolvimento da linha de produtos.
• BASIC Stamp: ideias de projetos, suporte e tópicos relacionados para todos os
modelos BASIC Stamp da Parallax.
• Microcontrollers SX: Assistência técnica para todos os chips SX, incluindo o
compilador SX / B e a ferramenta SX-Key.
• Sensors: Discussão relativa à ampla gama de sensores da Parallax, e interface
entre os sensores com microcontroladores da Parallax.
• Stamps in Class: estudantes, professores, clientes poderão discutir aqui materiais
educativos e projetos escolares da Parallax.
• Robotics: Para todos os robôs Parallax e robôs personalizados construídos com
processadores e sensores da Parallax.
• The Sandbox: Tópicos relacionados ao uso de produtos Parallax, somente,
inespecífico para os outros fóruns.
• Completed Projects: Publique aqui seus projetos concluídos, elaborados com os
produtos da Parallax.
• HYDRA System and Propeller Game Development: Discussão e assistência
técnica para o kit de desenvolvimento de jogo HYDRA e programação de
microcontrolador Propeller relacionado.
RECURSOS PARA EDUCADORES
Temos uma grande variedade de recursos neste texto elaborados para apoiar os
educadores.
Stamps in Class “Mini Projetos”
Para complementar nossos textos, nós fornecemos um banco de projetos para a sala de
aula. Projetado para envolver os alunos, cada “Mini Projeto" contém um completo
código de fontes, explicações de "Como ele Funciona" (“How it Works”), esquemas e
diagramas de fiação ou fotos para um dispositivo que o estudante poderá utilizar.
Muitos projetos têm um vídeo introdutório, para promover o auto estudo nos alunos
mais interessados em eletrônica e programação. Basta seguir o link Stamps in Class
“Mini Projetos " (“Mini Projects”) na www.parallax.com/Education.
Cursos para Educadores
Estes cursos, práticos e intensivos, de 1 ou 2 dias, para educadores são ministrados por
engenheiros da Parallax ou por professores experientes usando materiais educativos da
Parallax em suas salas de aula. Para mais detalhes visite → Educators Courses.
Fórum para Educadores da Parallax
Neste fórum privado, gratuito, os educadores podem fazer perguntas e compartilhar suas
experiências com o uso de produtos da Parallax em suas salas de aula. Aqui também são
Página - 9
postados materiais educativos complementares. Para se inscrever, envie um e-mail para
obter instruções para [email protected]; será necessário o envio de certificado de
educador.
Materiais Educativos Suplementares
Selecione os textos educativos da Parallax para ter um conjunto inédito de questões e
soluções postadas em nosso fórum para educadores (“Parallax Educators Forum”);
convidamos os educadores a copiar e modificar esse material à vontade para a
preparação rápida de lição de casa, questionários e testes. Aqui também podem ser
publicadas apresentações em PowerPoint e material de teste preparados por outros
educadores.
Permissões de Direitos Autorais para Uso Educacional
Não é necessário licença de instalação para o download, duplicação e instalação de
software para uso educacional com produtos Parallax como é necessário em muitas
escolas ou computadores domésticos. Nossos textos Stamps in Class e Manual BASIC
Stamp estão disponíveis gratuitamente para downloads em PDF e podem ser
reproduzidos, desde que seja para uso educacional, exclusivamente com produtos de
microcontroladores Parallax e o estudante é cobrado não mais que o custo de
duplicação. Os arquivos PDF não são fechados, possibilitando a seleção de textos e
imagens para preparar apostilas, transparências ou apresentações do PowerPoint.
TRADUÇÕES EM LINGUAS EXTRANGEIRAS
Muitos de nossos textos Stamps in Class foram traduzidos para outras línguas, estes
textos disponíveis para download gratuitamente e sujeitos a mesma permissão de
direitos autorais para uso educacional como em nossas versões originais. Para ver a lista
completa, clique nos links Tutorials & Translations em www.parallax.com / Education.
Os textos foram preparados, em coordenação com o programa de tradutores voluntários
da Parallax. Se você estiver interessado em participar do nosso programa de tradutor
voluntário, envie um e-mail para [email protected].
SOBRE O AUTOR
Andy Lindsay juntou-se a Parallax Inc. em 1999, e, desde então foi autor de oito livros e
numerosos artigos e documentos de produtos para a empresa. As três últimas versões
“Do que é um microcontrolador?” foram criadas e atualizadas com base em observações
e comentários educativos que Andy coletou enquanto viajava pelo país e pelo exterior
ministrando cursos educacionais em eventos. Andy estudou engenharia elétrica e
eletrônica na Universidade Estadual da Califórnia, Sacramento, e é um autor que
contribuiu para diversos trabalhos que abordam o tema de microcontroladores em préengenharia de currículos. Quando não está escrevendo material educativo, Andy faz
engenharia de produto e aplicação para a Parallax.
COLABORADORES ESPECIAIS
A equipe da Parallax montada para preparar esta edição inclui: departamento de
liderança e excelência por Aristides Alvarez; projeto aula e redação técnica por Andy
Lindsay; a arte é coberta por Jen Jacobs; ilustrações gráficas por Rich Allred e Andy
Lindsay; revisão técnica por Jessica Uelmen; sutilezas, edição e layout por Stephanie
Lindsay. Agradecimentos especiais a Ken Gracey, fundador do Basic Stamp no
Página - 10
programa Class, e Tracy Allen e Phil Pilgrim pela consulta na seleção do sensor de luz
utilizado nesta versão que substitui o sulfureto de cádmio fotoresistor.
Muitas pessoas, aos quais ainda estamos gratos, contribuíram com edições anteriores
para o desenvolvimento do “O que é um Microcontrolador?”. A Parallax deseja
agradecer novamente a Robert Ang por sua revisão inicial completa e detalhada e ao já
falecido veterano engenheiro e estimado cliente Sid Weaver pela revisão criteriosa.
Obrigado também aos autores de Stamps in Class Tracy Allen (Aplicação de Senhores)
e Martin Hebel (Controle de Processos) por sua revisão e recomendações. Andy
Lindsay agradece a seu pai Marshall e ao cunhado Kubilay pôr os seus conselhos
musicais especializados e sugestões.
Página - 11
Capítulo 1: Introdução
QUANTOS MICROCONTROLADORES VOCÊ VIU HOJE?
Um microcontrolador é um tipo de computador em miniatura que você pode encontrar
em todos os tipos de dispositivos eletrônicos. Alguns exemplos de produtos cotidianos,
têm microcontroladores embutidos e são mostrados na Figura 1- 1. Se eles têm botões e
um visor digital, é possível que eles também tenham um cérebro microcontrolador
programável.
Figura 1-1
Exemplos cotidianos
de dispositivos que
contenham
microcontroladores
Tente fazer uma lista contando quantos dispositivos com microcontroladores que você
usa em um dia normal. Aqui estão alguns exemplos: se o seu rádio relógio disparar de
manhã e você apertar o botão “soneca” algumas vezes, a primeira coisa que você estará
fazendo no seu dia é interagir com um microcontrolador. Aquecer um pouco de comida
no forno de micro-ondas e fazer uma chamada em um telefone celular também
envolvem interação com microcontroladores. Isso é apenas o começo. Aqui estão mais
alguns exemplos: ligar a televisão com um controle remoto manual, jogos portáteis, usar
uma calculadora. Todos esses dispositivos têm microcontroladores dentro deles que
interagem com você.
BASIC STAMP 2 – SEU NOVO MÓDULO MICROCONTROLADOR
O módulo BASIC Stamp® 2 da Parallax Inc., mostrado na Figura 1- 2, tem um
microcontrolador construído para ele, que é o chip preto mais largo. O resto dos
componentes do módulo BASIC Stamp também é encontrado em aparelhos de consumo
que você usa todos os dias. Juntos, eles são corretamente denominados sistema de
computador embutido. Este nome é quase sempre abreviado como "sistema embutido".
Esses módulos são, frequentemente, chamados de "microcontroladores".
As atividades deste texto irão guiá-lo através da construção de circuitos semelhantes aos
encontrados em eletrodomésticos e aparelhos de alta tecnologia. Você também
escreverá programas de computador que o módulo BASIC Stamp irá executar. Estes
programas farão o módulo BASIC Stamp monitorar e controlar esses circuitos para que
eles executem funções úteis.
Figura 1-2
Módulo
Microcontrolador
BASIC Stamp 2
Página - 12
Neste texto, "BASIC Stamp" refere-se ao módulo microcontrolador BASIC Stamp®
2. Projetado e fabricado pela Parallax Incorporated, o nome deste módulo é
comumente abreviado para BS2, e é o primeiro da série de módulos apresentados na
Figura 1- 3. Cada um dos outros módulos é um pouco diferente, com uma
velocidade mais elevada, mais memória, e funções extras, ou algumas combinações
destas características adicionais. Para maiores informações, siga o link "Compare
BASIC Stamp modules" em www.parallax.com/BasicStamp.
Figura 1-3
Modelos BASIC
Stamp 2, da
esquerda para a
direita: BS2, BS2E,
BS2SX, BS2P24,
BS2P40, BS2pe,
BS2px
INVENÇÕES INCRÍVEIS COM MICROCONTROLADORES BASIC STAMP
Aparelhos de consumo não são as únicas coisas que contêm microcontroladores. Robôs,
máquinas, projetos aeroespaciais e outros dispositivos de alta tecnologia também são
construídos com microcontroladores. Vamos dar uma olhada em alguns exemplos que
foram criados com módulos BASIC Stamp.
Os robôs foram projetados para fazer tudo, desde ajudar os alunos a aprender mais sobre
microcontroladores, como cortar a grama, e resolver complexos problemas mecânicos.
A Figura 1- 4 mostra um exemplo de dois robôs. Em cada um destes robôs, os alunos
utilizam o BASIC Stamp 2 para ler sensores, controlar motores e para comunicação com
outros computadores. O robô da esquerda é o robô Boe-Bot® da Parallax Inc. Os
projetos do livro Robótica com o Boe-Bot podem ser resolvidos com o Boe-Bot, depois
que você trabalhar com as atividades deste texto. O da direita é chamado de um
submarino ROV (veículo operado remotamente) e foi construído e testado no Instituto
MATE (Educação em Tecnologia Avançada da Marinha) pelos professores de verão. Os
operadores veem na TV o que o ROV vê através de uma câmera de vídeo e podem
controlá-lo com uma combinação de um controle manual e um laptop. Seu BASIC
Stamp mede a profundidade e a temperatura, controla o motor de impulsão vertical, e
troca informações com o laptop. O MATE coordena competições regionais e
internacionais de ROV para estudantes de variados níveis, desde o ensino médio até a
universidade.
Figura 1-4
Robôs educacionais
Robô Boe-Bot (à
esquerda) e
ROV no MATE pelos
professores do Instituto
de Verão (à direita,
www.marinetech.org)
Outros robôs resolvem problemas mais complexos, tais como o voo do robô autônomo
de controle remoto mostrado no lado esquerdo da Figura 1-5. Este robô foi construído e
testado por estudantes de engenharia mecânica na Universidade da Califórnia, em
Irvine. Eles usaram um módulo BASIC Stamp para ajudá-los na comunicação com um
sistema de posicionamento global por satélite (GPS), para que o robô pudesse saber a
Página - 13
sua posição e altitude. O BASIC Stamp também lê o nível de sensores e controla os
ajustes do motor para manter o robô voador corretamente. A centopeia robótica, à
direita da Figura 1-5, foi desenvolvido por um professor da Universidade Técnica de
Nanyang, de Singapura. Ele tem mais de 50 módulos BASIC Stamp a bordo, e todos
eles se comunicam uns com os outros em uma elaborada rede que ajuda a controlar e
orquestrar o movimento de cada conjunto de pernas. Robôs como esse, não só nos
ajudam a entender melhor projetos na natureza como, eventualmente, podem ser usados
para explorar locais distantes ou mesmo outros planetas.
Figura 1-5
Robôs de pesquisa
que contêm
microcontroladores
Voo do robô de
controle remoto
autônomo na UC
Irvine (à esquerda) e
do Projeto Centopeia
na Universidade de
Nanyang (à direita)
Com a ajuda de microcontroladores, os robôs também podem assumir tarefas do dia-adia, tais como cortar a grama. O módulo BASIC Stamp dentro do cortador de grama
mostrado na Figura 1-6 ajuda o robô a permanecer dentro dos limites da relva, e
também lê os sensores que detectam obstáculos e controla os motores que o fazem
mover.
Figura 1-6
Módulo
Microcontrolador
BASIC Stamp 2
Microcontroladores são também utilizados em pesquisas científicas de alta tecnologia e
projetos aeroespaciais. A estação meteorológica mostrada no lado esquerdo da Figura 17 é usada para coletar dados ambientais relacionados à degradação dos recifes de coral.
O módulo BASIC Stamp dentro dos recifes de coral reúne dados a partir de uma
variedade de sensores e armazena-os para posterior recuperação pelos cientistas. O
submarino no centro é um veículo de exploração submarina, e seus propulsores,
câmeras e luzes são todos controlados por microcontroladores BASIC Stamp. O foguete
mostrado à direita fazia parte de uma competição para lançar um foguete de propriedade
privada para o espaço. Ninguém ganhou o concurso, mas este foguete quase fez isso! O
BASIC Stamp controlou quase todos os aspectos da sequência de lançamento.
Página - 14
Figura 1-7
Exemplos de
microcontroladores
ambientais e aeroespaciais
Coleta de dados ecológicos
por Sistema EME (à
esquerda), pesquisa
submarina feita pelo Instituto
Harbor Branch (centro), e
lançamento de teste
aeroespacial JP (à direita)
De aparelhos domésticos comuns até aplicações científicas e aeroespaciais, você vai
precisar do básico de um microcontrolador para iniciar projetos como estes introduzidos
aqui. Ao trabalhar com as atividades deste livro, você vai começar a experimentar e
aprender a usar uma variedade de blocos de construção encontrada em todas essas
invenções de alta tecnologia. Você vai construir circuitos para displays, sensores e
controladores de movimento. Você vai aprender como conectar esses circuitos para o
módulo BASIC Stamp 2 e, em seguida, escrever programas de computador que o fazem
controlar movimentos, exibir e coletar dados dos sensores. Ao longo do caminho, você
vai aprender importantes conceitos e técnicas de informática e de programação
eletrônica. Quando você estiver apto, poderá perceber sozinho, um meio de inventar um
dispositivo para seu próprio projeto.
HARDWARE E SOFTWARE
Começar com módulos microcontroladores BASIC Stamp é semelhante a começar com
um novo PC ou laptop. As primeiras coisas que a maioria das pessoas tem que fazer é
tirá-lo da caixa, ligá-lo, instalar e testar alguns softwares, e talvez até mesmo escrever
algum software próprio, usando uma linguagem de programação. Se esta é sua primeira
vez usando um módulo BASIC Stamp, você vai fazer todas essas mesmas atividades. Se
você estiver em aula, o hardware poderá já estar pronto para você. Se for este o caso, o
professor pode ter outras instruções. Se não, este capítulo irá guiá-lo, passo a passo, para
que o seu novo microcontrolador BASIC Stamp ligue e funcione.
ATIVIDADE #1: OBTENDO O SOFTWARE
O BASIC Stamp Editor (versão 2.5 ou superior) é o software que você vai usar na
maioria das atividades e projetos neste texto. Você vai usar este software para escrever
programas que o módulo BASIC Stamp executará. Você também pode usar este
software para visualizar mensagens enviadas pelo BASIC Stamp que ajudam a entender
o que ele capta.
Requisitos do Sistema do Computador
Você vai precisar de um computador pessoal para executar o software BASIC Stamp
Editor. Seu computador precisa ter as seguintes características:
•
•
•
Microsoft Windows 2000 ou sistema operacional mais recente
Porta Serial disponível ou porta USB
Acesso à Internet e um navegador de Internet
Página - 15
Baixar o Software a Partir da Internet
É importante, se possível, usar sempre a versão mais recente do software BASIC Stamp
Editor. O primeiro passo é ir até o site internacional da Parallax e baixar o software (em
inglês), ou se preferir utilize o site da BS Educacional e procure por Suporte &
Downloads (www.bseducacional.com.br).
 Usando um navegador da Web, vá para www.parallax.com/basicstampsoftware
(Figura 1-8).
Figura 1-8
Página de download
do BASIC Stamp
Editor no
www.parallax.com/
basicstampsoftware
Este é o local para
fazer o download da
versão mais recente
do software, em
inglês.
 Use o “Click Here to Download” para obter a versão mais recente do software
BASIC Stamp Editor Windows (Figura 1-9).
Figura 1-9
Página de download
do software BASIC
Stamp Editor.
Clique no botão para
começar o download.
 A janela de download do arquivo será aberta, perguntando se você deseja
executar ou salvar este arquivo (Figura 1- 10). Clique em Salvar.
Página - 16
Figura 1-10
Janela do arquivo de
download
Clique em Salvar
(Save) e salve o
arquivo no seu
computador.
 Use o campo Salvar em (Save in) para escolher o local em seu computador onde
o arquivo de instalação será salvo, em seguida, clique no botão Salvar (Figura 111).
Figura 1-11
Janela Salvar como
(Save as)
Escolha um local em
seu computador para
salvar o software de
instalação, então
clique em Salvar
(Save).
 Quando o download terminar, clique em Executar (Figura 1-12.)
 Siga as instruções que aparecem. Ao aparecer mensagens do sistema operacional
pedindo para confirmar se você deseja continuar com a instalação, concorde.
Figura 1-12
Baixe a mensagem
completa
Clique em Executar
(Run).
Se for solicitado,
sempre confirme
que deseja
continuar.
 Será aberta uma janela do instalador BASIC Stamp Editor (Figura 1-13). Clique
em Avançar e siga as instruções, aceitando todos os padrões.
Página - 17
Figura 1-13
Janela do instalador
do BASIC Stamp
Editor
Clique em avançar
(Next)
 IMPORTANTE: Quando a mensagem “Instalar o Drive USB” (Install USB
Driver) for exibida (Figure 1-14), assinale a opção instalar automaticamente /
atualizar o driver (recomendado) e clique em Avançar.
Figura 1-14
Mensagem de
instalação do drive
USB
Deixe a caixa
marcada e clique
em Avançar
(Next).
 Quando a mensagem "Pronto para iniciar a Instalação” (Ready to Install the
Program) aparecer (Figura 1-15), clique no botão Instalar. Uma barra de
progresso pode aparecer, e isso pode levar alguns minutos.

Página - 18
Figura 1-15
Pronto para iniciar
a instalação
Clique em instalar
(Install) para
avançar.
Neste ponto, uma janela adicional pode aparecer atrás da janela atual, enquanto os
drivers USB estão sendo atualizados. Esta janela fechará automaticamente, quando a
instalação do driver for concluída. Caso você não veja esta janela, não significa que há
problemas.
Sobre os drivers USB. Os drivers USB instalados com o BASIC Stamp
Windows Editor são, por padrão, necessários para usar qualquer hardware
Parallax conectado à porta USB do seu computador. VCP significa em inglês
porta virtual COM e vai permitir que a porta USB do seu computador seja tratada
como uma porta serial padrão RS232 pelo hardware Parallax.
Controladores USB para diferentes sistemas operacionais. Os drivers USB
VCP inclusos no software BASIC Stamp Windows Editor são somente para
determinadas versões do sistema operacional Windows. Para maiores
informações, visite o site www.parallax.com/usbdrivers.
 Quando a janela informar que a instalação foi concluída com sucesso, clique em
Concluir (Finish) (Figura 1-16).
Figura 1-16
Instalação do
BASIC Stamp
Editor concluída
Clique em
Concluído
(Finish).
Página - 19
ATIVIDADE #2: USANDO A AJUDA PARA CONFIGURAÇÃO DO
HARDWARE
Nesta seção você vai executar o arquivo de Ajuda do BASIC Stamp Editor. Dentro do
arquivo de Ajuda você vai aprender sobre as diferentes placas de programação BASIC
Stamp, disponíveis para os programas Stamps in Class e determinar qual delas você está
usando. Então, você vai seguir os passos da ajuda para conectar o seu hardware ao seu
computador e testar o seu sistema de programação BASIC Stamp.
Executando o Editor do BASIC Stamp pela primeira vez
 Se você ver o ícone do BASIC Stamp Editor no seu desktop, clique duas vezes
nele (Figura 1-17).
 Ou, clique no menu Iniciar do seu computador, em seguida selecione Programas
 Parallax Inc  BASIC Stamp Editor 2.5  BASIC Stamp Editor 2.5.
Figura 1-17
BASIC Stamp Editor
Desktop Icon
Dê um duplo clique
para iniciar o
programa.
 Na barra de ferramentas do BASIC Stamp Editor clique em Ajuda (Help) na
barra de ferramentas (Figura 1-18) e selecione BASIC Stamp Help.
Figura 1-18
Abrindo o menu Ajuda
(Help)
Clique Ajuda (Help), e
escolha o BASIC
Stamp Help a partir do
menu drop-down.
Página - 20
Figura 1-19: Menu Ajuda do BASIC Stamp Editor
 Clique no link “Começando com Stamps in Class” (“Getting Started with
Stamps in Class”) na parte inferior da página Bem-vindo (Welcome) como
mostrado no canto inferior direito da Figura 1-19.
Seguindo as Instruções do Arquivo de Ajuda (HELP)
A partir daqui, você vai seguir as instruções do arquivo de Ajuda para completar estas
tarefas:
•
•
•
•
•
•
Identificar qual placa de desenvolvimento BASIC Stamp você está usando
Ligar sua placa de desenvolvimento ao seu computador
Testar sua conexão de programação
Solucionar problemas de sua conexão de programação, se necessário
Escrever seu primeiro programa PBASIC para seu BASIC Stamp
Desligar seu hardware quando terminar
Quando você tiver concluído as atividades no arquivo de Ajuda, retorne para o livro e
continue com o sumário abaixo antes de passar para o Capítulo 2.
Página - 21
O que eu faço se eu ficar preso em alguma parte?
Se você tiver problemas ao seguir as instruções neste livro ou no arquivo Ajuda,
você tem muitas opções para obter suporte técnico gratuito:
•
Fóruns: inscreva-se e poste uma mensagem gratuitamente para nós no
fórum Stamps in Class em forums.parallax.com (em inglês) ou na
Central
de
Aprendizado
da
BS
Educacional
(www.bseducacional.com.br).
•
E-mail:
mande
um
e-mail
para
[email protected]
ou
[email protected] para suporte em português.
•
Telefone: Brasil – ligue para (011) 2533-9478 ou Estados Unidos - +1
888-99-STAMP (888 997-8267). Ou outros ligue para (916) 624-8333.
•
Mais
recursos:
Visite
www.parallax.com/support
www.bseducacional.com.br/Central de Aprendizado
ou
SUMÁRIO
Este capítulo guiou você através do seguinte:
• Uma introdução a alguns dispositivos que contêm microcontroladores
• Introdução ao módulo BASIC Stamp
• Tour por algumas invenções interessantes feitas com módulos BASIC Stamp
• Onde obter o software gratuito BASIC Stamp Editor que você vai usar em
praticamente todas as experiências neste texto
• Como instalar o software BASIC Stamp Editor
• Como usar o módulo BASIC Stamp, Board of Education, e HomeWork Board
• Como configurar o hardware BASIC Stamp
• Como testar seu software e hardware
• Como escrever e executar um programa PBASIC
• Usando os comandos DEBUG e END
• Usando o CR caractere de controle e DEC formatador
• Breve introdução ao código ASCII
• Como desligar a alimentação do seu Board of Education e HomeWork Board
quando terminar suas atividades.
Questões
1. Que é o microcontrolador?
2. BASIC Stamp é um módulo microcontrolador, ou ele contém um?
3. Que pistas você procuraria para descobrir se um aparelho como um rádio relógio
ou um telefone celular contém um microcontrolador?
4. Que significa um apóstrofo no início de uma linha de um código em um
programa PBASIC e o que esse código significa?
5. Que comandos PBASIC você aprendeu neste capítulo?
6. Vamos dizer que você queira fazer uma pausa em seu projeto BASIC Stamp
para ir fazer um lanche, ou talvez você queira dar uma pausa maior e retornar
somente após alguns dias. O que você faria antes desta pausa?
Exercícios
1. Explique o significado do asterisco neste comando: DEBUG DEC 7 * 11
Página - 22
2. Adivinhe o que o Debug Terminal iria mostrar se você executasse este comando:
DEBUG DEC 7 + 11
3. Existe um problema com esses dois comandos. Quando você executa o código,
os números que aparecem estão travados, parecendo assim que há um grande
número em vez de dois pequenos. Deve-se modificar esses dois comandos para
que as respostas apareçam em linhas diferentes no DEBUG Terminal.
DEBUG DEC 7 * 11
DEBUG DEC 7 + 11
Projetos
1. Use o DEBUG para mostrar a solução do problema de cálculo: 1 + 2 + 3 + 4.
2. Salve seu primeiro programa YourTurn.bs2 com um outro nome. Se você
colocasse o comando DEBUG mostrado na linha abaixo antes do comando END,
que outras linhas você poderia deletar e ainda assim tê-lo funcionando?
Modifique a cópia do programa para testar as suas hipóteses (sua previsão do
que irá acontecer).
DEBUG "Quanto é 7 X 11?", CR, " A resposta é: ", DEC 7 * 11
Soluções
Q1. Um microcontrolador é um tipo de computador em miniatura encontrado em
produtos eletrônicos.
Q2. O módulo BASIC Stamp contém um chip microcontrolador.
Q3. Se o aparelho tem botões e um visor digital, é um bom indício de que ele tenha
um microcontrolador dentro dele.
Q4. Um comentário.
Q5. DEBUG e END
Q6. Desligue a energia do projeto BASIC Stamp.
Isto multiplica os dois operadores 7 e 11, resultando 77. O asterisco é o operador de
multiplicação.
O DEBUG Terminal iria mostrar: 18
Para solucionar o problema, acrescente o comando de controle CR seguido de uma vírgula.
DEBUG DEC 7 * 11
DEBUG CR, DEC 7 + 11
P1. Aqui está um programa para a solução do cálculo matemático: 1 +2 +3 +4.
' O que é um microcontrolador? - Ch01Prj01_Add1234.bs2
'{$STAMP BS2}
'{$PBASIC 2.5}
DEBUG "Quanto é 1+2+3+4?"
DEBUG CR, "A resposta é: "
DEBUG DEC 1+2+3+4
END
Página - 23
P2. As ultimas três linhas do DEBUG podem ser deletadas. Um adicional CR será
preciso depois da mensagem “Olá” ("Hello").
' O que é um microcontrolador? - Ch01Prj02_ FirstProgramYourTurn.bs2
' BASIC Stamp mandará a mensagem para o Debug Terminal.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Olá, sou eu” (Hello, it is me”), seu BASIC Stamp!” CR
DEBUG " Quanto é 7 X 11?", CR, "A resposta é: ", DEC 7 * 11
END
A saída do DEBUG Terminal é:
Olá, sou eu, seu BASIC Stamp!
Quanto é 7 X 11?
A resposta é: 77
Esta saída é a mesma do código anterior. Este é um exemplo do uso de vírgulas para
produzir uma grande quantidade de informações, usando apenas um comando DEBUG
com vários elementos nele.
Página - 24
Capítulo 2: Luzes Acesas e Apagadas (On e Off)
LUZES INDICADORAS
Luzes indicadoras são tão comuns que a maioria das pessoas tendem a não dar-lhes
muita atenção. A Figura 2-1 mostra três luzes indicadoras em uma impressora a laser.
Dependendo de qual luz está acesa, a pessoa que usa a impressora sabe se ela está
funcionando corretamente ou não. Aqui estão apenas alguns exemplos de dispositivos
com luzes indicadoras: aparelhos de som de automóveis, televisores, aparelhos de DVD,
discos rígidos, impressoras e painéis de controle do sistema de alarme.
Figura 2-1
Luzes indicadoras
Luzes indicadoras
são comuns em
muitos dispositivos
diários.
Tornar uma luz indicadora on e off é uma simples questão de ligar e desligar a partir de
uma fonte de energia. Em alguns casos, a luz indicadora está ligada diretamente à
bateria ou a fonte de alimentação, como no indicador de alimentação no Board of
Education. Outras luzes indicadoras são ligadas e desligadas por um microcontrolador
dentro do dispositivo. Este é o status das luzes indicadoras que indicam o que o aparelho
está fazendo.
FAZENDO UM DIODO EMISSOR DE LUZ (LED) EMITIR LUZ
A maioria das luzes indicadoras que você vê nos dispositivos é chamada de diodos
emissores de luz. Você, frequentemente, verá em livros e diagramas de circuitos, um
diodo emissor de luz abreviado pelas letras LED. O nome geralmente é pronunciado
como três letras: "L-E-D". Você pode construir um circuito de LED, ligá-lo a energia, e
o LED emitirá luz. Se você desligar a energia do circuito de LED ele cessará de emitir
de luz.
Um circuito de LED pode ser ligado ao BASIC Stamp, e o BASIC Stamp pode ser
programado para ligar e desligar a alimentação do circuito de LED. Isto é muito mais
fácil do que mudar manualmente a fiação do circuito ou ligar e desligar a bateria. O
BASIC Stamp também pode ser programado para fazer o seguinte:
•
•
•
•
Acender e apagar os LEDs de um circuito em ritmos diferentes
Acender e apagar os LEDs de um circuito um número específico de vezes
Controlar mais de um circuito de LED
Controlar a cor de um circuito de LED bicolor (duas cores)
Página - 25
ATIVIDADE #1: CONSTRUINDO E TESTANDO UM CIRCUITO DE LED
É importante testar os componentes individualmente, antes de construí-los em um
sistema maior. Esta atividade se concentra na construção e teste de dois circuitos de
LED diferentes. O primeiro circuito é o que faz com que o diodo emissor de luz emita
luz. O segundo circuito é o que faz com que ele não emita luz. Na atividade que vem
depois desta primeira, você vai construir o circuito de LED em um sistema maior,
ligando-o ao BASIC Stamp. Então você vai escrever programas que fazem o BASIC
Stamp provocar o LED a emitir ou não luz. Nos primeiros testes de cada circuito de
LED você só vai ter certeza de que ele está funcionando se conectá-lo a um BASIC
Stamp.
Apresentando o Resistor
Um resistor é um componente que "resiste" ao fluxo de eletricidade. Este fluxo de
eletricidade é chamado de corrente. Cada resistor tem um valor que mostra o quanto ele
resiste ao fluxo de corrente. Este valor de resistência é chamado de ohm, e o sinal para o
ohm é a letra grega ômega: Ω. Mais tarde, neste livro você verá o símbolo kΩ, ou seja,
“kilo-ohm”, ou mil ohms. O resistor que você estará trabalhando nesta atividade é o
resistor 470 Ω mostrado na Figura 2-2. A resistência tem dois fios (chamados de
“leads” e pronuncia-se "liids"), cada um saindo de uma extremidade. Há um caixa de
cerâmica entre os dois terminais, é a parte que resiste à passagem da corrente. A maioria
dos diagramas de circuitos que mostram resistências usam o símbolo que está
representado abaixo, do lado esquerdo, com as linhas em zig-zag para informar a pessoa
que na montagem do circuito ela deverá usar um resistor de 470 Ω. Isto é chamado de
“símbolo esquemático”. O desenho da direita é um desenho da peça utilizada em alguns
de nossos produtos de nível iniciante, em textos Stamp in Class para ajudar a construir
circuitos.
Gold
Silver
or
Blank
470 Ω
Yellow
Violet
Brown
Figura 2-2
Desenho de um resistor de 470 Ω
Símbolo Esquemático (à
esquerda) e o desenho (à direita)
Os resistores que estamos usando nesta atividade têm listras coloridas que indicam quais
são os valores de resistência. Há uma combinação de cor diferente para cada valor de
resistência. Por exemplo, o código de cores para a resistência de 470 Ω é amarelovioleta-marrom.
Pode haver uma quarta faixa que indica a tolerância do resistor. A tolerância é medida
em porcentagem, e mostra a distância que a resistência real está da resistência rotulada.
A quarta faixa pode ser dourada (5%), prateada (10%) ou sem tarja (20%). Para as
atividades deste livro, a tolerância de um resistor não importa, mas sim o seu valor.
Cada barra de cores que informa o valor do resistor corresponde a um dígito, e essas
cores/dígitos estão listados na Tabela 2-1. A Figura 2-3 mostra como usar cada barra de
cor com a tabela para determinar o valor de um resistor.
Página - 26
Tabela 2-1
Cores do Resistor e Código
Valores
Dígito
Cor
0
1
2
3
4
5
6
7
8
9
Preto
Marrom
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco
Tolerance
Code
First Digit
Number of Zeros
Second Digit
Figura
2-3
Tabela
de
cores
do
resistor
Aqui está um exemplo que mostra como a Tabela 2-1 e a Figura 2-3 podem ser usadas
para descobrir o valor de um resistor, provando que o amarelo-violeta-marrom é
realmente 470 Ω:
•
•
•
A primeira faixa é amarela, o que significa que o dígito mais à esquerda é um 4.
A segunda faixa é violeta, o que significa que o próximo dígito é 7.
A terceira faixa é marrom. Se marrom é 1, significa que apenas um zero deverá
ser adicionado à direita dos dois primeiros números.
amarelo-violeta-marrom= 4-7-0 = 470 Ω.
Apresentando o LED
Um diodo é uma válvula de uma via de corrente, e um diodo emissor de luz (LED)
emite luz quando a corrente passa através do mesmo. Ao contrário dos códigos de cores
em um resistor, a cor do LED, apenas diz-lhe qual a cor que vai brilhar quando a
corrente passar por ele. As marcas importantes em um LED estão contidas na sua forma.
Uma vez que um LED é uma válvula unidirecional, você deve conectá-lo da maneira
correta, ou não funcionará como previsto.
A Figura 2-4 mostra o símbolo esquemático de um LED e o desenho da peça. Um LED
tem dois terminais. Um é chamado de “ânodo”, e o outro é chamado de “cátodo”. Nesta
atividade, você vai ter que construir o LED em um circuito, e você deve prestar atenção
e certificar-se de que as ligações de ânodo e cátodo estão conectadas ao circuito de
forma adequada. No desenho da peça, o ânodo é rotulado com o sinal de mais (+). No
símbolo esquemático, o ânodo é a parte larga do triângulo. Neste desenho da peça, o
cátodo é o pino que não está marcado, e no símbolo esquemático, o cátodo é a linha
sobre o triângulo.
Página - 27
Figura 2-4
Desenho da peça e símbolo
esquemático do LED
Desenho da peça (acima) e
símbolo esquemático (abaixo).
Nos desenhos daqui em diante, o
LED apresentará um “+” ao lado
da perna do ânodo.
+
LED
Quando você começar a construir seu circuito, não se esqueça de verificar se ele está de
acordo com o símbolo esquemático e o desenho da peça. Observe no desenho da peça os
diferentes comprimentos do LED. O condutor longo é ligado ao ânodo do diodo emissor
de luz, e o mais curto é ligado ao seu cátodo. E também, se você olhar com atenção para
a parte plástica do LED, é possível ver uma parte plana próxima a perna mais curta que
informa que esse é o cátodo. Isso realmente vem a calhar se os fios forem cortados com
o mesmo comprimento.
Peças Para Teste do Circuito de LED
(1) LED – verde
(1) Resistor – 470 Ω (amarelo-violeta-marrom)
Identificar as peças: Além dos desenhos de peças na Figura 2-2 e Figura 2-4,
você pode usar a foto na última página do livro para ajudar a identificar as peças
do kit, necessárias para esta e todas as outras atividades.
Construindo o Circuito de Teste do LED
Você irá construir um circuito, ligando os fios do LED e uma resistência, a pequenos
orifícios denominados soquetes na área de prototipagem mostrada na Figura 2-5. Esta
área de prototipagem tem soquetes pretos na parte superior e no lado esquerdo. Os
soquetes pretos no topo têm os seguintes rótulos sobre eles: Vdd (+5 V), Vin
(Tensão desregulada direto da sua bateria ou fonte de alimentação) e Vss (0 V, também
chamado de terra). Estes são chamados terminais de potência, e serão usados para
fornecer eletricidade a seus circuitos. Os soquetes pretos à esquerda têm rótulos como
P0, P1 a P15. Estes soquetes serão usados para ligar o circuito de entrada/saída dos
pinos do módulo BASIC Stamp.
Página - 28
Vdd
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
Figura 2-5
Área de prototipagem
Terminais de alimentação
(soquetes pretos no topo),
Acesso dos pinos de I/O
(soquetes pretos na lateral), e
placa de montagem sem solda
(soquetes brancos)
Pinos de entrada/saída são geralmente chamados de pinos de I/O; depois de ligar
seu circuito a um ou mais desses pinos de I/O, você pode programar o BASIC
Stamp para monitorar o circuito (entrada) ou enviar sinais on ou off para o
circuito (output). Na próxima atividade você vai tentar isto.
A placa de montagem branca com vários furos, é chamada de protoboard livre de
soldas. Você usará o protoboard para conectar componentes uns aos outros e construir
circuitos. Esta placa tem17 linhas de soquetes. Cada linha contém dois grupos de cinco
soquetes separados por um pequeno vão. Todos os soquetes num grupo de 5 estão
conectados. Então, se você ligar dois fios no grupo de 5 soquetes, eles vão fazer o
contato elétrico. Por outro lado, dois fios na mesma linha, mas em lados opostos do vão,
não serão ligados. Muitos dispositivos são projetados para serem conectados em
soquetes separados pelo vão, como, por exemplo, o botão que vamos usar no Capítulo 3.
Mais sobre placas: Para saber mais sobre a história das placas, como as placas
modernas são construídas e como usá-las, consulte os recursos de vídeo no link
www.parallax.com/go/WAM.
A Figura 2-6 mostra um diagrama esquemático do circuito, e uma figura de como o
circuito deve parecer quando ele é construído no protoboard. Cada grupo de 5 soquetes
pode conectar até cinco ligações, ou fios, uns aos outros. Para este circuito, o resistor e o
LED estão ligados, pois cada um tem um fio ligado ao mesmo grupo 5 de soquetes.
Note que um fio do resistor é ligado a VDD (+5 V) de modo que o circuito possa obter
energia. O outro fio de resistência é ligado ao fio do ânodo do diodo emissor de luz. O
fio do cátodo do diodo emissor de luz é ligado a Vss (0 V, terra) completando o circuito.
Agora você está pronto para construir o circuito mostrado na Figura 2- 6 (abaixo),
ligando os fios de LED e resistor em soquetes na área de prototipagem. Siga estes
passos:
 Desligue a energia do Board of Education ou do HomeWork Board.
 Use a Figura 2-4 para decidir qual fio está ligado ao cátodo do diodo emissor de
luz. Procure o fio mais curto e a parte plana na parte plástica do LED.
 Ligue o cátodo do LED em um dos soquetes pretos rotulados “Vss” na área de
prototipagem.
 Ligue o ânodo do LED (o outro fio mais longo) no soquete mostrado no
protoboard.
Página - 29
 Ligue um dos fios do resistor ao mesmo grupo de 5 soquetes como no ânodo do
LED. Isto irá ligar os dois fios juntos.
 Ligue outro fio do resistor em um dos soquetes rotulado “Vdd”.
A direção importa para o LED, mas não para o resistor. Se você conectar o LED
da maneira incorreta, ele não emitirá luz quando a energia for ligada. A
resistência apenas resiste ao fluxo de corrente. Não existe para trás ou para frente
em um resistor.
 Reconecte a energia do Board of Education ou do HomeWork Board.
 Cheque para ter certeza se o seu LED verde está emitindo luz. Ele deverá estar
emitindo luz verde.
Vdd
Vdd
X3
470 Ω
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 2-6
LED acesso, ligado diretamente a
energia
Esquemático (esquerda) e
Diagrama de fiação (direita).
Note-se que um fio do resistor e
do ânodo do LED verde estão
conectados no mesmo grupo de
5 soquetes. Isto liga
eletricamente os dois
componentes.
Se o LED verde não emite luz quando você ligar a energia da placa:
 Alguns LEDs são mais brilhantes quando visto de cima. Tente olhar para baixo
estando logo acima do corpo plástico do LED.
 Se a sala for muito clara, tente apagar algumas luzes, ou usar as mãos para
projetar uma sombra sobre o LED.
Se você ainda não viu nenhuma luz verde, experimente estes passos:
 Verifique novamente se cátodo e o ânodo do LED estão conectados
corretamente. Se não, basta remover o LED, girá-lo 180º, e ligá-lo novamente. O
LED não será afetado se você ligá-lo ao contrário, somente não emitirá luz.
 Quando você ligar o LED na direção certa, ele deverá emitir luz.
 Verifique novamente se você construiu seu circuito exatamente como mostrado
na Figura 2-6.
 Se você estiver usando um kit que alguém usou antes de você, o LED pode estar
danificado, então tente um diferente.
 Se você estiver em uma aula de laboratório, peça ajuda para o seu instrutor.
Ainda está empacado? Experimente estes recursos gratuitos on-line:
Visite os fóruns Stamps In Class: Se você não tiver um instrutor ou amigo que
possa lhe ajudar, você pode sempre checar no fórum Stamps in Class no link
http://forums.parallax.com. Se você não tirar suas dúvidas lá, você poderá
contatar o departamento de Suporte Técnico Parallax, seguindo o link suporte
(Support) no site www.parallax.com.
Página - 30
Como Funciona o Teste do Circuito LED
Os terminais Vss e Vdd fornecem pressão elétrica da mesma maneira que uma bateria
faria. As tomadas Vdd são como terminal positivo da bateria, e os soquetes de VSS, são
como terminais negativos da bateria. A Figura 2-7 mostra como é a aplicação de pressão
a um circuito elétrico através de uma bateria e o que faz com que elétrons fluam através
dele. Este fluxo de elétrons é chamado de corrente elétrica, ou apenas corrente. A
corrente elétrica é limitada pela resistência. Esta corrente faz com que o diodo emita luz.
+
_
--- - N--N
N
-
-
-
N N
+++
+++
+++
Figura 2-7
Fluxo de elétrons em um circuito
de LED
-
N
+
+
=
N
-
-
-
-
-
-
-
-
-
Os sinais de menos com os
círculos em torno deles são
utilizados para mostrar os
elétrons fluindo do terminal
negativo da bateria ao terminal
positivo.
Reações químicas dentro da bateria alimentam o circuito com fornecimento de
corrente. O terminal negativo da bateria contém um composto que tem moléculas
com elétrons extras (mostrado na Figura 2-7 por sinais de menos). O terminal
positivo da bateria tem um composto químico que tem moléculas com elétrons a
menos (mostrado por sinais de mais). Quando um elétron deixa uma molécula no
terminal negativo e viaja através do fio, é chamado de elétron livre (também
mostrado por sinal de menos). A molécula que perdeu o elétron extra não tem
mais uma carga extra negativa, agora chamada de neutra (indicado por um N).
Quando um elétron alcança o terminal positivo, ele se junta a molécula com
elétrons a menos, e agora aquela molécula se torna neutra também.
A Figura 2-8 mostra como o fluxo de eletricidade através do circuito de LED é descrito
usando a notação esquemática. A pressão em todo o circuito elétrico é chamada de
tensão. Os sinais + e - são usados para mostrar a tensão aplicada a um circuito. A seta
mostra a corrente que flui através do circuito. Esta seta é quase sempre mostrada
apontando para a direção oposta do fluxo real de elétrons. Benjamin Franklin não
acreditava, pois não tinha conhecimento sobre elétrons, quando ele decidiu representar o
fluxo de corrente de carga que passa do positivo para o terminal negativo de um
circuito. Quando os físicos descobriram a verdadeira natureza da corrente elétrica, a
convenção já estava bem estabelecida.
Voltage
+
Vdd
Resistance
Figura 2-8
LED aceso, circuito esquemático
mostrando tensão convencional e
fluxo de corrente
Current
LED
Voltage
-
Vss
Os sinais + e - mostram a tensão
aplicada ao circuito, e a seta
mostra o fluxo de corrente
através do circuito.
Página - 31
Um desenho esquemático (como na Figura 2-8) é uma imagem que explica como
um ou mais circuitos são ligados. Esquemas são usados por estudantes,
entusiastas da eletrônica, eletricistas, engenheiros e praticamente todos que
trabalham com circuitos.
Apêndice B: Mais sobre eletricidade – este apêndice contém alguns termos do
glossário e uma atividade que você pode tentar para se familiarizar mais com as
medições de tensão, corrente e resistência.
Sua Vez – Modificando o Teste do Circuito LED
Na próxima atividade, você vai programar o BASIC Stamp para ligar o LED, em
seguida, desligá-lo e ligá-lo novamente. O BASIC Stamp vai fazer isso para mudar o
circuito de LED entre duas conexões diferentes, Vdd e Vss. Você terminará seu trabalho
com circuitos quando o resistor estiver ligado a VDD e o LED emitir luz. Faça as
alterações apresentadas na Figura 2-9 para verificar se o LED será desligado (não emite
luz) quando a ligação do resistor for desconectada do Vdd e conectada a VSS.
 Desligue a energia do Board of Education ou do HomeWork Board.
 Desligue o fio do resistor que está ligado no soquete Vdd, e ligue-o a um soquete
Vss como mostrado na Figura 2-9.
 Reconecte a energia do Board of Education ou do HomeWork Board.
 Verifique se o LED verde não está emitindo luz. Não deverá estar brilhando a
luz verde.
Por que os LEDs não brilham? Uma vez que ambas as extremidades do circuito
estão ligadas à mesma tensão (Vss), não há qualquer pressão em todo o circuito
elétrico. Assim, nenhuma corrente flui através do circuito e o LED permanece
desligado.
Vdd
X3
470 Ω
Vss
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 2-9
Circuito de LED
Apagado
Esquemático
(esquerda) e diagrama
de fiação (direita).
ATIVIDADE #2: CONTROLE DE ON/OFF COM O BASIC STAMP
Na Atividade #1, dois circuitos foram construídos e testados. Um circuito fez o LED
emitir luz enquanto o outro não. Figura 2-10 mostra como o BASIC Stamp pode fazer a
mesma coisa se você conectar um circuito de LED a um de seus pinos de I/O. Nesta
atividade, você vai ligar o circuito de LED para o BASIC Stamp e programá-lo para
Página - 32
ligar o LED on e off. Você também vai experimentar com programas que fazem o
BASIC Stamp fazer isso em velocidades diferentes.
SOUT
1
24
VIN
SIN
2
23
VSS
RES
ATN
3
22
RES
VDD (+5V)
VSS
4
21
VDD (+5V)
20
P15
19
P14
18
P13
SOUT
1
24
VIN
SIN
2
23
VSS
ATN
3
22
VSS
4
21
20
P15
P0
5
19
P14
P1
6
18
P13
P2
7
BS2
Vdd
BS2
Vdd
P0
5
P1
6
P2
7
P3
8
17
P12
P3
8
17
P12
P4
Vss
Vss
9
16
P11
P4
9
16
P11
P5 10
15
P10
P5 10
15
P10
P6
11
14
P9
P6
11
14
P9
P7 12
13
P8
P7 12
13
P8
O BASIC Stamp pode
ser programado para
ligar internamente a
entrada do circuito de
LED para VDD ou
VSS.
BS2-IC
BS2-IC
Figura 2-10
BASIC Stamp
Comutação
Existem duas grandes diferenças entre mudar a conexão manualmente e deixando o
BASIC Stamp fazer isso. Primeiro, o BASIC Stamp não tem que cortar a energia da
placa de alimentação, quando se muda a alimentação do circuito de LED de Vdd para
Vss. Em segundo lugar, enquanto um ser humano pode fazer essa mudança várias vezes
por minuto, o BASIC Stamp pode fazê-la milhares de vezes por segundo!
Peças de Teste do Circuito de LED
As mesmas da Atividade #1.
Conectando o Circuito de LED ao BASIC Stamp
O circuito de LED mostrado na Figura 2-11 é ligado quase do mesmo modo que o
circuito no exercício anterior. A diferença é que o fio do resistor que foi trocado
manualmente entre Vdd e Vss está agora ligado a um pino de I/O do BASIC Stamp.
 Desconecte a energia do Board of Education ou do HomeWork Board.
 Modifique o circuito que você estava trabalhando na Atividade #1 para que ele
corresponda ao da Figura 2-11.
Vdd
P14
X3
470 Ω
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 2-11
Circuito de LED
controlado pelo
BASIC Stamp
A entrada do
circuito de LED
está agora ligada a
um pino BASIC
Stamp I/O em vez
de Vdd ou Vss.
Resistores são essenciais. Lembre-se sempre de usar um resistor. Sem ele, muita
corrente fluirá através do circuito o que pode danificar diversas peças em seu
circuito BASIC Stamp, Board of Education ou HomeWork Board.
Página - 33
Acendendo e Apagando o LED com um Programa
O programa de exemplo, faz com que o diodo emissor de luz pisque, acendendo e
apagando, uma vez por segundo. Ele introduz várias novas técnicas de programação ao
mesmo tempo. Após executá-lo, você vai ler explicações de diferentes partes do
programa para entender melhor como ele funciona.
Exemplo de Programa: LedOnOff.bs2





Coloque o código LedOnOff.bs2 no Basic Stamp Editor.
Reconecte a energia do Board of Education ou do HomeWork Board.
Execute o programa.
Verifique se o LED pisca on e off uma vez por segundo.
Desconecte a energia quando o programa estiver concluído.
' O que é um Microcontrolador - LedOnOff.bs2
' Acenda e apague o LED. Repete uma vez por segundo indefinidamente.
'{$STAMP BS2}
'{$PBASIC 2.5}
DEBUG "O LED conectado a P14 está piscando!"
DO
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
LOOP
Como Funciona o LedOnOff.bs2
O comando DEBUG “O LED conectado a P14 está piscando!” faz esta
declaração aparecer no DEBUG Terminal. O comando HIGH 14 fará o BASIC Stamp
conectar internamente o pino I/O P14 para Vdd. Isso fará o LED ficar aceso (on).
O comando PAUSE 500 fará o BASIC Stamp não fazer nada por meio segundo até o
LED acender. O número 500 chamará o comando PAUSE para esperar 500/1000 por
segundo. O número que acompanhará o PAUSE é chamado de argumento. Argumentos
dão ao PBASIC a informação que ele precisa para trabalhar. Se você procurar PAUSE no
manual BASIC Stamp, você irá descobrir que esse número é chamado de argumento
Duration. O nome Duration foi escolhido para esse argumento para mostrar que o
comando PAUSE significa pausa por uma certa duração (“duration”) de tempo em
milésimos de segundos.
O que é milésimo de segundos? É um segundo dividido por mil e é abreviado
“ms”. São necessários 1000 ms para igualar a um segundo.
O comando LOW 14 fará o BASIC Stamp conectar internamente o pino I/O P14 para
Vss. Isso fará com que o LED fique off. Desde que o LOW 14 esteja acompanhado por
um outro PAUSE 500, o LED ficará off por meio segundo.
Página - 34
O motivo da constante repetição do código é porque está encaixado entre as palavras
chaves do PBASIC DO e LOOP. Figura 0-12 mostra como DO…LOOP funciona. Ao
colocar o segmento do código que gira o LED on e off com pausas entre DO e LOOP,
chamará o BASIC Stamp a executar esses quatro comandos constantemente. O
resultado será que o LED piscará on e off, repetidamente até que você desligue a
alimentação, pressione e segure o botão Reset, ou até que a bateria descarregue. Códigos
que repetem um conjunto de comandos, indefinidamente, são chamados “loop infinito”.
DO
HIGH 14
PAUSE 250
LOW 14
PAUSE 250
Figura 2-12
DO…LOOP
O código entre as palavras-chave
DO e LOOP é executado
repetidas vezes indefinidamente.
LOOP
Um Teste de Diagnóstico para o Seu Computador
Embora não seja comum, existem alguns sistemas de computadores, tais como certos
“laptops” e “docking stations”, que vão interromper o programa PBASIC depois da
primeira vez através de um DO...LOOP. Esses computadores têm um design de porta
serial não-padrão. Ao colocar um comando DEBUG no programa LedOnOff.bs2, o
DEBUG Terminal aberto evita que isso possivelmente aconteça. Na próxima atividade
reexecute esse programa sem o comando DEBUG para verificar se o seu computador tem
este problema de porta serial não-padrão. Não é comum, mas seria importante você
saber.
 Abra o programa LedOnOff.bs2.
 Delete todo o comando DEBUG.
 Execute e modifique o programa enquanto você observa o LED.
Se o LED piscar on e off continuamente, tal como aconteceu quando você executou o
programa original com o comando DEBUG, o computador não tem esse problema.
Se o LED piscar on e off apenas uma vez, e parar, significa que você tem um
computador com um design de porta serial não-padrão. Se você desconectar o cabo
serial da sua placa e pressionar o botão Reset, o BASIC Stamp vai executar o programa
corretamente, sem congelamento. Nos programas que você escrever, você sempre terá
que adicionar um único comando DEBUG:
DEBUG “Programa em andamento!”
… logo após as diretivas do compilador. Ele vai abrir o DEBUG Terminal e manter a
porta COM aberta. Isso impedirá que os programas congelem após uma passagem pelo
DO...LOOP, ou quaisquer outros comandos de looping que você aprenderá nos
capítulos posteriores. Você vai ver esse comando em alguns dos exemplos de programas
que não precisam de uma instrução de DEBUG. Assim, você será capaz de executar todos
os programas restantes deste livro, mesmo se o computador falhar no teste de
Página - 35
diagnóstico, mas, nesse caso, não se esqueça de adicionar um comando curto de DEBUG
quando você começar a escrever seus próprios programas.
Sua vez – Cronometragem e Repetições
Mudando argumento Duration do comando PAUSE você pode alterar a quantidade de
tempo que o LED permanece ligado e desligado. Por exemplo, alterando os argumentos
Duration para 250, ele fará com que o LED pisque e desligue duas vezes por segundo.
O DO...LOOP em seu programa agora vai ficar assim:
DO
HIGH 14
PAUSE 250
LOW 14
PAUSE 250
LOOP
 Abrir LedOnOff.bs2 e salvar uma cópia como LedOnOffYourTurn.bs2.
 Mudar ambos: comando PAUSE e argumento Duration de 500 para 250, e
reexecutar o programa.
Se você quer fazer o LED piscar on e off uma vez a cada três segundos, com o tempo
“low” duas vezes maior do que o “high”, você pode programar o comando PAUSE,
usando o PAUSE 1000 após o comando HIGH, para que ele leve apenas um segundo. O
comando PAUSE após o comando LOW 14 terá que ser PAUSE 2000.
DO
HIGH 14
PAUSE 1000
LOW 14
PAUSE 2000
LOOP
 Modifique e reexecute o programa usando o trecho de código acima.
 Uma experiência divertida é ver o quanto você pode deixar as pausas mais curtas





e ainda ter o LED piscando. Quando o LED estiver piscando muito rápido, mas
parecer que ele está simplesmente aceso, é chamado de persistência de visão.
Como testar e ver qual é a sua persistência de visão.
Tente modificar os argumentos Duration de seu comando de PAUSE para que
eles sejam 100.
Reexecute seu programa e cheque a oscilação.
Reduza ambos os argumentos Duration por 5 e tente novamente.
Mantenha sempre reduzindo os argumentos Duration até que o LED pareça estar
ligado o tempo todo, sem oscilação. Ficará mais escuro do que o normal, mas
não deve parecer que pisca.
Página - 36
Uma última coisa a fazer é criar um pisca-pisca de LED de uma única piscada. Quando
o programa é executado, o LED pisca apenas uma vez. Esta é uma maneira de olhar
para a funcionalidade do DO...LOOP. Você pode remover temporariamente o DO...
LOOP do programa, colocando um apóstrofo a esquerda, de ambas as palavras chaves do
DO e do LOOP como mostrado abaixo.
' DO
HIGH 14
PAUSE 1000
LOW 14
PAUSE 2000
' LOOP
 Modifique e reexecute o programa usando o trecho de código acima.
 Explique por que o LED piscou uma só vez?
Comentando uma linha de código: Colocar um apóstrofo à esquerda de um
comando é transformá-lo em um comentário. Esta é uma ferramenta útil, porque
na verdade você não tem que apagar o comando para ver o que acontecerá se
você removê-lo do programa. É muito mais fácil adicionar e remover um
apóstrofo do que apagar e digitar novamente os comandos.
ATIVIDADE #3: CONTANDO E REPETINDO
Na atividade anterior, ou o circuito de LED piscava on e off o tempo todo, ou piscava
uma única vez e parava. E se você quiser que o LED pisque e desligue dez vezes?
Computadores (incluindo o BASIC Stamp) são ótimos para manter a totalidade de
funcionamento de quantas vezes algo acontece. Os computadores também podem ser
programados para tomar decisões com base numa variedade de condições. Nesta
atividade, você vai programar o BASIC Stamp para que o LED pare de piscar on e off
após 10 vezes.
Contando peças e circuito de teste
Use o exemplo de circuito mostrado na Figura 2-11 na página 32.
Quantas Vezes?
Há muitas maneiras de fazer um LED piscar on e off dez vezes. O caminho mais
simples é usar o loop FOR...NEXT. O loop FOR...NEXT é semelhante ao
DO...LOOP. Embora o loop possa ser utilizado para repetir comandos um determinado
número de vezes, FOR...NEXT é mais fácil de usar. Isto, algumas vezes é chamado de
loop contado ou finito. O loop FOR...NEXT depende de uma variável para controlar
quantas vezes o LED piscou on e off. Uma variável é uma palavra de sua escolha, que é
usada para armazenar um valor. O próximo exemplo de programa escolhe o contador de
palavras para "contar" quantas vezes o LED está on e off.
Página - 37
A escolha de palavras para nomes de variáveis tem várias regras:
1.
O nome não pode ser uma palavra, que já é utilizada por PBASIC.
Essas palavras são chamadas de palavras reservadas, e alguns
exemplos que você já deve estar familiarizado são DEBUG, PAUSE,
HIGH, LOW, DO, e LOOP. Você pode ver a lista completa de
palavras reservadas no Manual do BASIC Stamp.
2.
O nome não pode ter espaço.
3.
Portanto o nome deve conter letras, números ou sublinhados e deve
começar com uma letra.
4. O nome deve ser inferior a 33 caracteres.
Exemplo de Programa: LedOnOffTenTimes.bs2
O programa LedOnOffTenTimes.bs2 demonstrou como usar o loop FOR...NEXT para
piscar o LED on e off dez vezes.






O circuito de teste da Atividade #2 deve ser construído (ou reconstruído).
Entre com o código LedOnOffTenTimes.bs2 no BASIC Stamp Editor.
Conecte a energia do Board of Education ou do HomeWork Board.
Execute o programa.
Verifique se o LED pisca on e off dez vezes.
Execute o programa uma segunda vez, e verifique se o valor do contador
mostrado no DEBUG Terminal monitora com precisão quantas vezes o LED
piscou. Dica: em vez de clicar em Executar uma segunda vez, você pode
pressionar e soltar o botão Reset no seu Board of Education ou HomeWork
Board.
' O que é um Microcontrolador - LedOnOffTenTimes.bs2
' Acenda e apague o LED. Repita 10 vezes.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter VAR Byte
FOR counter = 1 TO 10
DEBUG ? counter
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
DEBUG "Pronto!"
END
Como Funciona o LedOnOffTenTimes.bs2
Esta declaração PBASIC:
Página - 38
counter VAR Byte
…diz ao BASIC Stamp Editor que seu programa irá usar o contador de palavras como
uma variável que pode armazenar o valor de informações de um byte.
O que é Byte? Um byte é memória suficiente para armazenar um número entre
0 e 255. O BASIC Stamp tem quatro tipos diferentes de variáveis, e cada uma
pode
armazenar
uma
gama
diferente
de
números:
Tabela 2-2: Tipos de variáveis e valores que elas podem
armazenar
Tipo de variável
Intervalo de valores
Bit
Nib
Byte
0à1
0 à 15
0 à 255
Word
0 à 65535
A instrução DEBUG pode incluir formatadores que determinam como as informações
devem ser exibidas no DEBUG Terminal. Colocar o “?” ponto de interrogação
formatador antes de uma variável em um comando DEBUG diz ao DEBUG Terminal
para exibir o nome da variável e seu valor. Isto é como o comando:
DEBUG ? counter
… mostra o nome e o valor da variável de contador no DEBUG Terminal.
O loop FOR...NEXT e todos os comandos no seu interior são mostrados abaixo. A
declaração FOR ... counter = 1 to 10 diz ao BASIC Stamp que ele terá que
definir a variável de contador para 1, em seguida, manter a execução dos comandos até
que ele receba a declaração NEXT. Quando o BASIC Stamp chega à instrução NEXT, ele
salta de volta para a instrução FOR. A instrução FOR adiciona um para o valor do
contador. Em seguida, ela verifica se contador é maior do que dez ainda. Se não, o
processo se repete. Quando o valor do contador finalmente atinge onze, o programa
ignora os comandos entre as declarações FOR e NEXT e avança para o comando que vem
depois da declaração NEXT.
FOR counter = 1 to 10
DEBUG ? counter
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
O comando que vem depois da declaração NEXT é:
DEBUG "Pronto!"
Página - 39
Este comando está incluso apenas para mostrar o que o programa faz, depois de dez
vezes através do loop FOR ... NEXT. Ele avança para o comando que vem depois da
instrução NEXT.
Sua Vez – Outras Maneiras de Contar
 No programa LedOnOffTenTimes.bs2, substitua a declaração:
para:
 Reexecute o programa. O que o programa fez de diferente, e o que era esperado?
 Tente uma segunda modificação para a declaração FOR. Desta vez, mude para:
FOR counter = 20 to 120 STEP 10
Quantas vezes o LED pisca? Quais são os valores exibidos no DEBUG Terminal?
ATIVIDADE #4: CONSTRUINDO E TESTANDO O SEGUNDO CIRCUITO DE
LED
Os LEDs indicadores podem ser usados para informar muitas coisas para o usuário da
máquina. Muitos dispositivos precisam de dois, três, ou mais LEDs para informar ao
usuário se a máquina está pronta ou não, se houve uma avaria, se uma tarefa já foi
executada, e assim por diante.
Nesta atividade, você vai repetir o teste no circuito de LED da Atividade #1 para um
segundo circuito de LED. Então você vai ajustar o programa de exemplo da Atividade
#2 para garantir que o circuito de LED está conectado corretamente ao BASIC Stamp.
Depois disso, você irá modificar o exemplo de programa da Atividade #2 para fazer os
LEDs operarem em conjunto.
Peças Extras Necessárias
Além das peças que você utilizou nas Atividades 1 e 2, você necessitará das seguintes
peças:
(1) LED – amarelo
Construindo e Testando o Segundo Circuito de LED
Na Atividade #1, você testou manualmente o primeiro circuito de LED para ter certeza
de que ele funcionava antes de conectá-lo ao BASIC Stamp. Antes de ligar o segundo
circuito de LED ao BASIC Stamp, é importante testá-lo também.




Desconecte a energia do Board of Education ou do HomeWork Board.
Construa o segundo circuito de LED mostrado na Figura 2-13.
Reconecte a energia do Board of Education ou do HomeWork Board.
Será que o circuito de LED que você acabou de adicionar liga? Se sim, então
continue. Se não, na Atividade #1 tem algumas sugestões de resolução de
problemas que você pode repetir neste circuito.
Página - 40
Vdd
Vdd
470 Ω
P14
470 Ω
LED
LED
Vss
Vss
Vss
Vin
+
X3
+
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 2-13
Manual do circuito de
teste para o segundo
LED
 Desconecte a energia do seu Board of Education ou do HomeWork Board.
 Modifique o segundo circuito de LED que acabou de testar, ligando o fio do
resistor do circuito de LED (entrada) (input) para P15, como mostrado na Figura
2 -14.
Vdd
X3
P15
470 Ω
P14
470 Ω
LED
Vss
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
+
Figura 2-14
Conectar o
segundo
LED no
BASIC
Stamp
Esquemático
(esquerda) e
diagrama de
fiação
(direita).
Usando um Programa para Testar o Segundo Circuito de LED
Na Atividade #2, você utilizou um programa de exemplo e os comandos de HIGH e LOW
para controlar que o circuito de LED estivesse conectado a P14. Estes comandos têm
que ser alterados para controlar que o circuito de LED esteja conectado a P15. Em vez
de usar HIGH 14 e LOW 14, você irá usar HIGH 15 e LOW 15.
Exemplo de Programa: TestSecondLed.bs2




Entre com TestSecondLed.bs2 no BASIC Stamp Editor.
Conecte a energia do Board of Education ou do HomeWork Board.
Execute o TestSecondLED.bs2.
Verifique se o circuito de LED conectado a P15 está piscando. Se o LED que
estiver ligado ao P15 piscar, passe para o próximo exemplo (Controlar ambos os
LEDs). Se o circuito de LED conectado a P15 não estiver piscando, verifique o
circuito para checar erros de fiação e seu programa para checar erros de
digitação e tente novamente.
Página - 41
' O que é um Microcontrolador - TestSecondLed.bs2
' Acenda e apague o LED ligado a P15.
' Repita uma vez por segundo indefinidamente.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programa em andamento!"
DO
HIGH 15
PAUSE 500
LOW 15
PAUSE 500
LOOP
Controlando Ambos os LEDs
Sim, você pode fazer os LEDs piscarem de uma só vez. Uma forma de fazer isso é usar
dois comandos HIGH antes do primeiro comando PAUSE. Um comando HIGH define
P14 HIGH, e o próximo comando HIGH define P15 HIGH. Você também vai precisar de
dois comandos LOW para apagar os dois LEDs. É verdade que ambos os LEDs não vão
ligar e desligar exatamente ao mesmo tempo, porque um está on e off após o outro. No
entanto, não há mais do que um milésimo de segundo de diferença entre as duas
alterações, logo, o olho humano não consegue detectar.
Exemplo de Programa: FlashBothLeds.bs2
 Coloque o código FlashBothLeds.bs2 no BASIC Stamp Editor.
 Execute o programa.
 Cheque que ambos os LEDs pisquem on e off ao mesmo tempo.
' O que é um Microcontrolador - FlashBothLeds.bs2
' Acenda e apague os LEDs conectados a P14 e P15.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
HIGH 14
HIGH 15
PAUSE 500
LOW 14
LOW 15
PAUSE 500
LOOP
Página - 42
Sua Vez – LEDs Alternados
Você pode fazer com que os LEDs se alternem trocando os comandos HIGH e LOW que
controlam um dos pinos de I/O. Isto significa que enquanto um LED estiver ligado, o
outro estará desligado.
 Modique FlashBothLeds.bs2 para que as palavras chaves entre os comandos DO
e LOOP fiquem assim:
HIGH 14
LOW 15
PAUSE 500
LOW 14
HIGH 15
PAUSE 500
 Execute e modifique a versão do FlashBothLeds.bs2 e verifique se os LEDs
piscam alternadamente on e off.
ATIVIDADE #5: USANDO A DIREÇÃO DA CORRENTE PARA CONTROLAR
O LED BICOLOR
O dispositivo mostrado na Figura 2-15 é um monitor de segurança para as chaves
eletrônicas. Quando uma chave eletrônica com o código correto é usada, o diodo
emissor de luz muda de cor, e uma porta se abre. Este tipo de diodo emissor de luz é
chamado LED bicolor. Esta atividade responde a duas perguntas:
1. Como o LED muda de cor?
2. Como utilizar um com o BASIC Stamp?
Figura 2-15
LED bicolor em um
dispositivo de
segurança
Quando a porta está
trancada, este LED
bicolor brilha em
vermelho. Quando a
porta é desbloqueada
por uma chave
eletrônica com o
código correto, o LED
fica verde.
Apresentando o LED Bicolor
Símbolo esquemático do LED bicolor e desenho da peça são mostrados na Figura 2-16.
Página - 43
Figura 2-16
LED Bicolor
Símbolo esquemático
(à esquerda) e parte de
desenho (à direita).
O LED bicolor é realmente apenas dois LEDs em um único pacote. Figura 2-17 mostra
como você pode aplicar tensão em uma direção e o LED acender em verde. Ao desligar
o LED e colocá-lo de volta na posição invertida, o LED terá então um brilho vermelho.
Tal como acontece com os outros LEDs, se você conectar dois terminais de circuito de
Vss, o LED não emitirá luz.
Figura 2-17
LED bicolor e
tensão aplicada
Verde (à
esquerda),
vermelho (centro)
e nenhuma luz (à
direita)
Partes do Circuito do LED Bicolor
(1) LED – bicolor
(1) Fios de ligação
Construindo e Testando o Circuito do LED Bicolor
Figura 2-18 mostra o teste manual do LED bicolor.





Desconecte a energia do Board of Education ou do HomeWork Board.
Construa o circuito mostrado no lado esquerdo na Figura 0-18.
Reconecte a energia e verifique se o LED bicolor está emitindo uma luz verde.
Desconecte a energia novamente.
Modifique seu circuito para que ele corresponda ao mostrado no lado direito da
Figura 2-18.
 Reconecte a energia.
 Verifique se o LED bicolor está agora emitindo uma luz vermelha.
 Desconecte a energia.
Página - 44
O que acontece se as cores de meu LED bicolor estiverem invertidas? LEDs
bicolores são fabricados como ilustrado na Figura 2-16, com as cores invertidas.
Se o seu LED bicolor brilha em vermelho quando ele está conectado ao circuito
que deveria fazê-lo brilhar verde e vice-versa, as cores do seu LED estão
invertidas. Se for esse o caso, sempre plugue o pino 1 onde nos diagramas
mostrar o pino 2 e pino 2 onde nos diagramas mostrar o pino 1.
Vdd
1 Vin 2
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 2-18
Teste manual do LED
bicolor
Vdd
X3
2 Vin 1
Vss
LED bicolor: verde (à
esquerda) e vermelho
(à direita).
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Controlar um LED bicolor com o BASIC Stamp requer dois pinos de I/O. Depois de ter
verificado manualmente que o LED bicolor trabalha utilizando o teste manual, você
pode conectar o circuito para o BASIC Stamp, como mostrado na Figura 2-19.
 Conecte o circuito do LED bicolor ao BASIC Stamp como mostrado na Figura
2-19.
Página - 45
Figura 2-19
LED bicolor conectado
ao BASIC Stamp
Esquemática (à
esquerda) e diagrama
de fiação (à direita).
BASIC Stamp - Controle do LED Bicolor
Figura 2-20 mostra como você pode usar P15 e P14 para controlar o fluxo de corrente
no circuito de LED bicolor. O esquema acima mostra como a corrente flui através do
LED verde quando P15 está definido para Vdd com HIGH e P14 está definido para Vss
com LOW. Isso ocorre porque o LED verde irá deixar a corrente passar através dele
quando a pressão elétrica for aplicada como mostrado, mas o LED vermelho atuará
como uma válvula fechada e não deixará a corrente passar através dele. O LED bicolor
brilha verde.
O esquema abaixo mostra o que acontece quando P15 está definido para Vss e P14 está
definido para Vdd. A pressão elétrica está invertida. O LED verde desliga e não permite
que a corrente passe. Enquanto isso, o LED vermelho acende, e a corrente passa através
do circuito na direção oposta.
HIGH = Vdd P15
1
Current
Figura 2-20
BASIC Stamp teste do
LED bicolor
2
LOW = Vss P14
470 Ω
LOW = Vss P15
Corrente através do
diodo emissor de luz
verde (acima) e um
LED vermelho (em
baixo).
1
Current
2
HIGH = Vdd P14
470 Ω
A Figura 2-20 mostra também a chave para a programação do BASIC Stamp para fazer
o LED bicolor brilhar em duas cores diferentes. O esquema acima mostra como fazer o
LED bicolor brilhar verde com HIGH 15 e LOW 14. O esquema abaixo mostra como
fazer o LED bicolor brilhar vermelho usando LOW 15 e HIGH 14. Para desligar o
Página - 46
LED, envie sinais de baixa tanto para P14 e P15 usando LOW 15 e LOW 14. Em outras
palavras, use LOW em ambos os pinos.
O LED bicolor também se desligará se você enviar sinais de HIGH para
ambos os P14 e P15. Por quê? Porque a pressão elétrica (voltagem) é a mesma
em P14 e P15, independentemente de você definir os pinos I/O HIGH ou LOW.
Exemplo de Programa: TestBiColorLED.bs2
 Insira e execute o código TestBiColorLed.bs2 no BASIC Stamp Editor.
 Verifique os ciclos de LED entre o vermelho, verde, na posição off.
' O que é um Microcontrolador - TestBiColorLed.bs2
' Faça o LED bicolor brilhar vermelho, depois verde e apagar.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DEBUG "Programa em andamento!", CR
DO
DEBUG "Verde..."
HIGH 15
LOW 14
PAUSE 1500
DEBUG "Vermelho..."
LOW 15
HIGH 14
PAUSE 1500
DEBUG "Apagado...", CR
LOW 15
LOW 14
PAUSE 1500
LOOP
Sua vez – Luzes do Visor
Na Atividade #3, a variável chamada counter foi usada para controlar quantas vezes o
LED piscou. O que acontecerá se você usar o valor do counter para controlar o
comando PAUSE argumento Duration ao alterar repetidamente a cor do LED bicolor?
 Renomear e salvar TestBiColorLed.bs2 para TestBiColorLedYourTurn.bs2.
 Adicionar a variável counter antes da declaração:
counter VAR BYTE
 Substituir o código de teste no DO...LOOP por este loop FOR...NEXT.
HIGH 15
Página - 47
LOW 14
PAUSE counter
LOW 15
HIGH 14
PAUSE counter
NEXT
Quando estiver concluído, seu código deve parecer com:
counter VAR BYTE
DO
HIGH 15
LOW 14
PAUSE counter
LOW 15
HIGH 14
PAUSE counter
NEXT
LOOP
No início de cada passagem através do loop FOR...NEXT o valor PAUSE (argumento
Duration) é apenas um milésimo de segundo. Cada vez que através loop FOR...NEXT,
a pausa recebe mais por um milésimo de segundo de cada vez até chegar a 50 milésimos
de segundo. O DO...LOOP faz com que o loop FOR...NEXT seja executado
repetidamente.
 Execute o programa modificado e observe o efeito.
Página - 48
SUMÁRIO
O BASIC Stamp pode ser programado para mudar um circuito com um diodo emissor
de luz (LED) para on e off. Os LEDs indicadores são úteis em uma variedade de
lugares, incluindo muitos monitores de computador, discos rígidos e outros dispositivos.
O diodo emissor de luz foi introduzido, juntamente com uma técnica para identificar
seus terminais de ânodo e cátodo. Um circuito de LED tem que ter uma resistência para
limitar a corrente que passa através dele. Resistores foram introduzidos juntamente com
um dos esquemas de codificação mais comuns para indicar o valor de um resistor.
O BASIC Stamp muda um circuito de LED on e off, ligando internamente um pino de
I/O também para VDD ou VSS. O comando HIGH pode ser usado para fazer o BASIC
Stamp conectar internamente um de seus pinos de I/O para Vdd e o comando LOW pode
ser usado para conectar internamente um pino de I/O para VSS. O comando PAUSE é
usado para fazer com que o BASIC Stamp não execute os comandos por um período de
tempo. Este foi usado para fazer os LEDs permanecerem on e/ou off por um certo
período de tempo. A quantidade de tempo é determinada pelo número utilizado no
argumento Duration do comando PAUSE.
DO...LOOP pode ser usado para criar um loop infinito. Os comandos entre as palavras
chaves DO e LOOP serão executados repetidamente. Mesmo que isso seja chamado de
um loop infinito, o programa pode ser reiniciado desconectando e reconectando a
energia ou pressionando e soltando o botão Reset. Um novo programa também pode ser
baixado para o BASIC Stamp, e isso vai apagar o programa com o loop infinito. Loops
contados podem ser feitos com FOR...NEXT, uma variável para manter o controle de
quantas repetições de loop tem sido feitas, e os números para especificar onde iniciar e
parar a contagem.
Direção de corrente e tensão de polaridade foram introduzidas utilizando um LED
bicolor. Se a tensão é aplicada em todo o circuito de LED, a corrente passará por ele em
uma direção, e ele brilhará com uma cor específica. Se a tensão de polaridade é
invertida, cursos de corrente passam através do circuito no sentido oposto e irá brilhar
numa cor diferente.
Questões
1. Qual é o nome desta letra grega: Ω, e a que medição essa letra Ω se refere?
2. Quais resistências permitiriam mais corrente através do circuito, de um resistor
de 470 Ω ou um resistor de1000 Ω?
3. Como você conecta dois fios usando uma placa de montagem? Você pode usar
uma placa de montagem para conectar quatro fios juntos?
4. O que você sempre tem que fazer antes de modificar um circuito que você
construiu sobre uma placa?
5. Quanto tempo deve passar o PAUSE 10000?
6. Como você poderia provocar o BASIC Stamp a não fazer nada por um minuto
inteiro?
7. Quais são os diferentes tipos de variáveis?
8. Pode um byte manter o valor de 500?
9. O que fará o comando HIGH 7?
Página - 49
Exercícios
1. Desenhe o esquema de um circuito de LED como o que você trabalhou na
Atividade #2, mas ligue o circuito em P13 em vez de P14. Explique como você
poderia modificar LedOnOff.bs2 na página 3, para que ele faça o circuito de
LED piscar on e off quatro vezes por segundo.
2. Explique como modificar LedOnOffTenTimes.bs2 para que ele faça o circuito
de LED piscar on e off 5.000 vezes antes de parar. Dica: você vai precisar
modificar apenas duas linhas de código.
Projeto
1. Faça uma contagem de 10 segundos usando um LED amarelo e um LED bicolor.
Faça o LED bicolor começar vermelho por 3 segundos. Após 3 segundos, altere
o LED bicolor para verde. Quando o LED bicolor mudar para verde, pisque o
LED amarelo on e off uma vez por segundo durante dez segundos. Quando o
LED amarelo piscar, o LED bicolor deve voltar para o vermelho e ficar desse
jeito.
Soluções
Q1. Ômega refere-se à ohm que mede quão fortemente algo resiste ao fluxo de
corrente.
Q2. O resistor 470 Ω: valores mais elevados resistem mais fortemente do que os
valores mais baixos, portanto, valores mais baixos permitem maior fluxo de
corrente.
Q3. Para conectar dois fios, ligue os 2 fios no mesmo grupo de 5 soquetes. Você
pode conectar 4 fios, ligando todos os 4 fios no mesmo grupo de 5 soquetes.
Q4. Desligue a alimentação.
Q5. 10 segundos.
Q6. PAUSE 60000
Q7. Bit, Nib, Byte, e Word
Q8. Não. O maior valor que um byte pode conter é 255. O valor 500 está fora de
alcance para um byte.
Q9. HIGH 7 fará com que o BASIC Stamp conecte internamente o pino I/O P7 para
Vdd.
E1. A duração da pausa tem de ser reduzida para 500 ms / 4 = 125 ms. Para usar i
pino I/O P13, HIGH 14 e LOW 14 foram substituídos por HIGH 13 e LOW 13.
E2.
P13
470 Ω
LED
Vss
DO
HIGH 13
PAUSE 125
LOW 13
PAUSE 125
LOOP
A variável counter tem que ser mudada para Word size, e a declaração FOR tem que
ser modificada para contar de 1 a 5000.
counter VAR Word
Página - 50
DEBUG ? counter, CR
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
P1. O esquema do LED bicolor do lado esquerdo, está inalterado a partir da Figura
2-19, na página 46. O esquema do LED amarelo baseia-se na Figura 2-11, na
página 33. Para este projeto, P14 foi alterado para P13, e um LED amarelo foi
usado em vez de verde. NOTA: Quando o BASIC Stamp fica sem comandos, ele
entra em um modo de baixa potência que faz com que os LEDs bicolores
pisquem rapidamente a cada 2,3 segundos. O mesmo aplica-se após o programa
executar um comando END. Há outro comando chamado STOP que você pode
adicionar ao final do programa para deter quaisquer sinais de HIGH / LOW, sem
entrar em modo de baixa energia, que por sua vez o impede de piscar.
P2.
P13
470 Ω
Yellow
LED
Vss
' O que é um Microcontrolador - Ch02Prj01_Countdown.bs2
' Contagem de dez segundos com LEDs vermelho, verde e amarelo.
' Vermelho/Verde: LED bicolor no P15, P14. Amarelo: P13
' {$STAMP BS2}
' {$PBASIC 2.5}
counter VAR Byte
' Vermelho por três segundos...
LOW 15
HIGH 14
PAUSE 3000
' Verde por dez segundos...
HIGH 15
LOW 14
' ...enquanto o LED amarelo pisca
HIGH 13
PAUSE 500
LOW 13
PAUSE 500
NEXT
' Vermelho aceso
LOW 15
' LED bicolor vermelho
' LED bicolor verde
' LED amarelo aceso
' LED amarelo apagado
Página - 51
HIGH
14
Página - 52
Capítulo 3: Entrada Digital – Botões
ENCONTRADOS EM CALCULADORAS, JOGOS PORTÁTEIS E
APLICATIVOS
Quantos dispositivos com botões você usa diariamente? Aqui estão alguns exemplos
que podem estar na sua lista: computador, mouse, calculadora, forno de microondas,
controle remoto de TV, jogos manuais e telefone celular. Em cada dispositivo, há um
microcontrolador digitalizando os botões de pressão e de espera para mudar o circuito.
Quando o circuito muda, o microcontrolador detecta a alteração e toma medidas. Até o
final deste capítulo, você terá experiências com criação de circuitos de botões e
programará o BASIC Stamp para monitorá-los e tomar medidas quando ocorrerem essas
alterações.
RECEBIMENTO VS. ENVIO DE SINAIS DE HIGH E LOW
No Capítulo 2, você programou o BASIC Stamp para enviar sinais de high e low, e usou
circuitos de LED para exibir esses sinais. O envio de sinais de high e low significa que
você usou um pino de I/O BASIC Stamp como uma saída. Neste capítulo, você vai usar
um pino de I/O do BASIC Stamp como entrada. Em uma entrada, um pino de I/O ouve
sinais de high/low, em vez de enviá-los. Você vai enviar esses sinais para o BASIC
Stamp usando um circuito de botão, e você vai programar o BASIC Stamp para
reconhecer se o botão foi pressionado ou não.
Outros termos que significam envio e recebimento de HIGH/LOW. O envio
de sinais de high/low é descrito de maneiras diferentes. Você pode ver o envio
mencionado, como transmissão, controle ou comutação. Em vez de HIGH/LOW,
você pode vê-lo chamado de binário, TTL, CMOS, ou sinais booleanos. Outro
termo para recepção é detecção.
ATIVIDADE #1: TESTANDO UM BOTÃO COM UM CIRCUITO DE LED
Se você pode usar um botão para enviar um sinal de alta ou de baixa (high ou low) para
o BASIC Stamp, você pode também controlar um LED com um botão? A resposta é
sim, e você vai usá-lo para testar um botão nesta atividade.
Apresentando o Botão
A Figura 3-1 mostra um diagrama esquemático do símbolo e desenho da peça de um
botão de pressão normalmente aberto. Dois dos pinos do botão de pressão estão
conectados a cada um dos terminais. Isto significa que ligar um fio ou uma peça ao pino
1 do botão é o mesmo que ligar ao pino 4. A mesma regra aplica-se com os pinos 2 e 3.
A razão pela qual o botão não tem apenas dois pinos é porque ele precisa de
estabilidade. Se o botão tivesse apenas dois pinos, eles poderiam eventualmente dobrar
e quebrar devido a pressão que o botão recebe quando pressionado.
1, 4
2, 3
Figura 3-1
Botão normalmente aberto
1
4
2
3
Símbolo esquemático (à
esquerda) e parte de desenho (à
direita)
Página - 53
O lado esquerdo da Figura 3-2 mostra a aparência de um botão de pressão normalmente
aberto quando não está pressionado. Quando o botão não está pressionado, existe uma
defasagem entre os terminais 1,4 e 2,3. Esta diferença faz com que o terminal 1,4 não
possa levar corrente para o terminal 2,3. Isto é chamado de circuito aberto. O nome
"normalmente aberto" significa que o estado normal do botão (não pressionado) forma
um circuito aberto. Quando o botão é pressionado, a distância entre os terminais 1,4 e
2,3 é reduzida por um metal condutor. Isto é chamado de circuito fechado, e assim a
corrente pode fluir através do botão de pressão.
1, 4
1, 4
2, 3
2, 3
Figura 3-2
Botão normalmente aberto
Não pressionado (à esquerda) e
pressionado (à direita)
Peças de Teste para o Botão de Pressão
(1) LED – escolha uma cor
(1) Botão – normalmente aberto
(1) Fios
Construindo um Circuito de Teste do Botão
A Figura 3-3 mostra o circuito que você pode construir para testar manualmente o
botão.
Sempre desconecte a energia do Board of Education ou do BASIC Stamp
HomeWork Board antes de fazer qualquer mudança ou teste de circuito. Daqui
em diante, as instruções não vão dizer: "Desligue a alimentação" entre cada
modificação do circuito. Cabe a você se lembrar de fazer isso.
Sempre reconecte a energia do Board of Education ou do BASIC Stamp
HomeWork Board antes de baixar o programa do BASIC Stamp.
 Construa o circuito mostrado na Figura 3-3.
Vdd
Vdd
Vin
Vss
+
X3
1, 4
2, 3
470 Ω
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-3
Circuito de teste do
botão
Página - 54
Testando um Botão com um Circuito de LED
Quando o botão não for pressionado, o LED estará desligado. Se a fiação estiver
correta, quando o botão for pressionado, o LED deverá ser ligado (emitindo luz).
Sinais de alerta: Se o Power LED do Board of Education piscar, escurecer ou
desligar completamente quando você reconectar a energia, pode significar que há
um curto-circuito de Vdd para Vss ou de Vin para VSS. Se isso acontecer,
desligue imediatamente, encontre e corrija o erro em seu circuito.
O Power LED construído dentro do HomeWork Board é diferente. Tanto
pode ser rotulado de "Power" ou "Running" e só brilha enquanto um programa
está em execução. Se um programa termina, porque ele executa um comando
END ou porque é executado sem comandos, o LED desliga.
 Verifique se o LED em seu circuito de teste está desligado.
 Pressione e segure o botão e verifique se o LED emite luz enquanto você estiver
pressionando o botão.
Como o Circuito de Botão Funciona
O lado esquerdo da Figura 3-4 mostra o que acontece quando o botão não está
pressionado. O circuito de LED não está ligado a Vdd. É um circuito aberto que não
pode conduzir corrente. Ao pressionar o botão de pressão, como mostrado no lado
direito da figura, você fecha a ligação entre os terminais com um condutor de metal. Isto
faz um caminho para que os elétrons fluam através do circuito e como resultado o diodo
emissor de luz emite luz.
Vdd
Vdd
1, 4
1, 4
2, 3
2, 3
No
Current
470 Ω
Figura 3-4
Botão não pressionado
e pressionado.
470 Ω
Current
LED
LED
Vss
Botão não pressionado:
circuito aberto e luz
desligada (à esquerda)
Botão pressionado:
circuito fechado e luz
ligada (à direita)
Vss
Sua Vez – Um Curto-Circuito
A Figura 3-5 mostra um circuito que vai fazer com que o diodo emissor de luz se
comporte de forma diferente. Quando o botão for pressionado, o LED apaga. Uma vez
que este botão liga um condutor entre os terminais 1,4 e 2,3, quando pressionado,
significa que a eletricidade passa a circular pelo menor caminho da resistência através
do botão em vez de ir através do LED. Ao contrário dos curtos-circuitos possíveis
discutidos na caixa de Sinais de Alerta, o curto-circuito que o botão pressionado
provoca através dos terminais do LED não danifica qualquer circuito e serve a um
propósito útil.
Página - 55
 Repita os testes realizados no primeiro circuito de botão que você construiu com
este novo circuito.
Vdd
Vdd
Vin
Vss
X3
1, 4
LED
2, 3
470 Ω
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Figura 3-5
Diodo emissor de luz
que entra em curtocircuito com uso do
botão
O que você pode realmente fazer com o LED? Até agora, o cátodo do LED
sempre foi ligado ao Vss. Agora, o LED está num local diferente no circuito,
com o seu ânodo ligado ao Vss. Muitas vezes as pessoas se perguntam se isso
quebra todas as regras do circuito, e a resposta é não. A pressão elétrica fornecida
por Vdd e Vss é de 5 volts. O LED vermelho sempre usará cerca de 1,7 volts, e o
resistor vai usar os restantes 3,3 volts, independentemente da sua ordem.
ATIVIDADE #2: LEITURA DO BOTÃO COM O BASIC STAMP
Nesta atividade, você vai ligar um circuito de botão para o BASIC Stamp mostrar se ele
está ou não pressionado. Você vai fazer isso escrevendo um programa de PBASIC que
verifica o estado do botão e exibe-o no DEBUG Terminal.
Peças para um Circuito de Botão
(1) Resistor – 220 Ω (vermelho-vermelho-marrom)
(1) Resistor – 10 kΩ (marrom-preto-laranja)
(2) Fios
Construindo o Circuito de Botão para o BASIC Stamp
A Figura 3-6 mostra um circuito de botão ligado ao pino de I/O P3 do BASIC Stamp.
 Construindo o circuito mostrado na Figura 3-6.
Página - 56
Vdd
Vin
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
P3
220 Ω
10 kΩ
Vss
Vss
Figura 3-6
Circuito de
botão conectado
ao pino de I/O
P3
No diagrama de
fiação, o resistor
de 220 Ω está
no lado
esquerdo
ligando o botão
à P3, enquanto
o resistor de 10
kΩ está à
direita, ligando o
circuito do botão
à Vss.
A Figura 3-7 mostra o que o BASIC Stamp vê quando o botão é pressionado e quando
não é. Quando o botão é pressionado, o BASIC Stamp percebe que Vdd está ligado a
P3. Dentro do BASIC Stamp, isso faz com que ele coloque o número 1 em uma parte da
sua memória que armazena informações sobre os seus pinos de I/O. Quando o botão não
for pressionado, o BASIC Stamp não pode sentir Vdd, mas pode sentir Vss através dos
resistores 10 kΩ e 220 Ω. Isso faz com que ele armazene o número 0, no mesmo local
de memória que armazena 1 quando o botão está pressionado.
Vdd
220 Ω
10 kΩ
SOUT
1
SIN
2
24
ATN
3
VIN
23
VSS
22
VSS
4
RES
21
P0
P1
VDD (+5V)
5
20
P15
6
19
P2
7
P14
18
P3
8
P13
17
P12
BS2
1
0
P4
9
16
P11
P5
10
15
P10
P6
11
14
P9
13
P8
P7 12
BS2-IC
Vss
Vdd
220 Ω
10 kΩ
SOUT
1
SIN
2
24
VIN
23
ATN
3
VSS
4
VSS
22
RES
21
P0
VDD (+5V)
5
20
P15
P1
6
19
P14
P2
7
18
P13
P3
8
17
P12
P4
9
16
P11
P5 10
15
P10
P6
11
14
P9
P7 12
13
P8
BS2
1
0
Figura 3-7
BASIC Stamp lendo o
botão
Quando o botão está
pressionado, o BASIC
Stamp lê 1 (acima).
Quando o botão não
está pressionado o
BASIC Stamp lê 0
(abaixo).
BS2-IC
Vss
Binário e Circuitos: O sistema numérico com base-2 usa apenas os dígitos 1 e 0
para fazer números, e esses valores binários podem ser transmitidos de um
dispositivo para outro. O BASIC Stamp interpreta Vdd (5 V) como um binário-1
e Vss (0 V) como um binário-0. Da mesma forma, quando o BASIC Stamp
define o pino de I/O para Vdd usando HIGH, envia o binário-1. Quando defini o
pino de I/O para Vss usando LOW, envia o um binário-0. Esta é uma forma usual
de comunicação de números utilizada por diversos computadores, chips e outros
dispositivos.
Página - 57
Programando o BASIC Stamp para Monitorar o Botão
O BASIC Stamp armazena um ou zero percebidos no pino de I/O P3 em um local de
memória chamado IN3. Aqui está um exemplo de programa que mostra como isso
funciona:
Exemplo de Programa: ReadPushbuttonState.bs2
Este próximo programa faz o BASIC Stamp verificar o botão a cada ¼ de segundo e
enviar o valor de IN3 ao DEBUG Terminal.
A Figura 3-8 mostra o DEBUG Terminal enquanto o programa está sendo executado.
Quando o botão é pressionado, o DEBUG Terminal exibe o número 1, e quando o botão
não está pressionado, o DEBUG Terminal exibe o número 0.
Figura 3-8
DEBUG Terminal mostrando a
leitura do botão
O DEBUG Terminal exibe 1
quando o botão é pressionado, e
0 quando não está pressionado.
 Entre com o programa ReadPushbuttonState.bs2 no BASIC Stamp Editor.
 Execute o programa.
 Verifique se o DEBUG Terminal exibe o valor 0 quando o botão não está
pressionado.
 Verifique se o DEBUG Terminal exibe o valor 1 quando o botão é pressionado e
mantido.
' O que é um Microcontrolador - ReadPushbuttonState.bs2
' Verifique e informe, a cada 1/4 de segundo, através do DEBUG
' Terminal o estado do botão.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN3
PAUSE 250
LOOP
Como Funciona o ReadPushbuttonState.bs2
O DO...LOOP no programa repete a cada 1/4 de segundo por causa do comando PAUSE
250. Cada vez através do DO...LOOP, o comando DEBUG ? IN3 envia o valor de IN3
para o DEBUG Terminal. O valor de IN3 é o estado que o pino de I/O P3 percebe no
instante em que o comando DEBUG é executado.
Página - 58
Sua Vez – Um Botão com um Resistor pull-up
O circuito que você terminou tem um resistor ligado ao Vss. Esta resistência é chamada
de resistência pull-down, pois puxa a tensão no P3 até Vss (0 volts), quando o botão não
está pressionado. A Figura 3-9 mostra um circuito de botão de pressão que usa uma
resistência pull-up. Esta puxa o resistor de tensão até Vdd (5 volt), quando o botão não
está pressionado. As regras já estão invertidas. Quando o botão não for pressionado,
IN3 armazena o número 1, e quando o botão é pressionado, IN3 armazena o número 0.
O resistor 220 Ω é utilizado nos exemplos de circuitos de botões de pressão para
proteger o pino de I/O do BASIC Stamp. Embora seja uma boa prática para
prototipagem, na maioria dos produtos este resistor é substituído por um fio (pois
fios custam menos que resistores).
 Modifique seu circuito como mostrado na Figura 3-9.
 Re-execute ReadPushbuttonState.bs2.
 Usando o DEBUG Terminal, verifique se IN3 é 1 quando o botão não está
pressionado e 0 quando o botão está pressionado.
Vdd
Vdd
10 kΩ
P3
220 Ω
Vss
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-9
Circuito de botão
modificado
Baixa atividade vs. alta atividade: O botão do circuito da Figura 3-9 é chamado
de atividade baixa porque manda ao BASIC Stamp um sinal de baixa (Vss)
quando o botão é ativado (pressionado). O botão do circuito na Figura 3-6 é
chamado de alta porque envia um sinal de alta (Vdd) quando o botão é ativado
(pressionado).
ATIVIDADE #3: CONTROLE POR BOTÃO DE UM CIRCUITO DE LED
A Figura 3-10 mostra, em zoom, o botão de pressão e o LED usado para ajustar as
configurações em um monitor de computador. Este é apenas um dos muitos dispositivos
que possuem um botão que você pode pressionar para ajustar o dispositivo e um LED
para mostrar o status do dispositivo.
Página - 59
Figura 3-10
Botão e LED no
monitor do
computador
O BASIC Stamp pode ser programado para tomar decisões com base no que ele sente.
Por exemplo, ele pode ser programado para piscar o LED em on/off, dez vezes por
segundo, quando o botão é pressionado.
Peças do Circuito de LED e Botão
(1) LED – qualquer cor
(2) Fios
Construindo o Circuito de LED e Botão
A Figura 3-11 mostra o circuito de botão usado na atividade que você acabou de
terminar junto do circuito de LED utilizado na Atividade #2 do Capítulo 2.
P14
470 Ω
LED
Vdd
X3
Vss
Vdd
P3
220 Ω
10 kΩ
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 3-11
Circuito de LED e
botão
Programando o Controle do Botão
O BASIC Stamp pode ser programado para tomar decisões usando as declarações
IF...THEN...ELSE. O programa de exemplo que você vai executar irá piscar o LED
on e off quando o botão for pressionado. Cada vez através do DO...LOOP, as
Página - 60
declarações IF...THEN...ELSE verificam o estado do botão e decidem se o LED
deve piscar ou não.
Exemplo de Programa: PushbuttonControlledLed.bs2
 Entre com o PushbuttonControlledLed.bs2 no BASIC Stamp Editor e execute-o.
 Verifique se o LED pisca on e off enquanto o botão é pressionado e mantido
pressionado.
 Verifique se o LED não piscará quando o botão não estiver pressionado.
' O que é um Microcontrolador - PushbuttonControlledLed.bs2
' Verifique o estado do botão 10 vezes por segundo e faça o LED piscar
' quando pressionado.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN3
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
LOW 14
PAUSE 50
ELSE
PAUSE 100
ENDIF
LOOP
Como Funciona o PushbuttonControlledLed.bs2
Este programa é uma versão modificada do ReadPushbuttonState.bs2 da atividade
anterior. Os comandos DO ... LOOP e DEBUG? IN3 são os mesmos. O comando
PAUSE 250 foi substituído por uma declaração IF...THEN...ELSE. Quando a
condição após o IF é verdadeira (IN3 = 1), os comandos que vêm após a declaração
THEN, são então executados. Eles serão executados até que a declaração ELSE seja
atingida, ponto no qual o programa salta para ENDIF e segue em frente. Quando a
condição do IF não é verdadeira (IN3 = 0), os comandos da instrução ELSE são
executados até ENDIF ser atingido.
Você pode fazer uma lista detalhada do que um programa deve fazer, isso ajudará a
planejar o programa ou descrever o que ele faz. Esse tipo de lista é chamado de pseudocódigo, e o exemplo abaixo usa pseudo-código para descrever como o
PushbuttonControlledLed.bs2 funciona.
o Faz com que os comandos a partir daqui até a declaração de Loop se
repitam indefinidamente.
o Mostra o valor de IN3 no DEBUG Terminal.
o Se (If) o valor de IN3 for 1, então (Then)
 Acende o LED
Página - 61
 Espera 1/20 de segundo
 Apaga o LED
 Espero 1/20 de segundo
o Se não (Else) (se o valor de IN3 for 0)
 Não faz nada, mas espera a mesma quantia de tempo que
levaria para o LED piscar rapidamente (1/10 de
segundo).
o Loop
Sua Vez – Mais Rápido/Mais Devagar
 Salve o programa de exemplo com um nome diferente.
 Modifique o programa para que o LED pisque duas vezes mais rápido, quando
você pressionar e segurar o botão.
 Modifique o programa para que o LED pisque duas vezes mais devagar, quando
você pressionar e segurar o botão.
ATIVIDADE #4: DOIS BOTÕES CONTROLANDO DOIS DOS CIRCUITOS DE
LED
Vamos adicionar um segundo botão para o projeto e ver como ele funciona. Para tornar
as coisas um pouco mais interessantes, vamos também adicionar um segundo circuito de
LED e usar o segundo botão para controlá-lo.
Peças do Circuito de LED e Botão
(2) Resistores – 10 kΩ (marrom-preto-laranja)
(2) Resistores – 470 Ω (amarelo-violeta-marrom)
(2) Resistores – 220 Ω (vermelho-vermelho-marrom)
(2) LEDs – qualquer cor
(3) Fios
Adicionando um Botão e um Circuito de LED
A Figura 3-12 mostra um segundo circuito de LED e botão adicionados ao circuito que
você testou na atividade anterior.
 Construa o circuito mostrado na Figura 3-12. Se você precisar de ajuda para
construir o circuito mostrado no esquema, use o diagrama de fiação na Figura 313 como guia.
 Modifique ReadPushbuttonState.bs2 para que ele leia IN4 em vez de IN3, e use
isso para testar o segundo botão do circuito.
Página - 62
P15
470 Ω
P14
470 Ω
LED
LED
Vss
Vss
Vdd
Vdd
Figura 3-12
Esquema para circuito
de dois botões e
LEDs
P4
220 Ω
P3
220 Ω
10 kΩ
Vss
10 kΩ
Vss
Pontos que indicam conexões: Existe, na Figura 3-12, três locais onde os fios se
intersectam, mas apenas dois pontos. Os fios estão conectados apenas se há um
ponto na intersecção. O fio que conecta o botão ligado a P4 ao resistor de 10 kΩ,
não está conectado ao circuito do botão ligado a P3 porque não há nenhum ponto
indicando essa conexão.
Vdd
X3
Vin
Vss
++
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-13
Diagrama de fiação de dois
botões e LEDs
Programando o Controle do Botão
Na atividade anterior, você fez uma experiência ao tomar decisões de usar uma
instrução
IF...THEN...ELSE.
Também
existe
tal
coisa
com
um
IF...ELSEIF...ELSE. Ele funciona muito bem para decidir quais LEDs piscarão e
desligarão. O seguinte programa de exemplo mostra como ele funciona.
Exemplo de Programa: PushbuttonControlOfTwoLeds.bs2
 Coloque e execute PushbuttonControlOfTwoLeds.bs2 no BASIC Stamp Editor.
 Verifique se o circuito de LED conectado à P14 piscará on e off quando o botão
no circuito conectado à P3 é pressionado.
Página - 63
 Também verifique se o LED no circuito ligado à P15 pisca quando o botão do
circuito conectado à P4 é pressionado.
'
'
'
'
O que é um Microcontrolador- PushbuttonControlOfTwoLeds.bs2
Faça o LED ligado a P14 piscar quando o botão ligado a P3 for
pressionado e o LED ligado a P15 piscar quando o botão ligado a P4
for pressionado.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DO
DEBUG HOME
DEBUG ? IN4
DEBUG ? IN3
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
ELSEIF (IN4 = 1) THEN
HIGH 15
PAUSE 50
ELSE
PAUSE 50
ENDIF
LOW 14
LOW 15
PAUSE 50
LOOP
Como Funciona o PushbuttonControlOfTwoLeds.bs2
Se a exibição de IN3 e IN4 rolou para baixo o DEBUG Terminal, como aconteceu no
exemplo anterior, será difícil de ler. Uma maneira de corrigir isso é sempre enviar o
cursor para o topo à esquerda no DEBUG Terminal usando o caractere de controle
HOME:
DEBUG HOME
Enviar o cursor para a posição inicial sempre através do DO...LOOP, os comandos:
DEBUG ? IN4
DEBUG ? IN3
... exibem os valores de IN4 e IN3 sempre na mesma parte do DEBUG Terminal. A
palavra-chave DO começa o loop neste programa:
DO
Estes comandos na instrução IF são os mesmos que os do programa de exemplo da
atividade anterior:
Página - 64
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
É aqui que a palavra-chave ELSEIF o ajudará. Se IN3 não é 1, mas IN4 é 1, queremos
que o LED esteja ligado ao P15 em vez de estar ligado ao P14.
HIGH 15
PAUSE 50
Se nenhuma das afirmações for verdadeira, e ainda quisermos fazer uma pausa por 50
ms, sem alterar o estado de todos os circuitos de LED.
ELSE
PAUSE 50
Quando você terminar com todas as decisões, não se esqueça do ENDIF.
ENDIF
É hora de desligar os LEDs e pausar novamente. Você poderia decidir qual LED ligou e
desligá-lo. Comandos do PBASIC são executados de forma muito rápida, então por que
não deixá-los desligados e esquecer sobre elaborar mais decisões?
LOW 14
LOW 15
PAUSE 50
A declaração LOOP enviará o programa de volta para a declaração DO, e todo o processo
de checagem dos botões e mudança do estado dos LEDs começará novamente.
LOOP
Sua Vez – Que Tal Pressionar os dois Botões?
O exemplo de programa tem uma falha. Tente pressionar ambos os botões ao mesmo
tempo e você verá a falha. Seria esperado que ambos os LEDs piscassem on e off, mas
isto não acontece, pois somente um bloco de código IF...ELSEIF...ELSE será
executado antes que vá ao ENDIF. Aqui está como você pode corrigir esse problema:
 Salve PushbuttonControlOfTwoLeds.bs2 com um nome diferente.
 Substitua a declaração IF e o bloco de código:
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
...com a declaração IF...ELSEIF:
Página - 65
IF (IN3 = 1) AND (IN4 = 1) THEN
HIGH 14
HIGH 15
PAUSE 50
HIGH 14
PAUSE 50
Um bloco de código é um grupo de comandos. A instrução IF acima tem um
bloco de código com três comandos (HIGH, HIGH e PAUSE). A declaração
ELSEIF tem um bloco de código com dois comandos (HIGH, PAUSE).
 Execute ou modifique o programa e observe como ele lida com botão
pressionado e se os resultados dos circuitos de LED saíram como esperado.
A palavra chave AND pode ser usada nas declarações IF...THEN para checar
se há mais condições verdadeiras. Todas as condições com AND têm que ser
verdadeiras para a declaração IF ser verdadeira.
A palavra chave OR pode também ser usada para checar se pelo menos uma das
condições é verdadeira.
Você pode também modificar o programa para que os LEDs pisquem on em diferentes
quantidades de tempo. Por exemplo, você pode reduzir o argumento Duration do
comando PAUSE a 10 para ambos os botões, aumentando o PAUSE do LED P14 para
100, e o PAUSE do LED P15 para 200.
 Modifique o comando PAUSE do IF e as duas declarações ELSEIF como foram
discutidas.
 Execute o programa modificado.
 Observe a diferença no comportamento de cada luz.
ATIVIDADE #5: TESTE DE TEMPO DE REAÇÃO
Você é um engenheiro de sistemas e trabalha em uma empresa de vídeo games. O
departamento de Marketing recomenda que seja adicionado um circuito, no próximo
controle de um jogo de mão, para testar o tempo de reação do jogador. Sua próxima
tarefa será desenvolver um prova de conceito para o teste de tempo de reação.
A solução que você irá construir e testar nessa atividade é um exemplo de como
solucionar o problema, mas não é definitivamente a única solução. Antes de continuar,
tire um momento para pensar como deve ser projetada esse medidor de tempo de
reação.
Peças do Medidor de Tempo de Reação
(1) LED – bicolor
Página - 66
(2) Fios
Construindo o Circuito do Medidor de Tempo de Reação
A Figura 3-14 mostra um diagrama esquemático de fiação para um circuito que pode ser
utilizado com o BASIC Stamp para fazer um medido de tempo de reação.
 Construa o circuito mostrado na Figura 3-14 da página 66.
 Execute TestBiColorLED.bs2 da Atividade #5 do Capítulo 2 para testar o
circuito de LED bicolor e ter certeza de que a fiação está correta.
 Se você apenas reconstruir o circuito de botão para essa atividade, execute
ReadPushbuttonState.bs2 da Atividade #2 deste capítulo para ter certeza que seu
botão está funcionando corretamente.
P15
1
1
2
Vdd
P14
470 Ω
Vdd
P3
220 Ω
10 kΩ
Vin
Vss
X3
2
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-14
Circuito de reação de
tempo
Vss
Programando o Medidor de Tempo de Reação
O programa de exemplo seguinte é fará com que o LED bicolor off até que o jogador
pressione e segure o botão. Quando o botão for pressionado, o LED ficará vermelho por
um curto período de tempo. Quando o LED ficar verde, o jogador tem que soltar o botão
o mais rápido que puder. O programa medirá o tempo necessário entre o LED ficar
verde e o botão ser solto.
O programa de exemplo também demonstra como o captador e o contador funcionam.
Captação é o processo de verificação se alguma coisa foi mudada, de modo muito
rápido repetidas vezes. Contagem é o processo de adicionar um número a uma variável
cada vez que algo acontece (ou não). Neste programa, o BASIC Stamp vai pesquisar a
partir do momento que o LED bicolor ficar verde até que o botão seja solto. Ele vai
esperar 1/1000 de um segundo, usando o comando PAUSE 1. Cada vez que ele capta e o
botão não é liberado, ele adiciona 1 à variável de contagem chamada timeCounter.
Quando o botão é solto, o programa para a captação e envia uma mensagem para o
DEBUG Terminal que exibe o valor da variável timeCounter.
Exemplo de Programa: ReactionTimer.bs2
 Coloque e execute ReactionTimer.bs2.
 Siga as instruções no DEBUG Terminal (ver a Figura 3-15).
Página - 67
Figura 3-15
Instruções no DEBUG Terminal
da reação de tempo do jogo.
' O que é um Microcontrolador - ReactionTimer.bs2
' Teste o tempo de reação com um botão e um LED bicolor.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
timeCounter
' Espera 1 segundo antes da
' primeira menssagem.
VAR
Word
' Declara variável para armazenar
' o tempo.
DEBUG "Aperte e segure o botão", CR, ' Exibe as instruções de reação.
"para fazer a luz ficar vermelha.", CR, CR,
"Quando a luz ficar verde, solte", CR,
"o botão o mais rápido possível.", CR, CR
DO
' Inicia o loop principal.
DO
LOOP UNTIL IN3 = 1
' Loop repete...
' Até o botão ser pressionado.
HIGH 14
LOW 15
' LED bicolor vermelho.
PAUSE 1000
' Atrasa 1 segundo.
LOW 14
HIGH 15
' LED bicolor verde.
timeCounter = 0
' Define timeCounter para zero.
DO
' Loop, conta o tempo...
PAUSE 1
timeCounter = timeCounter + 1
LOOP UNTIL IN3 = 0
' Até que o botão seja solto.
LOW 15
' LED bicolor desligado.
DEBUG "Seu tempo foi ", DEC timeCounter, ' Exibe medição de tempo.
" ms.", CR, CR,
Página - 68
"Para jogar novamente,", CR,
' Mostra instruções novamente.
"pressione o botão mais uma vez.", CR, CR
LOOP
' Volta para início do loop
' principal.
Como Funciona o ReactionTimer.bs2
Como o programa deve manter o controle do número de vezes que o botão foi
pressionado, uma variável chamada timeCounter é declarada.
timeCounter
VAR
para armazenar
Word
' Declara variável
' o tempo.
Variáveis iniciadas com zero: Quando a variável é declarada no PBASIC, este
valor é automaticamente zero até que o comando mostre um novo valor.
O comando DEBUG contém instruções para o jogador.
DEBUG
"Aperte e segure o botão", CR,
"para fazer a luz ficar vermelha.", CR, CR,
"Quando a luz ficar verde, solte", CR,
"o botão o mais rápido possível.", CR, CR
As declarações DO...LOOP podem ser assentadas. Em outras palavras, você pode colocar
um DO...LOOP dentro de outro.
DO
' Inicia o loop principal.
DO
' Loop repete...
LOOP UNTIL IN3 = 1
' Pausa do progama estava localizada aqui.
LOOP
' Volta para início do loop
' principal.
Faça com que a parte interna do DO...LOOP mereça mais atenção. O DO...LOOP
pode usar uma condição para decidir se deve ou não se deve sair do loop e passar para
os comandos que virão depois.. O DO...LOOP se repetirá enquanto o botão não for
pressionado (IN3 = 0). O DO ... LOOP será executado repetidas vezes, até que IN3
seja = 1. Então, o programa passa para o próximo comando após a declaração LOOP
UNTIL. Este é um exemplo de captação. O DO...LOOP..UNTIL ficará enquanto o
botão estiver pressionado.
DO
LOOP UNTIL IN3 = 1
' Loop repete...
Os comandos que surgem imediatamente após a declaração LOOP UNTIL acenderão o
LED bicolor vermelho, o atraso de um segundo fará com que o verde acenda.
Página - 69
HIGH 14
LOW 15
PAUSE 1000
' Atrasa 1 segundo.
LOW 14
HIGH 15
Assim que o LED bicolor ficar verde, é hora de começar a contagem para acompanhar
quanto tempo o jogador demora para soltar o botão. A variável timeCounter está
definida em zero, depois outro DO ... LOOP com uma condição UNTIL começa a se
repetir. Ele se repete até que o jogador solte o botão (IN3 = 0). Cada vez através do
loop, o BASIC Stamp atrasará 1 ms usando PAUSE 1, e também adiciona 1 ao valor
da variável timeCounter.
timeCounter = 0
' Define timeCounter para zero.
DO
' Loop, conta o tempo...
PAUSE 1
LOOP UNTIL IN3 = 0
' Até que o botão seja solto.
Depois que o botão é liberado, o LED bicolor estará desligado.
LOW 15
Os resultados são exibidos no DEBUG Terminal.
DEBUG "Seu tempo foi ", DEC timeCounter,
" ms.", CR, CR,
"Para jogar novamente,", CR,
"pressione o botão mais uma vez.", CR, CR
A última declaração no programa é LOOP, que envia o programa de volta para a
primeira declaração DO.
Sua Vez – Revisão do Projeto (Tópicos Avançados)
O departamento de marketing deu o seu protótipo para alguns testadores de jogos.
Quando os testes dos jogos tiverem sido feitos, o departamento de marketing entregará
para você uma lista detalhada com os três problemas que deverão ser solucionados antes
que seu protótipo possa ser inserido em um controlador de jogos.
 Salve
ReactionTimer.bs2
ReactionTimerYourTurn.bs2).
com
um
novo
nome
(como
A "lista detalhada" de problemas e suas soluções são discutidas abaixo.
Item 1: Quando um jogador segura o botão durante 30 segundos, a sua pontuação fica
em torno de 14,000 ms, uma medição de 14 segundos. Isso tem que ser corrigido!
Página - 70
Acontece que a execução do próprio circuito, juntamente com a adição de uma variável
timeCounter leva cerca de 1 ms, sem o comando PAUSE 1. Isto é chamado de
sobrecarga de código (code overhead), e é a quantidade de tempo que o BASIC Stamp
leva para executar os comandos. Uma solução rápida, que vai melhorar a precisão, é
simplesmente comentar o comando PAUSE 1 adicionando um apóstrofo à esquerda
dele.
' PAUSE 1
 Tente comentar PAUSE 1 e teste para ver a precisão do programa.
Em vez de comentar o atraso, outra maneira de corrigir o programa é multiplicar os
resultados por dois. Por exemplo, antes que o comando DEBUG exiba o número de ms,
você pode inserir um comando que multiplicará o resultado por dois:
timeCounter = timeCounter * 2
' <- Adicione isso
DEBUG "Seu tempo foi ", DEC timeCounter, " ms.", CR, CR
 Apague o apóstrofo do comando PAUSE e tente multiplicar por dois e terá uma
solução.
Para precisão, você pode usar operador o * / para multiplicar por um valor com
uma fração. O operador * / não é difícil de usar, veja como:
1.
Coloque o valor ou variável que você deseja multiplicar por um valor
fracionário perante o operador */.
2.
Pegue o valor fracionário que você deseja usar e multiplique por 256.
3.
Livre-se de qualquer coisa à direita do ponto decimal.
4.
Coloque esse valor após o operador */.
Exemplo: Digamos que você deseja multiplicar a variável timeCounter por
3,69.
1.
Comece colocando timeCounter a esquerda do operador */ :
timeCounter = timeCounter */
2.
Multiplique seu valor fracional de 256: 3.69 x 256 = 944.64.
3.
Arredondando: 944.64 ≈ 945.
4.
Coloque o valor à direita do operador */:
timeCounter = timeCounter */ 945
por 3,69”
' multiplica
A multiplicação por 2 vai dimensionar um resultado de 14.000 a 28.000, que é
aproximadamente 30.000. 30,000 ÷ 14,000 ≈ 2.14. Para multiplicar por 2,14, com o
operador * / é preciso descobrir quantos 1/256 estão em 2.14 para maior precisão.
Então, 2,14 x 256 = 547,84 ≈ 548. Você pode usar esse valor e o operador */ para
substituir timecounter = timeCounter * 2.
Página - 71
 Substitua timeCounter = timeCounter
timeCounter
*/
548
e
teste
*
2 por timeCounter
novamente
o
=
programa.
Seus 30 segundos de teste com o programa original, sem modificações, podem produzir
um valor que é um pouco diferente de 14000. Se isso acontecer, você pode usar o
mesmo procedimento com os resultados do teste para calcular um valor para o operador
*/ para obter resultados ainda mais precisos.
 Tente isso!
Item 2: Jogadores logo descobriram que o atraso de vermelho para verde é de 1
segundo. Depois de jogar várias vezes, eles são capazes de prever quando soltar, e
sendo assim, sua pontuação já não reflete o tempo real de reação.
O BASIC Stamp tem um comando RANDOM. Aqui está como modificar seu código para
usar um número aleatório.
 No início do seu código, adicionar a declaração de uma nova variável chamada
value e configurá-lá para 23. O valor de 23 é denominado seed, porque ele
começa a sequência de números pseudo-aleatórios.
timeCounter VAR Word
value VAR Byte
value = 23
' <- Adicione isso
' <- Adicione isso
 Antes do comando PAUSE 1000 dentro do DO...LOOP, use o comando
RANDOM para atribuir um valor a um novo valor aleatório a partir da seqüência
pseudo-aleatória, que começou com 23.
RANDOM value
' <- Adicione isso
DEBUG "Tempo de atraso", ? 1000 + value, CR
' <- Adicione isso
 Modifique o comando PAUSE 1000 para que o valor "random" seja adicionado
ao seu argumento Duration.
PAUSE 1000 + value
' <- Modifique isso
LOW 14
HIGH 15
 Uma vez que o maior valor que um byte pode armazenar é 255, o comando
PAUSE varia somente por ¼ segundo. Você pode multiplicar o valor da variável
por 4 para fazer o atraso da luz vermelha alternar de 1 para pouco mais de 2
segundos.
DEBUG "Tempo de atraso", ? 1000 + (value*4), CR
' <- Modifique
PAUSE 1000 + (value * 4)
' <- Modifique isso
'
novamente
Página - 72
O que é um algoritmo? Um algoritmo é uma sequência de operações
matemáticas.
O que é pseudo-aleatório? Meios pseudo-aleatório parecem aleatórios, mas não
são na verdade. Cada vez que você iniciar o programa novamente, você terá a
mesma seqüência de valores.
O que é um seed? Um seed é um valor que é utilizado para iniciar uma
sequência de pseudo-aleatórios. Se você usar um valor diferente para seed
(alteração de valor entre 23 e algum outro número), irá resultar em uma
seqüência diferente pseudo-aleatórios.
Item 3: Um jogador que solta o botão antes da luz ficar verde receberá uma pontuação
excessivamente boa (1 ms). Seu microcontrolador precisa descobrir se o jogador está a
trapaceando.
O pseudo-código foi introduzido neste capítulo no final da Atividade #3. Aqui está um
pseudo-código para ajudá-lo a aplicar uma declaração IF...THEN...ELSE para
resolver o problema. Supondo que você tenha feito as outras alterações nos itens 1 e 2,
timeCounter será agora 2 em vez de 1 se o jogador soltar o botão antes da luz ficar
verde. As mudanças abaixo funcionarão se timeCounter for 1 ou 2.
•
•
•
•
•
Se o valor de timeCounter é menor ou igual a 2 (timeCounter <= 2)
o Mostra uma mensagem que diz ao jogador que ele deve esperar até
depois que a luz fique verde para soltar o botão.
Logo, (se o valor de timeCounter for maior do que 1)
Mostra o valor do tempo de timeCounter (assim como em
ReactionTimer.bs2) em ms.
End If
Mostra a mensagem para jogar novamente
 Modifique seu programa implementando esse pseudocódigo no PBASIC para
corrigir o problema de um jogador trapaceiro.
Página - 73
SUMÁRIO
Este capítulo introduziu o botão e alguns circuitos de botão comuns. Este capítulo
também apresentou como construir e testar um circuito de botão e como usar o BASIC
Stamp para ler o estado de um ou mais botões. O BASIC Stamp foi programado para
tomar decisões com base no estado dos botões e esta informação foi usada para
controlar os LEDs. Um temporizador de reação de jogo foi construído usando esses
conceitos. Além de controlar os LEDs, o BASIC Stamp foi programado para captar o
botão e fazer as medições de tempo.
Vários conceitos de programação foram introduzidos, incluindo contagem, pseudocódigo para planejamento de fluxo de programa, sobrecarga de código em aplicações
sensíveis ao tempo, e os valores de seeds para eventos pseudo-aleatórios.
Foi introduzida a leitura de circuitos de botões individuais usando as variáveis especiais
de E / S incorporadas ao BASIC Stamp (IN3, IN4, etc). Também foram introduzidas
tomadas de decisões com base nesses valores usando IF...THEN...ELSE,
IF...ELSEIF...ELSE, blocos de código e operadores AND e OR para avaliar mais de
uma condição. Adicionando uma condição para o DO...LOOP usando a palavra-chave
UNTIL foi introduzido junto com o assentamento de blocos de código DO...LOOP. O
comando RANDOM foi apresentado ao adicionar um elemento de imprevisibilidade de um
aplicativo, a reação de tempo de jogo.
Questões
1. Qual é a diferença entre o envio e recepção de sinais HIGH e LOW usando o
BASIC Stamp?
2. O que significa "normalmente aberto", quando diz respeito a um botão?
3. O que acontece entre os terminais de um botão normalmente abertos quando
você os pressiona?
4. Qual é o valor de IN3 quando um botão é ligado ao Vdd? Qual é o valor de IN3
quando um botão é ligado ao Vss?
5. O que faz o comando DEBUG ? IN3?
6. Que tipo de blocos de código podem ser utilizados para tomar decisões com
base no valor de um ou mais botões?
7. O que faz o caractere HOME control na declaração DEBUG HOME?
Exercícios
1. Explicar como modificar ReadPushbuttonState.bs2 na página 57 para que ele
leia o botão a cada segundo, em vez de a cada ¼ de segundo.
2. Explicar como modificar ReadPushbuttonState.bs2 para que ele leia um circuito
de botão normalmente aberto com um resistor pull-up ligado ao pino de I/O P6.
Projeto
1. Modifique ReactionTimer.bs2 para ele seja um jogo para dois jogadores.
Adicione um segundo botão ligado a P4 para o segundo jogador.
Soluções
Q1.Enviando o BASIC Stamp para usar pino de I/O como uma saída, enquanto
receptor usa o pino de I/O como entrada.
Página - 74
Q2.Normalmente aberto significa que o estado normal do botão (não pressionado)
forma um circuito aberto.
Q3.Quando pressionada, a distância entre os terminais é uma ponte para um
condutor de metal. A corrente pode então fluir através do botão de pressão.
Q4. IN3 = 1 quando o botão estiver ligado a Vdd. IN3 = 0 quando o botão estiver
ligado a Vss.
Q5.DEBUG ? IN3 apresenta o texto "IN3 =", seguido pelo valor armazenado no
IN3 (0 ou 1 dependendo do estado do pino de I/O P3), seguido por um retorno
de transporte.
Q6.IF...THEN...ELSE and IF...ELSEIF...ELSE.
Q7.O caractere HOME control envia o cursor para a posição superior esquerda no
DEBUG Terminal.
E1. O DO...LOOP no programa se repete a cada ¼ de segundo, devido ao comando
PAUSE 250. Para repetir a cada segundo, mude o PAUSE 250 (250 ms = 0,25 s
= ¼ s), para PAUSE 1000 (1000 ms = 1 s).
DO
DEBUG ? IN3
PAUSE 1000
LOOP
P1. Substitua IN3 por IN6, para ler o pino de I/O P6. O programa só exibe a posição
do botão de estado, e não usa o valor para tomar decisões, o que não importa se
o resistor é um pull-up ou pull-down. O comando DEBUG irá exibir a posição do
botão de qualquer maneira.
DO
DEBUG ? IN6
PAUSE 250
LOOP
Primeiro, um botão foi adicionado para o segundo jogador, ligado ao pino de I/O P4 no
BASIC Stamp. O esquema baseia-se na Figura 3-14.
Vdd
P15
1
P4
220 Ω
10 kΩ
2
P14
470 Ω
Vss
Vdd
P3
220 Ω
10 kΩ
Vss
Fragmentos do programa de solução estão incluídos abaixo, mas mantenha em mente
que soluções podem ser codificadas de várias maneiras. No entanto, a maioria das
soluções deverá incluir as seguintes modificações:
Página - 75
Use duas variáveis para manter o controle de tempo dos dois jogadores:
timeCounterA VAR Word ' Tempo de pontuação do jogador A
timeCounterB VAR Word ' Tempo de pontuação do jogador B
Altere as instruções para mostrar dois botões:
DEBUG "Pressione e segure os botões", CR,
DEBUG "Pressione os botões novamente.", CR, CR
Espere para que ambos os botões sejam pressionados antes do LED ficar vermelho,
usando o operador AND:
LOOP UNTIL (IN3 = 1) AND (IN4 = 1)
Aguarde os dois botões serem lançados para finalizar o tempo , usando mais uma vez o
operador AND:
Adicione lógica que decide quando o tempo do jogador é incrementado:
IF (IN3 = 1) THEN
timeCounterA = timeCounterA + 1
ENDIF
IF (IN4 = 1) THEN
timeCounterB = timeCounterB + 1
ENDIF
Mude o tempo de exibição que mostra o tempo de ambos jogadores:
DEBUG "Player A Time:
DEBUG "Player B Time:
", DEC timeCounterA, " ms. ", CR
", DEC timeCounterB, " ms. ", CR, CR
Adicione lógica que mostra qual jogador que teve o tempo de reação mais rápido:
IF (timeCounterA < timeCounterB) THEN
DEBUG "Jogador A é o vencedor!", CR
ELSEIF (timeCounterB < timeCounterA) THEN
DEBUG "Jogador B é o vencedor!", CR
ELSE
DEBUG "Empate!", CR
ENDIF
A solução completa é mostrada abaixo.
'
'
'
'
'
'
O que é um Microcontrolador - Ch03Prj01_TwoPlayerReactionTimer.bs2
Teste o tempo de reação com um botão e um LED bicolor.
Adicione um segundo botão para outro jogador. Os jogadores jogam ao
mesmo tempo usando o mesmo LED. O que soltar mais rápido ganha.
Pino P3: Botão do Jogador A, Ativo High
Pino P4: Botão do Jogador B, Ativo High
' {$STAMP BS2}
Página - 76
' {$PBASIC 2.5}
timeCounterA VAR
timeCounterB VAR
PAUSE 1000
Word
Word
' Pontuação de tempo jogador A
' Pontuação de tempo jogador B
' 1 s antes da 1a mensagem
DEBUG "Press and hold pushbuttons", CR,
' Exibe instruções
"to make light turn red.", CR, CR,
' de reação.
"When light turns green, let", CR,
"go as fast as you can.", CR, CR
DO
' Inicia loop principal.
DO
' Loop até nada ser pressionado.
HIGH 14
LOW 15
PAUSE 1000
' Atrasa 1 segundo.
LOW 14
HIGH 15
timeCounterA = 0
timeCounterB = 0
' Define timeCounters para zero.
DO
PAUSE 1
IF (IN3 = 1) THEN
' Se o botão ainda estiver
timeCounterA = timeCounterA + 1' pressionado, incrementa counter
ENDIF
IF (IN4 = 1) THEN
timeCounterB = timeCounterB + 1
ENDIF
LOW 15
' Loop até os dois botões serem
' soltos.
' LED bicolor apagado.
DEBUG "Tempo do Jogador A: ", DEC timeCounterA, " ms. ", CR
DEBUG "Tempo do Jogador B: ", DEC timeCounterB, " ms. ", CR, CR
IF (timeCounterA < timeCounterB) THEN
DEBUG "Jogador A é o vencedor!", CR
ELSEIF (timeCounterB < timeCounterA) THEN
DEBUG "Jogador B é o vencedor!", CR
ELSE
' Tempos de A & B são iguais
DEBUG "Empate!", CR
ENDIF
DEBUG CR
DEBUG "To play again, hold the ", CR ' Intruções para jogar de novo.
DEBUG "buttons down again.", CR, CR
LOOP
' Retorna ao início do loop
' principal.
Página - 77
Capítulo 4: Controle de Movimento
MOVIMENTO MICROCONTROLADO
Microcontroladores fazem, no dia a dia, os objetos ao seu redor, se deslocarem para o
lugar certo. Se você tiver uma impressora jato de tinta, o cabeçote de impressão que ao
imprimir vai e volta ao longo da página, é movido por um motor de passo controlado
por um microcontrolador. As portas automáticas de supermercado que são abertas
quando você passa são controladas por microcontroladores, e o recurso de ejeção
automática no seu leitor de DVD também é controlado por um microcontrolador.
SINAIS DE ON/OFF E MOVIMENTOS DO MOTOR
Praticamente todos os motores microcontrolados recebem sequências de sinais de alta e
baixa semelhantes aos que você envia para os LEDs. A diferença é que o
microcontrolador envia esses sinais a taxas que são geralmente muito mais rápidas do
que os exemplos de LED que piscam, mencionados no Capítulo 2. Se você tivesse que
usar um circuito de LED para monitorar sinais de controle, alguns fariam a cintilação
LED on/off tão rapidamente que o olho humano não conseguiria detectar a mudança. O
LED só iria parecer que brilha fracamente. Outros apareceriam como um rápido
lampejo, e outros seriam mais facilmente discerníveis.
Alguns motores requerem vários de circuitos que ajudam o microcontrolador a
funcionar. Outros motores necessitam de peças mecânicas extras para fazê-los
funcionar, corretamente, em máquinas. De todos os diferentes tipos de motores,
começando com o servo hobby que você vai experimentar neste capítulo é
provavelmente o mais simples. Como você verá em breve, é fácil controlá-lo com o
BASIC Stamp, pois requer poucos ou nenhum circuito adicional, e tem uma saída
mecânica que facilita a conexão com os objetos ao movimentá-los.
INTRODUZINDO O SERVO
O servo hobby é um dispositivo que controla a posição, e você pode encontrá-lo em
praticamente qualquer carro controlado por rádio (RC), barco ou avião. Em carros com
RC, o servo mantém a direção para controlar a forma como o carro drasticamente gira.
Em um barco de RC, ele detém o leme na posição de voltas. Aviões com RC têm
normalmente vários servos posicionando as diferentes abas para controlar o movimento
do avião. Em veículos com RC com motores movidos a gás, outro servo move a
alavanca do acelerador do motor para controlar o quão rápido o motor funciona. Um
exemplo de um avião com RC e de seu controlador de rádio são mostrados na figura 41. Os amadores "voam" o avião através da manipulação do leme com o polegar no
controlador de rádio, fazendo com que os servos no avião controlem a posição das abas
e do leme do avião com RC.
Página - 78
Figura 4-1
Modelo de Avião e
Controlador de Rádio
Então, como será segurando o leme do controlador de rádio em uma determinada
posição provocando a aba do avião com RC para se manter em uma determinada
posição? O controlador de rádio converte a posição de uma das alavancas em pulsos de
radioatividade que duram uma determinada quantidade de tempo. O tempo final de cada
indica a posição de um dos joysticks. No avião com RC, um receptor de rádio converte
esses pulsos de atividade de rádio em pulsos digitais (sinais de alta/baixa) e os envia
para os servos do avião. Cada servo tem, em seu interior, um circuito que converte esses
pulsos digitais para uma posição, que o servo mantém. A quantidade de tempo de cada
pulso tem uma duração que diz que posição o servo deve manter. Esses pulsos de
controle duram apenas alguns milésimos de segundo, e são repetidos em torno de 40 a
50 vezes por segundo para que o servo mantenha a posição.
A Figura 4-2 mostra o desenho de um servo padrão da Parallax. A tomada (1) é
utilizada para ligar o servo a uma fonte de energia (Vss e Vdd) e a uma fonte de sinal
(um pino de I/O do BASIC Stamp). O cabo (2) tem três fios, e conduz Vdd, Vss e a
linha de sinal da tomada no servo. O horn (3) é a parte do servo que se parece com uma
estrela de quatro pontas. Quando o servo está em execução, o horn é a peça móvel que
mantém o servo em diferentes posições. O parafuso Phillips (4) mantém o horn no eixo
de saída do servo. A caixa (5) contém o sensor de posição do servo e os circuitos de
controle, um motor DC e engrenagens. Estas partes trabalham juntas para levar sinais de
alta/baixa do BASIC Stamp e traduzi-los em posições detidas pelo horn do servo.
Página - 79
2
Figura 4-2
Servo Padrão Parallax
3
1
(1) Tomada
(2) Cabo
(3) Horn
(4) Parafuso que
prende o horn no eixo
de saída do servo
(5) Caixa
4
5
Neste capítulo, você vai programar o BASIC Stamp para enviar sinais que controlam a
posição do horn do servo ao servo. Ao fazer o BASIC Stamp enviar sinais que dizem ao
servo que mantenha diferentes posições, seus programas também podem orquestrar o
movimento do servo. Seus programas podem, até mesmo, monitorar botões e usar
informações enquanto os botões são pressionados para ajustar a posição que o servo
mantém (botão de controle da posição do servo). O BASIC Stamp também pode ser
programado para receber as mensagens que você digitar no DEBUG Terminal e usar
essas mensagens para controlar a posição do servo (posição de controle do terminal do
servo).
ATIVIDADE #1: CONECTANDO E TESTANDO O SERVO
Nesta atividade, você vai seguir instruções para conectar um servo à fonte de
alimentação de sua própria placa e do BASIC Stamp.
Servo e Peças do Circuito de LED
(1) Servo padrão da Parallax
(1) LED – Qualquer cor
O circuito de LED será utilizado para monitorar o sinal de controle que o BASIC Stamp
envia para o servo. Tenha em mente que o circuito de LED não é necessário para ajudar
o servo operar. Ele está ali apenas para ajudar a "ver" os sinais de controle.
CUIDADO: Utilize apenas o servo padrão da Parallax para as atividades neste
texto! Outros servos podem ser projetados para diferentes especificações que
podem não ser compatíveis com essas atividades.
Página - 80
Construindo os Servos e Circuitos de LED
No Capítulo 1, você identificou e atualizou sua placa usando a ajuda do BASIC Stamp
Editor. Você vai precisar saber qual placa e atualização que você tem aqui para que
você possa encontrar as instruções de construção do circuito de servo para a sua placa.
 Se você ainda não sabe qual placa e atualização que possui, abra a ajuda do




BASIC Stamp Editor, vá pra a página inicial e clique em Primeiros Passos
(Getting Started) com Stamps in Class. Em seguida, siga as instruções para
identificar a sua placa.
Se você tem um Board of Education USB (qualquer Rev) ou Serial (Rev C ou
superior), vá para o circuito do Board of Education na seção abaixo.
Se você tem o BASIC Stamp HomeWork Board (Rev C ou superior), vá para
seção do circuito do BASIC Stamp HomeWork Board abaixo.
Se você tem o BASIC Stamp HomeWork Board (Rev C ou superior) vá para a
seção do circuito do BASIC Stamp HomeWork Board Servo na página 82.
Se a sua placa não estiver na lista acima, vá para www.parallax.com/Go/WAM
→ Conexões de Circuito do Servo ( Servo Circuit Connections) para encontrar
instruções de circuito para a sua placa.. Quando você fizer as instruções do
circuito do servo para a sua placa, vá para Atividade # 2: Programa de Teste de
Controle do Servo na página 84.
Circuito do Servo no Board of Education
Essas instruções são para todos USB Board of Education Revision C, bem como para o
Serial Board of Education Rev C ou superior.
 Desligue a energia mostrada na Figura 4-3.
Figura 4-3
Desconecte a energia
Coloque a chave na posição 0 no
conjunto de 3 posições
Reset
0
1
2
A Figura 4-4 mostra o cabeçalho do servo no Board of Education. Esta placa tem um fio
que você pode usar para conectar a fonte de alimentação do servo, quer Vin ou Vdd. O
fio é a peça retangular preta removível indicada pela seta entre os dois cabeçalhos do
servo.
 Verifique se o fio está definido em Vdd como mostrado na Figura 4-4. Se estiver
definido Vin, levante o fio retangular para fora dos pinos em que está
atualmente posicionado, e, em seguida, pressione-o nos dois pinos mais
próximos do rótulo Vdd.
Página - 81
Figura 4-4
Fio do cabeçalho do servo
definido para Vdd
15 14 Vdd 13 12
Red
Black
X4
X5
Vin
O fio permite que você escolha a fonte de alimentação (Vin ou Vdd) para o
Servo Padrão Parallax.

Se você estiver usando uma bateria de 9 V, configure-o para Vdd.

Se você estiver usando uma pilha elétrica 4 AA, ou baterias de 6 V,
qualquer configuração funcionará.

Se você estiver usando um suporte de parede com fonte de alimentação
DC, use apenas Vdd. Antes de conectar a fonte de montagem na parede
DC para o Board of Education, não se esqueça de verificar as
especificações aceitáveis para os suprimentos DC listados no BASIC
Stamp Editor Help.
A Figura 4-5 mostra o esquema do circuito que você vai construir em seu Board of
Education.
 Construa o circuito mostrado na Figura 4-5 e na Figura 4-6.
 Certifique-se de que você ligou o servo da maneira correta. Os fios branco,
vermelho e preto devem estar alinhados como mostrado na Figura 4-6
P14
Figura 4-5
Esquema
indicador do
Servo e do LED
para o Board of
Education
470 Ω
LED
Vss
Vdd
P14
White
Red
Black
Vss
Servo
Para Serial Board
of Education Rev
C, ou mais
recente, ou
qualquer USB
Board of
Education
Página - 82
15 14 Vdd 13 12
White
Red
Black
Red
Black
X4
Vdd
X3
X5
Vin
Vss
+
Figura 4-6
Servo e LED Indicador
no Board of Education
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
standard servo
www.parallax.com
Até agora, você tem usado o interruptor de 3 posições na posição 1. Agora, você vai
movê-lo para a posição 2 para ligar a energia para o cabeçalho servo.
 Forneça energia para o cabeçalho de servo ajustando o interruptor de três
posições, como mostrado na Figura 4-7. Seu servo pode mover-se um pouco
quando você ligar a energia.
Figura 4-7
Alimentação ligada ao Board of
Education e cabeçalho do Servo
Reset
0
1
2
Se você vir instruções neste capítulo, que se lê "Ligação de energia para o seu Board"
mova o interruptor de 3 posições para a posição-2. Da mesma forma, se você vir
instruções neste capítulo, que se lê "Desligue a alimentação de sua placa" mova o
interruptor de 3 posições para a posição-0.
 Desligue a alimentação de sua placa.
 Vá para a Atividade #2 na página 84.
Circuito do BASIC Stamp HomeWork Board Servo
Se você está conectando seu servo em um BASIC Stamp HomeWork Board (Rev C ou
mais recente), você vai precisar dessas peças extras do seu kit:
(1) Conector de 3 pinos macho (como mostrado na Figura 4-8).
(4) Fios
Página - 83
Figura 4-8
Peça extra para circuito do Servo
do BASIC Stamp HomeWork
Board
Conector de 3 pinos macho
A Figura 4-9 mostra o esquema do servo e circuitos indicadores do LED no BASIC
Stamp HomeWork Board. As instruções que vêm depois desta figura mostrarão como
construir com segurança este circuito.
 Desligue a bateria 9 V do seu HomeWork Board.
 Construa o indicador de LED e circuito do cabeçalho do servo mostrado no
esquema da Figura 4-9 e o diagrama de fiação na Figura 4-10.
P14
470 Ω
LED
Vss
Figura 4-9
Esquema de Servo e
LED Indicador no
HomeWork Board
Vdd
P14
White
Red
Servo
Black
Vss
Figura 4-10
LED Indicador e
circuitos do cabeçalho
do Servo no
HomeWork Board
 Ligue o servo no cabeçalho do servo, como mostrado na Figura 4-11.
 Certifique-se de que as cores dos fios do servo estejam alinhadas corretamente
com as cores marcadas na imagem.
 Confira a fiação.
Página - 84
ATENÇÃO
Utilize apenas uma bateria de 9 V quando o seu Servo Padrão Parallax estiver
ligado ao BASIC Stamp HomeWork Board. Não use qualquer tipo de
alimentação DC ou "bateria substituta" que se conecta a uma tomada AC.
Para melhores resultados, certifique-se que sua bateria é nova. Se você estiver
usando uma bateria recarregável, verifique se ela está recém-recarregada.
Também deve ser avaliada por 100 mAh (miliampere hora) ou mais.
 Reconecte sua bateria 9 V para seu HomeWork Board. O servo pode mexer-se
um pouco quando você fizer a conexão.
Figura 4-11
Servo Conectado ao
HomeWork Board
ATIVIDADE #2: PROGRAMA DE TESTE DE CONTROLE DO SERVO
Grau é a medida de um ângulo representada pelo símbolo “ ° ”. Exemplos de medidas
de grau do ângulo são mostrados na Figura 4-12, incluindo 30°, 45°, 90°, 135° e 180°.
Cada ponto de medição do ângulo representa 1/360 de um círculo, assim a medida de
90° é de ¼ de um círculo, ou seja, 90 ÷ 360 = ¼. Da mesma forma, 180° é ½ de um
círculo, ou seja, 180 ÷ 360 = ½, você pode calcular frações semelhantes para as outras
medições de graus na figura.
Figura 4-12
Exemplos de medidas
de ângulo em graus
O servo padrão da Parallax é capaz de manter qualquer posição dentro de uma gama de
180°, assim as medições de grau podem ser úteis para descrever as posições que o servo
detém. A Figura 4-13 mostra exemplos de um servo com um laço de arame, que foi
introduzido através de dois dos furos em seu horn e, em seguida, torcido. A direção que
o laço de torção aponta indica o ângulo do horn do servo, veja na figura exemplos de 0°,
45°, 90°, 135° e 180°.
Página - 85
Figura 4-13: Exemplos da posição do horn de um servo
A amplitude de movimento e limites mecânicos do horn de seu servo
provavelmente será diferente do que é mostrado aqui. As instruções sobre como
ajustá-lo para corresponder a essa imagem virão após o primeiro programa de
exemplo.
Durante a fabricação, a montagem do horn do servo é aleatória, por isso as posições do
horn do servo serão, provavelmente, diferentes das mostradas na Figura 4-13. Na
realidade, em comparação com a Figura 4-13, o horn de seu servo pode ser montado em
qualquer posição em uma faixa +/- 45°. O servo na Figura 4-14 mostra o exemplo de
um servo cuja ponta foi montada a 20°, no sentido horário, a partir da Figura 4-13.
Depois de encontrar o centro da amplitude de movimento do horn do servo, você pode
usá-la como uma referência de 90° ou ajustar mecanicamente o horn do servo para que
ele corresponda a Figura 4-13 seguindo instruções incluídas mais a frente nesta
atividade.
Figura 4-14: Exemplos de posição do horn do servo antes do ajuste mecânico
Este é um exemplo de um horn que está montado no eixo de saída do servo cerca
de 20° para a esquerda da forma como foi definido na Figura 4-13.
Você pode encontrar o centro da amplitude de movimento do servo girando suavemente
o horn para encontrar seu sentido horário e anti-horário nos limites mecânicos. A
posição a meio caminho entre estes dois limites é o centro, ou a posição de 90°. A
posição central do servo pode cair em qualquer lugar da área mostrada na Figura 4-15.
Página - 86
O centro da amplitude de movimento do horn de
seu servo deve cair em algum lugar nesta área.
Figura 4-15
Gama de posições
centrais possíveis
Nestes próximos passos, torça o horn do servo lentamente sem forçá-lo! O
servo foi construído com limites mecânicos para evitar que o horn gire fora de
sua faixa de 180° de movimento. Torça o horn suavemente, e você será capaz de
sentir quando ele atinge um dos seus limites mecânicos. Não tente forçá-lo além
desses limites, pois assim você pode tirar as engrenagens de dentro do servo do
lugar.
 Verifique se a energia de sua placa ainda está desconectada.
 Delicadamente gire o horn do servo para descobrir os seus limites mecânicos,
em sentido horário e anti-horário. O horn do servo girará aplicando muita pouca
força até chegar a esses limites. NÃO TENTE TORCER OS HORNS ALÉM
DESTES LIMITES, torça somente o suficiente para encontrá-los.
 Gire o horn do servo para que ele fique a meio caminho entre os dois limites.
Esta é, aproximadamente, a posição "central" do servo.
 Com o horn do servo em sua posição central, passe um fio através do horn, torça
e amarre-o para que ele aponte para cima, na área mostrada na Figura 4-15.
Tenha em mente que a direção do laço de torção mostrada na figura é apenas um
exemplo; o seu laço de torção pode apontar para qualquer lugar da área. Onde quer que
ele aponte quando estiver no centro de sua amplitude de movimento, deveria estar bem
próximo da posição de 90° do servo. Mais uma vez, esta posição pode variar de um
servo para o outro, devido a forma que o horn é conectado ao servo.
Programando a Posição do Servo
O gráfico na Figura 4-16 é chamado de diagrama de tempo, e mostra exemplos de sinais
de alta/baixa que o BASIC Stamp tem que enviar ao servo para fazê-lo manter sua
posição de 90°.
Página - 87
Figura 4-16
Diagrama de
tempo do sinal do
Servo
Pulsos de 1,5 ms
fazem com que o
servo mantenha a
posição “central”
de 90°
O diagrama de tempo mostra sinais de alta que duram 1,5 ms, separados por sinais de
baixa que duram 20 ms. O ... para a direita do sinal é uma maneira de indicar que os
sinais de baixa de 1,5 ms e 20 ms têm de ser repetidos várias vezes para fazer o servo
manter a posição. O símbolo "~" em "~ 20 ms" indica que o tempo de baixa pode ser
aproximado, podendo variar de alguns milésimos de segundos acima ou abaixo de 20
ms, com quase nenhum efeito sobre as posições do horn do servo. Isso porque a
quantidade de tempo que o sinal de alta dura, é que diz ao servo que posição ficar, por
isso tem que ser precisa.
Há um comando especial chamado PULSOUT que dá ao seu programa um controle
preciso sobre as durações desses breves sinais de alta, que são comumente chamados
pulsos. Aqui está a sintaxe do comando PULSOUT:
PULSOUT Pin, Duration
Com o comando PULSOUT, você pode escrever o código PBASIC para fazer o BASIC
Stamp definir a posição do servo a 90° usando a Figura 4-16 do diagrama de tempo
como um guia. O argumento Pin do comando PULSOUT tem que ser um número que diz
que ao BASIC Stamp qual pino de I/O deve transmitir o pulso. O argumento Duration
do comando PULSOUT é o número de dois milionésimos-de-um-segundo, que é o tempo
que o pulso deve durar. 2 milionésimos de um segundo é igual a 2 microssegundos, que
é abreviado 2 μs.
Um milionésimo de segundo é chamado de um microssegundo. A letra grega
µ é usada no lugar da palavra micro e a letra s é usado no lugar do segundo. Isso
é útil para escrever e fazer anotações, pois ao invés de escrever dois
microssegundos, você pode escrever 2µs.
Lembrete: um milésimo de segundo é chamado de milésimo de segundo e é
abreviado ms.
Fato: 1 ms = 1000 µs. Em outras palavras, pode caber 1/1000000000 de um
segundo em um milésimo de segundo.
Agora que sabemos como usar o comando PULSOUT, o ServoCenter.bs2 envia pulsos de
controle repetidamente para fazer o servo manter sua posição de 90°. O comando
PULSOUT 14, 750 irá enviar um pulso de 1,5 ms para o servo. Isso porque o
argumento Duration do comando PULSOUT especifica o número de 2 μs que o pulso
deve durar. Desde que o argumento Duration seja 750, o comando PULSOUT fará o
último pulso para 750 × 2 μs = 1.500 μs, que é de 1,5 ms uma vez que existem 1.000 μs
em 1 ms. Após o pulso de alta ter sido feito, o comando PULSOUT deixa o pino de I/O
enviar um sinal de baixa. Assim, um comando PAUSE 20 depois do PULSOUT faz com
Página - 88
que o BASIC Stamp envie um sinal de baixa para 20 ms. Com esses dois comandos
dentro de um DO...LOOP, o 1,5 ms de alta seguido por 20 ms de baixa será repetido
várias vezes para fazer o servo esperar a sua posição.
Exemplo de Programa: ServoCenter.bs2
' O que é um Microcontrolador - ServoCenter.bs2
' Mantém o servo na posição central.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programa Funcionando!", CR
DO
PULSOUT 14, 750
PAUSE 20
LOOP
Teste o Servo na Posição “Central” de 90°
A posição do servo a 90° é chamada de posição central, porque o ponto 90° está no
"centro" da amplitude do movimento de 180° do servo. Os pulsos de 1,5 ms fazem o
servo manter seu horn nesta posição central, que deve ser no meio do caminho
determinado para encontrar os limites mecânicos do servo. Você pode usar qualquer
posição central do servo para manter a referência de 90°, ou usar uma chave de fenda
para remover e reposicionar o horn, assim 90° faz com que o fio do ponto do laço de
torção aponte para cima. As instruções para isso virão na seção intitulada: Opcional –
Ajuste dos horns do servo para 90° no Centro. Se você usar a posição central como
referência, sem ajustá-la, qualquer outra posição que o servo mantiver será próxima a
90°. Por exemplo, a posição de 45° será de 1/8 de volta no sentido horário, e a posição
135° será de 1/8 de volta para a esquerda. Exemplos disto foram mostrados na Figura 414 na página 86.
Vamos primeiro verificar qual posição central real de seu servo:
 Gire cuidadosamente o horn do servo para um de seus limites mecânicos.
 Reconecte a energia de sua placa. Se você tem o Board of Education, certifique-
se de deslizar as 3 posições até o fim para a direita (para posição-2).
 Execute o ServoCenter.bs2.
Assim que o programa for carregado, o horn do servo deve girar para a posição central e
ficar assim. O servo "ficará" nesta posição, porque os servos padrão são projetados para
resistir às forças externas que o empurram contra ele. É assim que o servo mantém a
direção RC do carro, do leme do barco, ou da aba de controle do avião no local.
 Tome nota da posição do centro de seu servo.
 Aplique uma pressão suave na torção do horn como você fez ao girar o servo
para encontrar os seus limites mecânicos. O servo deve resistir e segurar seu
horn na posição central.
Página - 89
Se você desligar a alimentação, você pode girar o servo fora da posição central. Quando
você reconectar energia, o programa vai reiniciar e o servo vai mover imediatamente o
horn de volta à sua posição central e mantê-lo lá.
 Tente isso!
Opcional – Ajuste o Horn do Servo para 90° Central
Opcionalmente, é possível ajustar o horn de seu servo para que ele faça o fio do laço de
torção apontar para cima quando ServoCenter.bs2 estiver em execução, como mostrado
no lado direito da Figura 4-17. Se você fizer este ajuste mecânico, vai simplificar o
rastreamento dos ângulos do servo, pois cada ângulo será semelhante aos da Figura 4-13
na página 86.
Você vai precisar de uma chave Phillips número 2 para esse ajuste opcional.
Eixo
de
saída
Chave
de fenda
Phillips
Figura 4-17
Centralização
Mecânica do
Servo
Você pode
remover e
reposicionar o
horn do servo no
eixo de saída com
uma pequena
chave de fenda
horn
 Retire o parafuso que prende o horn do servo ao seu eixo de saída e, em seguida,
puxe delicadamente o horn para fora da cápsula para libertá-la. Suas peças
devem assemelhar-se a que está no lado esquerdo da Figura 4-17.
 Reconecte a energia de sua placa. O programa deve fazer o servo manter o eixo
de saída na posição central.
 Deslize o horn de volta no eixo de saída do servo para que seu laço aponte para
cima, da mesma forma que é mostrada no canto direito da Figura 4-17.
Compensando o Alinhamento: O alinhamento do servo pode não fica perfeito
devido a forma como o horn se encaixa no eixo de saída, mas pode ser próximo.
Você pode então ajustar a alça de arame para compensar este pequeno desvio e
fazer o ponto do laço de torção para cima.
 Volte a apertar o parafuso Phillips.
 Reconecte a alimentação para que o programa faça com que o servo mantenha
sua posição central novamente. O laço de torção agora deve apontar para cima
(ou quase em linha reta) indicando a posição de 90°.
Página - 90
Sua Vez – Programas para o Servo Apontar Diferentes Direções
A Figura 4-18 mostra alguns comandos PULSOUT que dizem ao servo que mantenha
certas posições importantes, como 0°, 45°, 90°, 135° e 180°. Estes comandos PULSOUT
são aproximados, e você terá que ajustar levemente os valores para obter posições
angulares mais precisas. Você pode modificar o argumento Duration do comando
PULSOUT para ocupar qualquer área neste intervalo. Por exemplo, se você deseja que o
servo mantenha a posição de 30°, o argumento Duration do comando PULSOUT teria
que ser 417, que é 2/3 do caminho entre o argumento Duration de 250 (0°) para 500
(45°).
As durações de pulso na Figura 4-18 deixarão o horn do servo próximo aos
ângulos indicados, mas elas não são necessariamente exatas. Você pode
experimentar com diferentes valores PULSOUT Duration para um
posicionamento mais preciso.
 Salve uma cópia do ServoCenter.bs2 como TestServoPositions.bs2
 Altere o argumento PULSOUT Duration do programa de 750-para 500, e execute
o programa modificado para verificar se ele faz com que o servo mantenha sua
posição de 45°.
 Repita este teste de argumentos PULSOUT Duration com 1000 (135°), e 417
(30°).
 Para tentar prever o PULSOUT Duration você precisaria de uma posição que não
está listada na Figura 4-18, e teste para certificar-se de que o servo gire o horn e
mantenha a posição que você deseja. Exemplo de posições que podem incluir
60°, 120° etc.
Mantenha os argumentos PULSOUT Duration de seu programa na faixa 350
para 1150. A faixa é "em teoria", de 250-1250, mas na prática, o servo pode
tentar ir além dos seus limites mecânicos. Isto pode reduzir a vida útil do servo.
Se você quiser maximizar o alcance de movimento de seu servo, cuidadosamente
teste os valores que ficam gradualmente mais perto dos limites mecânicos.
Enquanto você usar os valores PULSOUT Duration que posicionam o horn do
servo apenas para dentro de seus limites mecânicos, o desgaste será normal em
vez de excessivo.
Página - 91
Figura 4-18: Posições do horn do servo, comandos PULSOUT durações de pulso
em ms.
Faça o Cálculo
Junto com cada comando PULSOUT na Figura 4-18, há um número correspondente a
milésimos de segundos que cada pulso dura. Por exemplo, o pulso que o comando
PULSOUT 14, 417 envia dura 0,834 ms, e o pulso que o PULSOUT 14, 500 envia
dura 1,0 ms. Se você tem um BASIC Stamp 2 e quer converter o tempo de milésimos de
segundos para o argumento Duration para o seu comando PULSOUT, use essa equação:
Duration = number of ms × 500
Por exemplo, se você já não soubesse que o argumento Duration do comando PULSOUT
para 1,5 ms é 750, aqui está como você pode calcular isso:
Duration = 1 .5 × 500
= 750
A razão pela qual nós devemos multiplicar o número de milésimos de segundos em um
pulso por 500 para obter um argumento Duration do comando PULSOUT é porque
Duration é em termos de unidades de 2 μs para o BS2. Quantas unidades de 2 μs têm em
1 ms? Para descobrir, basta dividir 2 sobre um milionésimo por 1 sobre 1 milésimo.
1
2
÷
= 500
1,000 1,000,000
Se o seu comando for PULSOUT 14, 500, o pulso vai durar 500 × 2 = 1.000 μs = 1,0
ms. (Lembre-se, 1,000 μs = 1 ms.)
Página - 92
Você também pode descobrir o enigma de um argumento Duration de um comando
PULSOUT usando esta equação:
number of ms =
Duration
ms
500
Por exemplo, se você considerar o comando PULSOUT 14, 850, quanto tempo o pulso
realmente durou?
850
ms
500
= 1 .7 ms
number of ms =
Escreva o Código de Diagramas de Tempo
A Figura 4-19 mostra um diagrama de tempo do sinal que o BASIC Stamp pode enviar
a um servo para que seu horn mantenha uma posição de 135°. Uma vez que este
diagrama de tempo apresenta pulsos repetidos, separados por sinais de baixa de 20ms, o
DO ... LOOP do ServoCenter.bs2 fornece um bom ponto de partida, e tudo o que
precisa ser ajustado é a duração do pulso de alta frequência. Para calcular o argumento
Duration do comando PULSOUT para pulsos de 2 ms no diagrama de tempo, você pode
usar a equação Duration na seção “Faça o cálculo” (Do the Math)
Duration = number of ms × 500
= 2.0 × 500
= 1000
Quando 1000 for substituído no argumento Duration do comando PULSOUT, o loop de
controle do servo deve ficar assim:
DO
PULSOUT 14, 1000
PAUSE 20
LOOP
 Teste o DO...LOOP em uma cópia do ServoCenter.bs2 e verifique se posição do
horn do servo está próxima de 135°.
 Repita este exercício para o diagrama de tempo na Figura 4-20.
Figura 4-19
Diagrama de
Tempo para
Posição de 135°
Pulsos de 2 ms
separados por 20
ms
Página - 93
Figura 4-20
Diagrama de
Tempo para
Posição de 45°
Pulsos de 1 ms
separados por 20
ms
ATIVIDADE #3: CONTROLE DE TEMPO DE ESPERA DO SERVO
Animatrônicos utilizam a eletrônica para animar adereços e efeitos especiais, e os
servos são uma ferramenta comum neste campo. A Figura 4-21 mostra o exemplo de
um projeto de robótica de uma mão animatrônica, com servos controlando cada dedo. O
programa PBASIC que controla os gestos das mãos tem que fazer os servos manterem a
posição por um determinado período de tempo para cada gesto. Na atividade anterior, os
nossos programas fizeram com que os servos sustentassem determinadas posições por
tempo indeterminado. Esta atividade apresenta como escrever um código que faz com
que o servo mantenha certas posições por determinados períodos de tempo.
Figura 4-21
Mão Animatrônica
Há cinco servos na parte inferior
direita da figura que estão
conectados aos dedos e que,
quando acionados, fazem-os
flexionar. Sendo, assim o BASIC
Stamp possui controle sobre
cada dedo.
Loops FOR...NEXT para Controlar o Tempo que o Servo Mantém uma
Posição
Se você escrever um código para fazer um LED piscar uma vez por segundo, você pode
inserir o código em um loop FOR...NEXT que se repete três vezes para fazer com que
a luz pisque por três segundos. Se os seus LEDs piscam cinco vezes por segundo, você
terá que fazer o loop FOR...NEXT repetir o circuito quinze vezes para fazer com que o
LED pisque por três segundos. Uma vez que os comandos PULSOUT e PAUSE que
controlam o seu servo são responsáveis por enviar sinais de alta/baixa, eles também
fazem o LED piscar. Os sinais que enviamos para o servo na atividade anterior fizeram
com que o brilho do LED fosse fraco, talvez com uma aparente tremulação, porque os
sinais on/off são muito rápidos, e os tempos de alta muito breves. Vamos diminuir os
sinais até a velocidade 1/10 para que a luz do LED indicador fique visível e piscando.
Página - 94
Exemplo de Programa: SlowServoSignalForLed.bs2
Comparado com o sinal do centro do servo, este exemplo de programa aumenta as
durações do PULSOUT e PAUSE por um fator de dez, para que possamos vê-los como o
LED indicador pisca. O loop FOR ... NEXT do programa se repete em quase 5 vezes
por segundo, de modo que 15 repetições resultam no piscar da luz por três segundos.
 Desconecte a energia do seu servo:




o Se você tem o Board of Education, coloque o interruptor de 3 posições
para posição 1 para desligar a alimentação do servo. A posição 1
continua a fornecer energia ao resto do sistema.
o Se você tem o BASIC Stamp HomeWork Board, desligue
temporariamente a ponta do fio que está ligada a Vdd e deixe-a livre. Isto
irá desligar a alimentação do seu servo.
Coloque e execute SlowServoSignalsForLed.bs2.
Verifique se o LED pisca rapidamente por cerca de três segundos.
Substitua o EndValue, do loop FOR...NEXT, de 15 para 30 e reexecute o
programa. Como o loop é repetido de duas a infinitas vezes, a luz deve piscar
pelo dobro de tempo - seis segundos.
Reconecte a energia de seu servo:
o Se você tem o Board of Education, coloque o interruptor de 3 posições
de volta a posição 2 para reconectar o servo.
o Se você tem o BASIC Stamp Homework Board, ligue a extremidade do
fio que você desconectou na tomada Vdd.
' O que é um Microcontrolador – SlowServoSignalsForLed.bs2
' Diminua para 1/10 a velocidade do sinal do servo para que seja
' possível ver o LED indicador acender e apagar.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programa funcionando!", CR
counter
VAR
Word
PULSOUT 14, 7500
PAUSE 200
NEXT
Exemplo de Programa: ThreeServoPositions.bs2
Se você alterar PULSOUT 14, 7500 para PULSOUT 14, 750 e PAUSE 200 para
PAUSE 20, você terá um loop FOR...NEXT que envia rapidamente o sinal de posição
central para o servo. Uma vez que os sinais agora duram 1/10 de suas durações no
SlowServoSignalsForLed.bs2, todo o loop FOR...NEXT levará 1/10 de tempo para ser
executado. Se o objetivo é fazer com que o servo mantenha uma determinada posição
por três segundos, simplesmente envie o número de pulsos dez vezes maior,
aumentando o argumento FOR...NEXT EndValue de 15 a 150.
segundos.
PULSOUT 14, 750
PAUSE 20
' Centralize por cerca de 3
Página - 95
LOOP
O programa de exemplo ThreeServoPositions.bs2 faz o servo manter três posições
diferentes que são mostradas na Figura 4-22, cada uma por cerca de 3 segundos.
Figura 4-22
ThreeServoPositions.bs2
O programa faz com que
o servo mantenha cada
posição por cerca de
três segundos.
 Coloque e execute o ThreeServoPositions.bs2.
 Verifique se o servo mantém cada posição na sequência mostrada na Figura 4-22
por cerca de três segundos.
A última posição que o servo vai manter por 3 segundos é de 135° e, em seguida, o
programa para. O horn do servo vai ficar na mesma posição, mesmo o BASIC Stamp
tendo parado de enviar os pulsos de controle. A diferença é que, durante os três
segundos que o BASIC Stamp mantém a posição de 135°, o servo resiste a quaisquer
forças que tentam empurrar o horn para longe dessa posição. Após os 3 segundos, o
horn do servo poderá manipulado manualmente.
Um jeito de você dizer se o servo está recebendo sinais de controle é observar o
indicador de LED que está conectado ao P14. Enquanto o LED indicador estiver aceso,
significa que o servo está recebendo sinais de controle e mantendo a sua posição.
Quando o sinal parar você verá o brilho no LED indicador parar também.
 Reexecute o programa (ou apenas pressione e solte o botão Reset de sua placa).
 Assim que o servo atingir a posição de 135°, fique de olho no sinal do LED
indicador enquanto você aplica uma leve força de torção no horn.
Você deve ser capaz de sentir a resistência do servo enquanto o LED acende de modo
muito fraco indicando que o servo ainda está recebendo um sinal de controle. Assim que
o LED desligar, indicando que o sinal de controle está parado, o servo irá parar de
manter a sua posição, e você será capaz de girar o horn manualmente.
 Quando o sinal de 135° parar, verifique se o LED indica que o sinal foi
interrompido e se o servo permite que você torça o horn além da posição 135°.
' O que é um Microcontrolador – ThreeServoPositions.bs2
' Servo mantém as posições de 45, 90, e 135 graus por cerca de 3
' segundos cada.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
PAUSE 1000
DEBUG "Posição = 45 graus...", CR
Página - 96
PULSOUT 14, 500
PAUSE 20
NEXT
' 45 graus por cerca de 3 seg.
PULSOUT 14, 750
PAUSE 20
NEXT
PULSOUT 14, 1000
PAUSE 20
NEXT
DEBUG "Pronto.", CR, CR
END
Sua Vez – Ajustando a Posição vs. Ajustando o Tempo de Espera
ThreeServoPositions.bs2 assume que executar 50 pulsos do servo em um loop
FOR...NEXT leva cerca de 1 segundo. Você também pode usar isso para ajustar o
tempo de espera, ajustando o argumento do EndValue do loop FOR...NEXT. Por
exemplo, se você deseja que o servo mantenha sua posição por cerca de dois segundos,
altere o argumento EndValue de 150 para 100. Para cinco segundos, altere de 150 para
250, e assim por diante.
 Salve uma cópia do ThreeServoPositions.bs2.
 Modifique cada argumento do EndValue do loop FOR...NEXT e experimente
diferentes valores para diferentes tempos de espera.
 Opcional: Personalize as posições de espera, ajustando argumento Duration de
cada comando PULSOUT.
Repetição de Tempo do Loop FOR...NEXT – Realmente é 1/44 de
Segundo, não 1/50
1/50 de um segundo é uma aproximação grosseira de repetição do loop. 1/44 de um
segundo é uma aproximação mais aproximada. Considere a quantidade de tempo que
cada elemento do loop FOR...NEXT leva para ser executado. O comando PULSOUT
14, 750 está no meio da faixa de possíveis durações de pulso, para que ele possa ser o
ponto de referência para a duração média de pulso. Ele envia um pulso que dura 750 × 2
ms = 1.500 ms = 1,5 ms. O comando PAUSE 20 faz o programa atrasar 20 ms. O loop
FOR...NEXT com comandos PULSOUT e PAUSE leva cerca de 1.3 ms para processar
todos os números e comandos. Embora isso signifique que o sinal de baixa entre os
pulsos dura 21,3 ms em vez de 20 ms, não afeta o desempenho do servo. Os tempos de
baixa podem ser alguns ms off, é apenas as durações de pulso de alta que tem que ser
precisas, e o comando PULSOUT é muito preciso.
Página - 97
Assim, o tempo total que o loop FOR ... NEXT leva para repetir é de 1,5 ms + 20 ms
+ 1.3 ms = 22,8 ms, que é 22,8 milésimos de segundo. Então, quantos 22,8 milésimos
de segundo se encaixam em um segundo? Vamos dividir 0,0228 por 1 e descobrir:
1 second ÷ 0.0228 seconds/repetition ≈ 43.86 repetition s
≈ 44 repetition s
É por isso que o loop é repetido a uma média de cerca de 44 repetições por segundo. O
número de repetições em um segundo é chamado de hertz, abreviado Hz. Assim,
podemos dizer que as repetições ou ciclos de sinal do servo serão de aproximadamente
44 Hz.
Ciclos e hertz (Hz): Quando um sinal se repete por um determinado número de
vezes, cada repetição é chamada de ciclo. O número de ciclos de um segundo é
medido em hertz. Hertz é abreviado Hz.
Maiores ou menores valores do PULSOUT Duration levam o loop FOR...NEXT a se
repetir em pouco mais ou menos tempo. O PULSOUT Duration de 750 está bem no meio
da faixa das durações de controle de pulso do servo, mostrada novamente na Figura 418 na página 92. Você pode utilizar 44 Hz como uma referência para o número de
pulsos por segundo no seu código. Se você precisar ser mais preciso, basta repetir o
cálculo para o comando PULSOUT que você está usando. Por exemplo, se o loop tem um
comando PULSOUT com Duration de 1000 em vez de 750, levará 2 ms para o pulso, em
vez de 1,5 ms. O loop ainda tem uma pausa de 20 ms e de 1,3 ms de tempo de
processamento. Então, acrescenta-se 2 + 20 + 1,3 ms = 23,3 ms. Divida 1 segundo por
esse valor para descobrir a taxa do loop FOR...NEXT, e teremos 1 ÷ 0,0233 ≈ 42,9 ≈ 43
Hz.
Sumário de Controle do Loop FOR...NEXT do Servo
A Figura 4-23 mostra a parte que cada número em um loop FOR...NEXT desempenha
no controle do servo. O EndValue do loop FOR...NEXT determina o número de 1/44 de
um segundo para o servo manter a posição. O argumento Duration do comando
PULSOUT diz ao servo que posição manter. O valor de 750 envia um pulso de 1,5 ms,
que instrui o servo a deter uma posição de 90° segundo a Figura 4-18 na página 108. O
argumento Pin do comando PULSOUT escolhe o pino de I/O para o envio de sinais de
controle do servo. Assim, 14 faz com que o comando PULSOUT envie breve sinal de alta
(pulso) para o servo ligado ao pino de I/O P14. Quando o pulso termina, leva o pino de
I/O a enviar um sinal de baixa. Em seguida, o comando PAUSE 20 assegura que o sinal
de baixa dure aproximadamente 20 ms antes do pulso seguinte.
Página - 98
“Pino de I/O do
Servo”
“Número de 44ths de
um segundo para
manter a posição”
FOR counter = 1 TO
132
“Posição a manter”
PULSOUT 14, 750
PAUSE 20
NEXT
“Necessário 20 ms
Figura 4-23
Loop FOR
...NEXT para
Controle do
Servo
entre cada pulso”
Na média, um loop FOR...NEXT, envia um único comando PULSOUT ao servo, seguido
de PAUSE 20, que repete cerca de 44 vezes por segundo. Uma vez que este ciclo se
repete 132 vezes, faz com que o servo mantenha a posição 90° por cerca de 3 segundos.
Isso por que:
132 repetition s ÷ 44 repetition s/second = 3 seconds
Se a sua aplicação ou projeto precisa fazer o BASIC Stamp enviar ao servo um sinal por
um determinado número de segundos, basta multiplicar o número de segundos por 44, e
usar o resultado em seu argumento EndValue do loop FOR...NEXT. Por exemplo, se o
sinal deve durar cinco segundos:
5 seconds × 44 repetitions/second = 220 repetitions
ATIVIDADE #4: CONTROLANDO POSIÇÕES COM SEU COMPUTADOR
A automação industrial envolve, muitas vezes, microcontroladores que se comunicam
com computadores de maior porte. Os microcontroladores leem sensores e transmitem
os dados para o computador principal. O computador principal interpreta e analisa os
dados do sensor e envia informações de volta sobre a posição para o microcontrolador.
O microcontrolador pode, em seguida, atualizar a velocidade da correia de transporte,
classificar uma posição, ou alguma outra tarefa mecânica de controle do motor.
Você pode usar o DEBUG Terminal para enviar mensagens a partir do seu computador
para o BASIC Stamp, como mostrado na Figura 4-24. O BASIC Stamp tem que ser
programado para ouvir as mensagens que você enviar, usando DEBUG Terminal, e
também para armazenar os dados que você enviar em uma ou mais variáveis.
Página - 99
Figura 4-24
Enviando mensagens
para o BASIC Stamp
Clique no campo branco
acima do painel de
exibição da mensagem e
digite sua mensagem.
Uma cópia da mensagem
que você digitou aparece
na janela inferior. Essa
cópia é chamada de eco.
Nesta atividade, você vai programar o BASIC Stamp para receber dois valores a partir
do DEBUG Terminal e, em seguida, usar esses valores para controlar o servo:
1. Número de pulsos para enviar ao servo
2. Valor do argumento Duration usado pelo comando PULSOUT
Você também vai programar o BASIC Stamp para usar esses valores para controlar o
servo.
Peças e Circuito
As mesmas da Atividade #2
Programando o BASIC Stamp para Receber Mensagens do DEBUG
A programação do BASIC Stamp para envio de mensagens para o DEBUG Terminal é
feita usando o comando DEBUG. A programação do BASIC Stamp para receber
mensagens do DEBUG Terminal é feita usando o comando DEBUGIN. Ao utilizar o
DEBUGIN, você também terá que declarar uma ou mais variáveis para o BASIC Stamp
armazenar as informações que recebe.
Aqui está um exemplo de uma variável que você pode declarar para que o BASIC
Stamp armazene um valor:
pulses VAR Word
Posteriormente no programa, você poderá usar essa variável para armazenar um número
recebido pelo comando DEBUGIN:
DEBUGIN DEC pulses
Quando o BASIC Stamp recebe um valor numérico a partir do DEBUG Terminal, ele
armazena-o em uma variável de pulsos. O formatador DEC diz ao comando DEBUGIN
que os caracteres que estão sendo enviados são algarismos que formam um número
Página - 100
decimal. Assim que você pressionar a tecla Enter, o BASIC Stamp armazenará os
dígitos recebidos, na variável de pulsos, como um número decimal, e, em seguida,
avançará.
Embora não esteja incluído no programa de exemplo, você pode adicionar uma linha
para verificar se a mensagem foi processada pelo BASIC Stamp.
DEBUG CR, "Você enviou o valor: ", DEC pulses
Exemplo de Programa: ServoControlWithDebug.bs2
Figura 4-25 mostra as janelas de transmissão do DEBUG Terminal juntamente com a
sua janela de recebimento. Janelas de recebimento é o que nós temos usado ao longo de
todo o processo para exibir mensagens que o DEBUG Terminal “recebe” do BASIC
Stamp. A janela de transmissão permite que você digite em caracteres e números e
“envie-os” ao BASIC Stamp.
Figura 4-25
Janela do DEBUG Terminal
← Janela de Transmissão
← Janela de Recebimento
Na figura 4-25, o número 264 é digitado na janela de transmissão do DEBUG Terminal.
Abaixo, na janela de recebimento, uma cópia do valor 264 é mostrada ao lado da
mensagem "Enter run time...". Essa cópia é chamada de eco, e isso só é exibido na
janela se o eco (Echo Off) no campo de seleção estiver desmarcado.
Eco é quando você envia uma mensagem através da janela de transmissão do
DEBUG Terminal, e uma cópia dessa mensagem aparece na janela de
recebimento do DEBUG Terminal. Há uma caixa de seleção Echo Off no canto
inferior direito do DEBUG Terminal e você pode clicar nela para alternar a
seleção. Para esta atividade, queremos mostrar os ecos na janela de recebimento,
portanto, deixe a caixa de seleção Echo Off desmarcada.
 Coloque o ServoControlWithDebug.bs2 no BASIC Stamp Editor e execute-o.
 Se a janela de transmissão é muito pequena, redimensione-a usando o mouse
para clicar, segurar e arrastar o separador para baixo. O separador é mostrado,
acima da mensagem de texto “Introduza o tempo de execução como um”
(“Enter run time as a”), na Figura 4-25.
 Verifique se a caixa de seleção Echo Off no canto inferior direito está
desmarcada.
 Clique na área superior da janela de transmissão para colocar o cursor lá e digite
as mensagens.
Página - 101
 Quando o DEBUG Terminal pedir “Introduza o tempo de execução de uma série
de pulsos:” digite o número 132, e pressione no teclado de seu computador a
tecla Enter.
 Quando o DEBUG Terminal pedir “Coloque a posição como duração de
PULSOUT:” digite o número 1000 e, em seguida, aperte Enter.
O PULSOUT Duration deve ser um número entre 350 e 1150. Se você digitar
números fora desta faixa, o programa irá mudar para o número mais próximo
dentro desse intervalo, ou 350 ou 1150. Se o programa não tem esse recurso de
segurança, alguns números poderão ser inscritos que fariam o servo tentar girar
para uma posição além de seus próprios limites mecânicos. Embora não quebre o
servo, poderá encurtar a vida útil do dispositivo.
O BASIC Stamp vai exibir a mensagem “Servo em execução...” enquanto estiver
enviando pulsos para o servo. Quando terminar o envio de pulsos para o servo, ele
exibirá por um segundo a mensagem “Pronto”. Em seguida, pedirá que você introduza
novamente o número de pulsos. Divirta-se com ele, mas certifique-se de seguir as
instruções da caixa de avisos sobre permanecer entre 350 e 1150 para o seu valor
PULSOUT.
 Experimente entrar com outros valores entre 350 e 1150 para o PULSOUT
Duration e 1 e 65534 para o número de pulsos.

Fazer o servo manter uma posição durante 1 segundo demora cerca de 44
pulsos. Então, para fazer o servo manter uma posição por cerca de 5 minutos,
você poderá introduzir 13200 “número exato de pulsos”. Isso é 44
pulsos/segundo × 60 segundos/minutos × 5 minutos = 13200 pulsos.
Por que usar valores de 1 a 64434? Se você realmente estiver interessado, leia
toda a seção sobre o comando FOR...NEXT no manual do BASIC Stamp para
aprender sobre o erro 16-bit rollover ou amplitude da variável. Ela pode causar
um bug quando você estiver fazendo seus próprios programas!
' O que é um Microcontrolador - ServoControlWithDebug.bs2
' Envia mensagens para o BASIC Stamp para controlar o servo usando
' o Debug Terminal.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
pulses
duration
VAR
VAR
VAR
Word
Word
Word
PAUSE 1000
DEBUG CLS, "Tempo de execução do servo:", CR,
" ~44 pulsos em 1 segundo", CR,
"Posição do servo:", CR,
" 350 <= PULSOUT Duration <= 1150", CR, CR
DO
DEBUG "Informe o tempo de execução ", CR,
"como número de pulsos: "
Página - 102
DEBUGIN DEC pulses
DEBUG "Informe a posição como", CR,
"PULSOUT Duration: "
DEBUGIN DEC duration
duration = duration MIN 350 MAX 1150
DEBUG "Serva em execução...", CR
FOR counter = 1 TO pulses
PULSOUT 14, duration
PAUSE 20
NEXT
DEBUG "Pronto", CR, CR
PAUSE 1000
LOOP
Como Funciona o ServoControlWithDebug.bs2
Três variáveis de WORD são declaradas neste programa:
counter
pulses
duration
Var
Var
Var
WORD
WORD
WORD
A variável counter é declarada para uso por um loop FOR...NEXT. (Veja o Capítulo 2,
Atividade #3 para mais detalhes.) Os pulsos e variáveis de duração são usados de duas
maneiras diferentes. Ambos são usados para receber e armazenar os valores enviados a
partir do DEBUG Terminal. A variável pulses também é usada para definir o número de
repetições no loop FOR...NEXT, que envia pulsos para o servo, e a variável Duration é
usada para definir a duração de cada pulso do comando PULSOUT.
Um comando DEBUG fornece um lembrete de que há cerca de 44 pulsos em um segundo
no loop FOR...NEXT, e que o argumento PULSOUT Duration que controla a posição do
servo pode ser um valor entre 350 e 1150.
DEBUG CLS, "Tempo de execução do servo:", CR,
" ~44 pulsos em 1 segundo ", CR,
O resto do programa é inserido dentro de um DO...LOOP sem um argumento WHILE
ou UNTIL Condition, para que os comandos executem uma e outra vez.
DO
' Resto do programa não exibido.
LOOP
O comando DEBUG é usado para enviar uma mensagem para você (o "usuário" do
software) digitar o número de pulsos. Em seguida, o comando DEBUGIN espera por você
para inserir dígitos que compõem o número e pressionar a tecla Enter no teclado. Os
dígitos inseridos são convertidos para um valor que é armazenado na variável de pulsos.
Página - 103
Este processo é repetido com um segundo comando DEBUG e DEBUGIN que carregam
um outro valor digitado na variável de duração também.
DEBUG "Informe o tempo de execução ", CR,
"como número de pulsos: ”
DEBUGIN DEC pulses
DEBUG "Informe a posição como", CR,
Depois de inserir o segundo valor, é útil exibir uma mensagem enquanto o servo estiver
funcionando para que você não tente entrar com um segundo valor durante esse tempo:
DEBUG "Servo em execução...", CR
Enquanto o servo está em execução, você pode tentar mover delicadamente o horn do
servo longe da posição que está segurando. O servo resistirá a uma leve pressão
aplicada no horn.
FOR Counter = StartValue TO EndValue {STEP StepValue} ...
NEXT
Esta é a sintaxe do loop FOR ... NEXT do manual do BASIC Stamp. Isso
mostra que você precisa de um Counter, StartValue e EndValue para controlar
quantas vezes o loop se repete. Há também um StepValue opcional, se você
quiser adicionar um número diferente de 1 ao valor do Counter cada vez através
do loop.
Como nos exemplos anteriores, a variável Counter foi usada para manter o controle das
repetições do loop FOR...NEXT. A variável Counter à parte, neste loop FOR...NEXT,
introduz algumas novas técnicas para o uso de variáveis para definir como o programa
(e o servo) se comportam. Até este exemplo, os loops FOR...NEXT usaram constantes
como 10 ou 132 nos loops do argumento EndValue. Neste loop FOR...NEXT, o valor
da variável de pulsos é utilizado para controlar o loop FOR...NEXT EndValue. Assim,
você define o valor de pulsos, inserindo um número no DEBUG Terminal e controla o
número de repetições que o loop FOR...NEXT faz, que por sua vez controla o tempo
que o servo mantém uma determinada posição.
FOR counter = 1 to pulses
PAUSE 20
NEXT
Além disso, nos exemplos anteriores, os valores constantes, tais como 500, 750 e 1000
foram utilizados para o argumento Duration do comando PULSOUT. Neste loop, a
variável denominada Duration que você definiu ao inserir os valores na janela de
transmissão do DEBUG Terminal, definirão agora a duração do pulso do comando
PULSOUT, que por sua vez controlará a posição que o servo irá manter.
Página - 104
Tire algum tempo para
ServoControlWithDebug.bs2.
entender
o
loop
FOR...NEXT
no
É um dos primeiros exemplos das coisas incríveis que você pode fazer com as
variáveis em argumentos e loops do comando PBASIC, e também destaca a
utilidade que um módulo de microcontrolador programável, como o BASIC
Stamp, pode ter.
Sua Vez – Estabelecendo Limites no Software
Vamos imaginar que este sistema de controle de servo pelo computador é aquele que
tem sido desenvolvido para controle remoto. Talvez um guarda de segurança use isso
para abrir uma porta que ele vê por uma câmera remota. Talvez um estudante
universitário use para controlar as portas de um labirinto que os ratos percorrem em
busca de comida. Talvez um militar use para apontar um canhão para um determinado
alvo. Se você está projetando um produto para outra pessoa usar, a última coisa que
você quer é dar ao usuário (guarda de segurança, estudante universitário, militar) a
capacidade de inserir um número errado que poderia danificar o equipamento.
Durante a execução do ServoControlWithDebug.bs2, é possível cometer um erro ao
digitar o valor Duration no DEBUG Terminal. Vamos dizer que você acidentalmente
digitou 100 em vez de 1000 ao pressionar Enter. O valor de 100 fará com que o servo
tente voltar para uma posição além de seus limites mecânicos. Embora ele não vá
quebrar instantaneamente o servo, com certeza não será bom para o servo ou para a sua
vida útil. Assim, o programa tem uma linha que impede que esse erro cause qualquer
dano:
Este comando corrige o acidente alterando a variável Duration de 100 para 350. Da
mesma forma, se você acidentalmente digitou 10000, reduziria a duração variável de
1150. Você poderia fazer algo equivalente com um par de declarações IF ... THEN:
IF duration < 350 THEN duration = 350
IF duration > 1150 THEN duration = 1150
Existem algumas máquinas onde até mesmo o valor corrigido automaticamente para o
mais próximo pode ter resultados indesejáveis. Por exemplo, se você tem um
computador que controla uma máquina que corta algum tipo de material caro, você não
deseja que a máquina simplesmente assuma que você quis dizer 350 quando tentou
digitar 1000, mas acidentalmente digitou 100. Se o material era para ser cortado apenas
na configuração 350, poderia vir a ser um erro caro. Outra abordagem que o programa
pode ter é a de simplesmente dizer-lhe que seu valor estava fora de alcance, e que você
deve tentar novamente. Aqui está um exemplo de como você pode modificar o código
para fazer isso:
 Salve o programa de exemplo ServoControlWithDebug.bs2 sob o novo nome
ServoControlWithDebugYourTurn.bs2.
 Substitua estes dois comandos:
DEBUG "Informe a posição como ", CR,
Página - 105
… Com este bloco de código:
DO
DEBUG "Informe a posição
"PULSOUT Duration:
IF duration < 350 THEN
DEBUG "O valor precisa
PAUSE 1000
ENDIF
IF duração > 1150 THEN
DEBUG "O valor precisa
PAUSE 1000
ENDIF
LOOP UNTIL duration >= 350
como um", CR,
"
ser maior do que 350", CR
ser maior do que 1150", CR
AND duration <= 1150
 Salve o programa.
 Execute o programa e verifique se ele repete até que você digite o valor, na faixa
correta, de 350 a 1150.
ATIVIDADE #5: CONVERTENDO POSIÇÃO DE MOVIMENTO
Nesta atividade, você vai programar o servo para alterar a posição em taxas diferentes.
Mudando a posição em taxas diferentes, você fará com que o horn de seu servo gire em
velocidades diferentes. Você pode usar esta técnica para controlar o movimento do
servo ao invés de sua posição.
Programando uma Taxa de Variação para Posição
Você pode usar um loop FOR...NEXT para fazer o servo ter uma área de alcance de
movimento da seguinte maneira:
PULSOUT 14, counter
PAUSE 20
NEXT
O loop FOR...NEXT faz com que o horn do servo comece em torno de 45° e em
seguida, gire lentamente para a esquerda até chegar a 135°. Como counter é o
indicador do loop FOR...NEXT, ele soma um a cada vez que é executado. O valor do
counter também é usado no argumento Duration do comando PULSOUT, o que
significa que a duração de cada pulso fica um pouco maior a cada vez que realiza um
loop. Uma vez que há mudanças na variável counter, o mesmo acontece com a
posição do horn do servo.
Loops FOR...NEXT têm um argumento STEP StepValue opcional. O argumento
StepValue pode ser usado para o servo fazer uma rotação mais rápida. Por exemplo,
você pode usar o argumento StepValue para adicionar 8 ao counter cada vez que
realizar um loop (em vez de um), modificando a instrução FOR assim:
Página - 106
FOR counter = 500 TO 1000 STEP 8
Você também pode fazer o servo girar na direção oposta, fazendo uma contagem
regressiva em vez de progressiva. Em PBASIC, o próximo loop FOR...NEXT vai fazer
uma contagem regressiva se o argumento StartValue for maior do que o argumento
EndValue. Aqui está um exemplo de como fazer uma contagem do loop FOR ...
NEXT de 1000 até 500:
Você pode combinar a contagem regressiva com um argumento StepValue para fazer
com que o servo gire mais rápido no sentido horário assim:
O truque para que o servo gire em velocidades diferentes é usar o loop FOR...NEXT
para contagens progressivas e regressivas com diferentes tamanhos de passos. O
exemplo de programa seguinte usa estas técnicas para fazer o horn do servo girar para
trás e para frente em velocidades diferentes.
Exemplo de Programa: ServoVelocities.bs2
 Coloque e execute ServoVelocities.bs2.
 Conforme o programa é executado, observe como o valor de counter varia no
DEBUG Terminal.
 Além disso, observe como o servo se comporta de forma diferente através dos
dois loops FOR...NEXT. Tanto a direção do horn do servo como a velocidade
mudam.
' O que é um Microcontrolador - ServoVelocities.bs2
' Rotaciona o servo no sentido anti-horário devagar, e então, no
' sentido horário rápido.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
PAUSE 1000
DO
DEBUG "Incremento da largura de pulso em 8", CR
PULSOUT 14, counter
PAUSE 7
DEBUG DEC5 counter, CR, CRSRUP
NEXT
DEBUG CR, "Decremento da largura de pulso em 20", CR
PULSOUT 14, counter
PAUSE 7
NEXT
Página - 107
DEBUG CR, "Repete", CR
LOOP
Como Funciona o ServoVelocities.bs2
O primeiro loop FOR...NEXT conta progressivamente de 500 a 1000 em passos de 8.
Como a variável counter é usada como o argumento Duration do comando PULSOUT, a
posição do horn do servo gira no sentido anti-horário em passos que são oito vezes o
menor possível.
PULSOUT 14, counter
PAUSE 7
NEXT
Por que PAUSE 7 em vez de PAUSE 20? O comando DEBUG DEC5
counter, CR, CRSRUP leva cerca de 8 ms para ser executado. Isto significa
que PAUSE 12 manteria um atraso de 20 ms entre os pulsos. Alguns
experimento de tentativa e erro mostraram que PAUSE 7 dá ao servo os
movimentos mais suaves. Uma vez que o tempo de baixa de 20 ms não precisa
ser preciso, não há problema em ajustá-lo.
Mais formatos DEBUG e controle de caracteres estão disponíveis no comando
DEBUG que exibe o valor da variável counter. Este valor é impresso no
formato decimal com 5 dígitos (DEC5). Depois que o valor é exibido, existe um
retorno (CR). Depois disso, o caractere de controle CRSRUP (cursor para cima)
envia o cursor de volta para cima na linha anterior. Isso faz com que o novo valor
do counter seja sobreposto ao antigo a cada vez em que um loop é realizado.
O segundo loop FOR...NEXT realiza uma contagem regressiva a partir de 1000 até 500
em passos de 20. A variável counter também é usada como um argumento para o
comando PULSOUT neste exemplo, fazendo o horn do servo girar no sentido horário.
PULSOUT 14, counter
PAUSE 7
NEXT
Sua Vez – Ajuste de Velocidade
 Tente diferentes valores de STEP para fazer o servo girar com diferentes
velocidades.
 Execute novamente o programa após cada modificação.
 Observe o efeito a cada novo valor de StepValue no que diz respeito a quão
rápido o horn do servo gira.
 Experimente diferentes valores Duration no comando PAUSE (entre 3 e 12) para
encontrar o valor que dá ao servo movimentos mais suaves para cada novo valor
StepValue.
Página - 108
ATIVIDADE #6: SERVO CONTROLADO POR BOTÃO
Neste capítulo, você escreveu programas que fazem o servo realizar um conjunto de
movimentos pré-definidos e controlou o servo usando o DEBUG Terminal. Você
também pode programar o BASIC Stamp para controlar o servo baseando-se nos dados
de entrada de botões. Nesta atividade, você vai:
•
•
Construir um circuito para controlar o servo através de botões.
Programar o BASIC Stamp para controlar o servo com base nas informações de
entradas dos botões.
Quando já tiver terminado, você será capaz de pressionar e segurar um botão para fazer
o BASIC Stamp girar o servo em uma direção, e pressionar e segurar outro botão para
que o servo gire em outra direção. Quando nenhum botão for pressionado, o servo irá
manter sua posição.
Peças Extras para o Controle por Botão do Servo
Serão usadas as mesmas peças das atividades anteriores deste capítulo. Além dessas,
você terá que reunir as seguintes peças para os circuitos de botões:
(2) Botões – normalmente abertos
(3) Fios
Adicionando o Controle de Controle por Botão
A Figura 4-26 mostra os circuitos de botão que você usará para controlar o servo.
 Adicione este circuito ao circuito do servo + LED que você vem usando até
agora. Quando você terminar, o seu circuito deve se parecer:
o Com a Figura 4-27 se você estiver usando o Board of Education USB
(qualquer Rev) ou Serial (Rev C ou mais recente).
o Figura 4-28 se você estiver usando BASIC Stamp HomeWork Board
(Rev C ou mais recente).
 Se a sua placa não estiver listada acima, vá para www.parallax.com/go/WAM e
consulte Servo Circuit Connections (Conexões do Circuito de Servo) para
encontrar instruções para a sua placa de circuito.
Vdd
P4
220 Ω
P3
220 Ω
10 kΩ
Vss
10 kΩ
Vss
Vdd
Figura 4-26
Circuitos de
Botão para
Controle do
Servo
Página - 109
Figura 4-27
Circuito do
servo do Board
of Education
Servo com
circuito de
botão
adicionado
15 14 Vdd 13 12
White
Red
Black
Red
Black
X4
Vdd
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
X5
Vin
Vss
+
standard servo
www.parallax.com
Para a série
Board of
Education Rev
C ou superior,
ou USB de
qualquer
revisão
Figura 4-28
Circuito do
servo do
HomeWork
Board Servo
com circuito de
botão
adicionado
Para o
HomeWork
Board Rev C
ou superior
 Teste
o botão ligado ao P3 usando a versão original do
ReadPushbuttonState.bs2. A seção que tem este programa e as instruções de
como usá-lo começa na página 57.
 Modifique o programa para que ele leia P4.
 Execute o programa modificado para testar o botão ligado a P4.
Programando o Controle por Botão do Servo
Os blocos de código IF...THEN podem ser usados para verificar se a situação do
botão adiciona ou subtrai uma variável denominada Duration. Esta variável é usada no
argumento Duration do comando PULSOUT. Se um dos botões é pressionado, o valor de
duration aumenta. Se o outro botão é pressionado, o valor de duration diminui. Uma
declaração IF...THEN é usada para decidir se a variável duration é muito grande
(maior que 1000) ou muito pequena (menor que 500).
Página - 110
Exemplo de Programa: ServoControlWithPushbuttons.bs2
Este exemplo de programa faz o horn do servo girar no sentido anti-horário quando o
botão ligado em P4 for pressionado. O horn do servo vai manter a rotação enquanto o
botão estiver pressionado e o valor de tempo será menor do que 1000. Quando o botão
de pressão ligado a P3 for pressionado, o horn do servo vai girar no sentido horário. O
servo também é limitado em seu movimento no sentido horário, porque a variável de
tempo não é permitida ficar abaixo de 500. O DEBUG Terminal exibe o valor de
duration, enquanto o programa está sendo executado.
 Coloque e execute o programa ServoControlWithPushbuttons.bs2 no BASIC
Stamp Editor.
 Verifique se o servo gira no sentido anti-horário quando você pressiona e segura
o botão ligado a P4.
 Verifique se, assim que atingido, o limite de duration > 1000, o servo para de
girar no sentido anti-horário.
 Verifique se o servo gira no sentido horário quando você pressiona e segura o
botão ligado a P3.
 Verifique se, assim que atingido, o limite de duration < 500, o servo para de
girar no sentido horário.
'
'
'
'
O que é um Microcontrolador - ServoControlWithPushbuttons.bs2
Pressione e segure o botão P4 parar girar o servo no sentido antihorário, ou pressione o botão P3 para girar o servo no sentido
horário.
' {$STAMP BS2}
' {$PBASIC 2.5}
duration
VAR
duration = 750
PAUSE 1000
DO
Word
IF IN3 = 1 THEN
IF duration > 500 THEN
duration = duration - 25
ENDIF
ENDIF
IF IN4 = 1 THEN
IF duration < 1000 THEN
duration = duration + 25
ENDIF
ENDIF
PAUSE 10
DEBUG HOME, DEC4 duration, " = duration"
LOOP
Sua Vez – Limites Mecânicos vs Limites de Software
Travas mecânicas do servo evitam que o servo vire além de cerca de 0° e 180°, que
correspondem a argumentos PULSOUT Duration próximos de 250 e 1250. O
ServoControlWithPushbuttons.bs2 também tem limites de software, impostos pelas
Página - 111
declarações IF...THEN que impedem você de usar um botão para girar o servo além
de um certo ponto. Em contraste com os limites mecânicos, os limites de software são
muito fáceis de ajustar. Por exemplo, você pode dar ao botão de controle do servo uma
maior amplitude de movimento, simplesmente substituindo todas as instâncias de 500
por 350, e todos as de 1000 por 1150. Ou você pode atribuir a seu servo uma faixa mais
estreita de movimento, substituindo as instâncias de 500 por 650, e as de 1000 por 850.
Os limites de software não precisam ser simétricos. Por exemplo, você pode alterar os
limites de software a partir do intervalo 500-1000 para o intervalo 350-750.
 Experimente diferentes limites do servo com o software, incluindo 350-1150,
650-850 e 350-750.
 Teste cada conjunto de limites de software para ter certeza de que eles
funcionam como esperado.
Você também pode alterar a rapidez do servo pressionando o botão. Por exemplo, se
você alterar no programa os dois valores 25 para 50, o servo irá responder duas vezes
mais rápido. Alternativamente, você pode alterá-los para 30, para fazer o servo
responder um pouco mais rápido, ou para 20, para fazê-los responder um pouco mais
devagar, ou para 10, para fazê-lo responder ainda mais devagar.
 Tente!
SUMÁRIO
Este capítulo apresentou um movimento microcontrolado utilizando um Servo Padrão
Parallax. Um servo é um dispositivo que se move e mantém uma posição específica
com base nos sinais eletrônicos que recebe. Estes sinais tomam a forma de pulsos que
duram entre 0,5 e 2,5 ms, e eles têm que ser entregues aproximadamente a cada 20 ms
para o servo manter a sua posição.
Um programador pode usar o comando PULSOUT para fazer o BASIC Stamp enviar
estes sinais. Desde que os pulsos sejam enviados a cada 20 ms, para o servo para manter
sua posição, os comandos PULSOUT e PAUSE serão, geralmente, colocados em uma
espécie de loop. Variáveis ou constantes podem ser usadas para determinar tanto o
número de repetições do loop quanto do argumento Duration do comando PULSOUT.
Neste capítulo, foram apresentadas várias maneiras de obter valores para as variáveis. A
variável pode receber o valor de seu DEBUG Terminal usando o comando DEBUGIN. O
valor da variável pode passar por uma seqüência de valores, se ele for usado com o
contra-argumento de um loop FOR...NEXT. Esta técnica pode ser usada para fazer com
que o servo faça movimentos de varredura. As declarações IF...THEN podem ser
usadas para monitorar os botões e adicionar ou subtrair a variável usada no argumento
Duration do comando PULSOUT quando um determinado botão for pressionado. Isto
permite o controle da posição e de movimentos radicais dependendo de como o
programa for construído e como os botões são operados.
Questões
1. Quais são as cinco partes externas de um servo? E para que elas são usadas?
2. É necessário um circuito de LED para que o servo trabalhe?
Página - 112
3. Que comando controla o sinal de tempo de baixa enviado para um servo? Que
comando controla tempo de alta?
4. Que elemento de programação pode ser utilizado para controlar a quantidade de
tempo que um servo mantém uma determinada posição?
5. Como você usa o DEBUG Terminal para enviar mensagens para o BASIC
Stamp? Que comando do programa você usa para fazer o BASIC Stamp receber
mensagens a partir do DEBUG Terminal?
6. Que tipo de bloco de código que você pode escrever para limitar a amplitude de
movimento do servo?
Exercícios
1. Faça um bloco de código que varra o valor de PULSOUT controlando um servo a
partir de Duration de 700 a 800, e em seguida, volte a 700, em incrementos de
(a) 1 e de (b) 4.
2. Adicione um loop FOR...NEXT à sua resposta para o exercício 1b para que ele
ofereça dez pulsos antes de incrementar o argumento Duration PULSOUT por 4.
Projeto
1. Modifique ServoControlWithDebug.bs2 para que ele monitore uma chave geral.
Se a chave geral (botão P3) for pressionada, o DEBUG Terminal não deve
aceitar qualquer comando, e deve exibir “Pressione chave de Start para iniciar”.
Quando a chave Start (botão P4) for pressionada, o programa deve funcionar
normalmente. Se a energia for desconectada e reconectada, o programa deve se
comportar como se a chave geral tivesse sido pressionada.
Soluções
Q1.1)Plug – conecta o servo a energia e fontes de sinal, 2) Cabo - conduz energia e
sinais do plug para o servo; 3) Horn - parte móvel do servo; 4) Parafuso – liga o
horn do servo ao eixo de saída, 5) Caixa - contém motor CC, engrenagens, e
circuitos de controle.
Q2.Não, o LED apenas nos ajuda a ver o que está acontecendo com os sinais de
controle.
Q3.O tempo de baixa é controlado com o comando PAUSE. O de alta é controlado
com o comando PULSOUT.
Q4.Um loop FOR...NEXT.
Q5.Escreva mensagens na janela de transmissão do DEBUG Terminal. Use o
comando DEBUGIN e uma variável para fazer o BASIC Stamp receber os
caracteres.
Q6.Q.6 Ou uma declaração IF...THEN ou um comando que usa os operadores
MAX e MIN para manter a variável dentro de certos intervalos.
E1.
a) Incrementos de 1
FOR counter = 700 TO
800
PULSOUT 14, counter
PAUSE 20
NEXT
FOR counter = 800 TO
b) Adicione STEP 4 para ambos
loops FOR...NEXT.
STEP 4
PULSOUT 14, counter
PAUSE 20
Página - 113
700
PULSOUT 14, counter
PAUSE 20
NEXT
NEXT
STEP 4
PULSOUT 14, counter
PAUSE 20
NEXT
E2. Suponha que uma variável denominada pulso tenha sido declarada:
FOR pulses = 1 TO 10
PULSOUT 14, counter
PAUSE 20
NEXT
NEXT
FOR pulses = 1 TO 10
PULSOUT 14, counter
PAUSE 20
NEXT
NEXT
1. Há muitas soluções possíveis, duas são dadas aqui.
'
'
'
'
O que é um Microcontrolaor - Ch04Prj01Soln1__KillSwitch.bs2
Envia mensagens ao BASIC Stamp para controlar o servo usando o
Debug Terminal desde que a chave geral não esteja sendo
pressionada.
' Contribuição de: Professor Clark J. Radcliffe, Departamento
' de Engenharia Mecânica, Michigan State University
' {$STAMP BS2}
' {$PBASIC 2.5}
counter VAR Word
pulses
VAR Word
duration VAR Word
DO
PAUSE 2000
IF (IN3 = 1) AND (IN4 = 0) THEN
DEBUG "Pressiona chave de Start para iniciar.
,CRSRUP
ELSEIF (IN3 = 0) AND (IN4 = 1) THEN
DEBUG CLS, "Informe número de pulsos:", CR
DEBUGIN DEC pulses
DEBUG "Informe PULSOUT duration:", CR
DEBUG "Servo em movimento...", CR
PAUSE 20
", CR
Página - 114
NEXT
DEBUG "Pronto!"
PAUSE 2000
ENDIF
LOOP
Abaixo está uma versão que pode até mesmo detectar o botão pressionado enquanto está
enviando um sinal para o servo. Isso é importante para as máquinas que precisam parar
imediatamente quando a chave geral é pressionada. Ele utiliza a técnica de espera que
foi introduzida no jogo reação de tempo no Capítulo 3, Atividade #5, em três lugares
diferentes no programa. Você pode verificar que o programa para de enviar um sinal de
controle para o servo, monitorando o sinal de luz do LED indicador ligado ao P14.
'
'
'
'
O que é um Microcontrolador - Ch04Prj01Soln2__KillSwitch.bs2
Envia mensagens ao BASIC Stamp para controlar o servo usando o
Debug Terminal desde que a chave geral não esteja sendo
pressionada.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
pulses
duration
VAR
VAR
VAR
Word
Word
Word
PAUSE 1000
DEBUG "Pressione chave de Start (P4) para iniciar.", CR
DO:LOOP UNTIL IN4 = 1
DEBUG "Pressione chave geral (P3) para parar.", CR
DEBUG CR, CR, "Tempo de execução do servo:", CR,
" ~44 pulsos em 1 segundo", CR,
DO
IF IN3 = 1 THEN
DEBUG "Pressione chave geral (P3) para parar.", CR
ENDIF
DEBUG "Informe tempo de execução como ", CR,
"número de pulsos: "
DEBUGIN DEC pulses
DEBUG "Informe posição como ", CR,
DEBUG "Servo em movimento...", CR
Página - 115
PAUSE 20
IF IN3 = 1 THEN
DEBUG " Pressione chave geral (P3) para parar.", CR
ENDIF
NEXT
DEBUG "Pronto!", CR, CR
PAUSE 1000
LOOP
Página - 116
Capítulo 5: Medindo a Rotação
AJUSTANDO OS MOSTRADORES E MÁQUINAS DE MONITORAMENTO
Muitas casas têm seletores para controlar a iluminação de uma sala. Gire o seletor em
um sentido e a iluminação ficará mais clara; gire o seletor em outro sentido e a
iluminação ficará mais amena. Algumas miniaturas de trens usam seletores para
controlar a direção e a velocidade do motor. Muitas máquinas têm seletores ou
manivelas que são usadas para afinar a posição das lâminas de corte e orientar a área de
ação.
Seletores também podem ser encontrados em equipamentos de áudio, que são usados
para ajustar o volume da música e da voz. A Figura 5-1 mostra um exemplo simples de
um seletor com um botão que ao girar ajusta o volume do alto-falante. Girando o botão,
um circuito dentro do alto-falante faz com que o volume da música no alto-falante
também mude. Circuitos similares também podem ser encontrados dentro de joysticks, e
até mesmo dentro do servo utilizado no Capítulo 4: Controle de Movimento.
Figura 5-1
Ajuste de volume em
um alto-falante
O RESISTOR VARIÁVEL SOB O SELETOR - UM POTENCIÔMETRO
O dispositivo dentro de muitos seletores de um sistema de som, de joysticks e dos
servos é chamado de potenciômetro, muitas vezes abreviado como um "pot". A Figura
5-2 mostra uma imagem com alguns potenciômetros comuns. Note-se que todos eles
têm três pinos.
Figura 5-2
Alguns exemplos
potenciômetros
A Figura 5-3 mostra o símbolo esquemático e desenho da peça do potenciômetro que
você vai usar neste capítulo. Os terminais A e B estão ligados a um componente
resistente de 10 kΩ. O terminal W é chamado wiper terminal, e está ligado a um fio que
toca o componente resistente em algum ponto entre as suas extremidades.
Página - 117
Figura 5-3
Símbolo esquemático do
Potenciômetro e desenho da
peça.
A Figura 5-4 mostra como o wiper de um potenciômetro funciona. Quando você ajustar
o botão na parte superior do potenciômetro, o wiper terminal fica em contato com o
componente resistivo em diferentes posições. Conforme você gira o botão no sentido
horário, o wiper fica mais próximo do terminal A, e conforme você gira o botão no
sentido anti-horário, o wiper fica mais próximo do terminal B.
Figura 5-4
Ajustando o wiper terminal do
potenciômetro
ATIVIDADE #1: CONSTRUINDO E TESTANDO O CIRCUITO DO
POTENCIÔMETRO
Introduzir resistores de diferentes tamanhos, em série, com um LED faz com que
diferentes quantidades de corrente fluam através do circuito. Uma resistência maior no
circuito de LED faz com que uma menor quantidade de corrente flua através do circuito
e o LED brilhe com menos força. Pequenas resistências no circuito LED provocam mais
corrente fluindo através do circuito e o LED fica mais brilhante. Ao ligar os terminais
do potenciômetro a W e A, em série, com um circuito de LED, você pode usá-lo para
ajustar a resistência no circuito. Este, por sua vez, ajusta o brilho do LED. Nesta
atividade, você vai usar o potenciômetro como um resistor variável para mudar o brilho
do LED.
Peças do Circuito do Regulador
(1) Potenciômetro – 10 kΩ
(1) LED – vermelho
(1) Fio
Construindo o Teste do Circuito do Potenciômetro
A Figura 5-5 mostra um circuito que pode ser utilizado para ajustar a luminosidade do
LED com um potenciômetro.
Página - 118
Dica: Se você tiver problemas para manter o potenciômetro nos soquetes do
protoboard, verifique suas pernas. Se cada uma tem uma pequena curva, usar um
alicate de bico para endireitá-las e, em seguida, tente ligar o potenciômetro no
protoboard novamente. Quando as pernas do potenciômetro estão retas, elas
conseguem manter um contato melhor com os soquetes do protoboard.
Figura 5-5
Circuito de Teste do
LED com
potenciômetro
Testando o Circuito do Potenciômetro
 Gire o potenciômetro no sentido horário até que ele atinja o seu limite mecânico
mostrado na Figura 5-6 (a).

Pressione um pouco o potenciômetro contra o protoboard quando você for
girar o seu botão. Para essas atividades, o potenciômetro deve estar firmemente
assentado nas bases do protoboard. Se você não tiver cuidado quando girar o
botão, o potenciômetro pode se desligar dos soquetes do protoboard, o que pode
acarretar medições incorretas. Então, aplique um pouco de pressão para baixo
quando você girar o botão do potenciômetro para mantê-lo no protoboard.
Cuidado ao manusear: Se o potenciômetro não girar até aqui, não tente forçálo. Basta girá-lo até que ele atinja o seu limite mecânico, caso contrário, ele pode
quebrar.
 Gire o potenciômetro no sentido anti-horário gradualmente para as posições
mostradas na Figura 5-6 (b), (c), (d), (e) e (f), observando o brilho do LED em
cada posição.
(a)
(b)
(c)
(d)
(e)
(f)
Figura 5-6
Botão do
potenciômetro
(a) até (f) mostra o
wiper terminal do
potenciômetro
ajustado para
diferentes posições.
Como Funciona o Circuito do Potenciômetro
A resistência total no seu circuito de teste é de 220 Ω mais a resistência entre os
terminais A e W do potenciômetro. A resistência entre os terminais A e W aumenta à
Página - 119
medida que o botão é ajustado no sentido anti-horário, o que por sua vez, reduz a
corrente através do LED, tornando a luz mais fraca.
ATIVIDADE #2: MEDINDO A RESISTÊNCIA AO MEDIR O TEMPO
Esta atividade introduz uma nova peça chamada capacitor. Um capacitor opera como
uma bateria recarregável que mantém a sua carga por curtos períodos de tempo. Esta
atividade também introduz RC-time, que é uma abreviatura de tempo de resistorcapacitor. RC-time é a medida de tempo que o capacitor gasta para perder uma certa
quantidade de sua carga armazenada ao enviar corrente ao resistor. Você vai ficar mais
familiarizado com o RC-time ao medir o tempo que o capacitor leva para descarregar
com diferentes tamanhos de resistores e capacitores. Nesta atividade, você vai
programar o BASIC Stamp para carregar um capacitor e, em seguida, medir o tempo
que leva para descarregar através de um resistor.
Apresentando o Capacitor
A Figura 5-7 mostra o símbolo esquemático e o desenho da peça para o tipo de
capacitor utilizado nesta atividade. O valor de capacitância é expresso em microfarads
(µF), e a medição é comumente impressa nos capacitores.
A caixa cilíndrica deste capacitor especial é chamada de canister. Este tipo de capacitor,
chamado capacitor eletrolítico, deve ser manuseado com cuidado.
 Leia o quadro ATENÇÃO.
ATENÇÃO: Este capacitor tem um terminal positivo (+) e um negativo (-). O
terminal negativo é o condutor que sai do recipiente de metal mais próximo da
faixa com um sinal negativo (-). Certifique-se sempre de conectar esses terminais
como mostrado nos diagramas de circuitos. Se conectar um desses capacitores
incorretamente, você pode danificá-los. Em alguns circuitos, se ligar este tipo de
capacitor de forma incorreta e, em seguida, conectar a energia, poderá acontecer
uma ruptura ou até mesmo uma explosão.
ATENÇÃO: Não aplicar mais tensão para um capacitor eletrolítico além da
permitida para manuseio. A voltagem está impressa no lado da caixa.
ATENÇÃO: É recomendado o uso de óculos de proteção ou de equipamento de
segurança.
3300 µF
Figura 5-7
Símbolo
esquemático
do
capacitor de 3300 µF e desenho
da peça
3300 µF
+
-
Preste muita atenção aos
condutores e como eles se
conectam aos terminais positivo
e negativo.
Página - 120
Peças do Circuito de Resistência e Tempo
(1) Capacitor – 3300 µF
(1) Capacitor – 1000 µF
(1) Resistor – 1 kΩ (marrom-preto-vermelho)
(1) Resistor – 2 kΩ (vermelho-preto-vermelho)
Construindo e Testando o Circuito de Tempo de Resistor-Capacitor (RC)
A Figura 5-8 mostra o esquema do circuito e a Figura 5-9 mostra o diagrama de fiação
para esta atividade. Você medirá o tempo, utilizando diferentes valores de resistência no
lugar do resistor denominado Ri.
 Leia cuidadosamente o quadro de SEGURANÇA.
Segurança
Sempre observe a polaridade quando ligar o capacitor 3300 ou 1000 µF.
Lembre-se, o terminal negativo é o condutor que sai do recipiente de metal mais
próximo da faixa com um sinal negativo (-). Use a Figura 5-7 para identificar os
terminais (+) e (-).
Seu capacitor 3300 µF vai funcionar bem neste experimento, desde que você
tenha certeza que os terminais positivo (+) e negativo (-) estão ligados
exatamente como mostrado nas Figura 5-8 e 5-9.
Nunca inverta a polaridade da fonte 3300 µF ou qualquer outra polaridade
do capacitor. A tensão nos terminais do capacitor (+) tem de ser sempre maior
do que a tensão no seu terminal (-). Vss é a tensão mais baixa (0 V) no Board of
Education e no BASIC Stamp HomeWork Board. Ao ligar o terminal negativo
do capacitor para Vss, você garante que a polaridade entre os terminais do
capacitor seja sempre correta.
Nunca aplique voltagem no capacitor que exceda a voltagem indicada nele.
Use equipamento de segurança ou óculos de proteção durante esta atividade.
Sempre desconecte a alimentação antes de construir ou modificar circuitos.
Mantenha as mãos longe deste capacitor quando a alimentação estiver
ligada.
Com a alimentação desligada, construa o circuito, como mostrado, começando com um
resistor 470 Ω no lugar da resistência denominada Ri.
P7
220 Ω
Ri
3300 µF
Vss
R1 = 470 Ω
R2 = 1 kΩ
R3 = 2 kΩ
R4 = 10 kΩ
Figura 5-8
Esquema para testar a
queda de tensão em
RC-time
As quatro resistências
diferentes serão
usadas, uma de cada
vez, no esquema com
Ri.
Página - 121
Quatro resistências diferentes serão utilizadas no lugar de Ri como mostrado no
esquema. Primeiro, o esquema será construído e testado com Ri = 470 Ω, e, mais tarde
com Ri = 1 kΩ etc.
R2
R3
R4
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
-
3
0
30
µF
+
Vdd
X3
Figura 5-9
Diagrama de fiação
para visualização da
queda de tensão em
RC-time
R1
Certifique-se de que o
condutor negativo do
capacitor é ligado na
placa da mesma forma
que é mostrado na
figura, com o polo
negativo ligado ao
Vss.
+
 Certifique-se de que o condutor negativo do capacitor é ligado na placa da
mesma forma que é mostrado na figura, com o polo negativo ligado ao Vss.
 Captação do Circuito RC-Time com o BASIC Stamp
Embora um cronômetro possa ser usado para gravar o tempo que a carga do capacitor
cai um certo nível, o BASIC Stamp também pode ser programado para monitorar o
circuito e dar uma medida de tempo mais consistente.
Exemplo de Programa: PolledRcTimer.bs2
 Coloque e execute PolledRcTimer.bs2.
 Observe como o BASIC Stamp carrega o capacitor e depois mede o tempo de






descarga.
Anote o tempo medido (tempo de descarga do capacitor) na linha 470Ω da
Tabela 5-1.
Desligue a energia do seu Board of Education ou do BASIC Stamp HomeWork
Board.
Retire o resistor 470Ω marcado como Ri nas Figuras 5-8 e 5-9 na página 3, e
substitua-o por um resistor de 1 kΩ.
Reconecte a energia de sua placa.
Grave a sua próxima medição de tempo (para o resistor de 1 kΩ).
Repita essas etapas para cada valor de resistor da Tabela 5-1.
Tabela 5 1: Resistência e RC-time para C=
3300 µF
Resistência (Ω)
470
1k
2k
10 k
Medida de tempo (s)
Página - 122
' O que é um Microcontrolador - PolledRcTimer.bs2
' Programa de tempo de reação modificado para acompanhar o tempo de
' queda de tensão.
' {$STAMP BS2}
' {$PBASIC 2.5}
timeCounter
counter
PAUSE 1000
VAR
VAR
Word
Nib
DEBUG CLS
HIGH 7
DEBUG "Capacitor carregando...", CR
PAUSE 1000
NEXT
DEBUG CR, CR, "Medindo o tempo de queda agora!", CR, CR
INPUT 7
DO
PAUSE 100
DEBUG ? IN7
DEBUG DEC5 timeCounter, CR, CRSRUP, CRSRUP
LOOP UNTIL IN7 = 0
DEBUG CR, CR, CR, "O tempo de queda RC foi ",
DEC timeCounter, CR,
"décimos de segundo.", CR, CR
END
Como Funciona PolledRcTimer.bs2
Duas variáveis são declaradas. A variável timeCounter é usada para controlar quanto
tempo o capacitor leva para descarregar através de Ri. A variável counter é usada para
realizar uma contagem regressiva enquanto o capacitor está carregando.
timeCounter
counter
VAR
VAR
Word
Nib
O comando DEBUG CLS limpa o DEBUG Terminal para que ele não fique confuso
com medições sucessivas. HIGH 7 determina P7 alto e começa a carregar o capacitor,
em seguida, é exibida a mensagem “Capacitor carregando...”. Depois disso, enquanto o
capacitor está carregando um loop FOR...NEXT faz a contagem regressiva. Da mesma
forma que as cargas do capacitor a voltagem através de seus terminais aumenta para
qualquer lugar entre 3,4 e 4,9 V (dependendo do valor com Ri).
DEBUG CLS
HIGH 7
DEBUG "Capacitor carregando...", CR
Página - 123
PAUSE 1000
NEXT
A mensagem informa quando a queda começa a ser captada.
DEBUG CR, CR, " Medindo o tempo de queda agora!", CR, CR
A fim de deixar o capacitor descarregar através do resistor Ri, o pino de I/O é alterado
de HIGH para INPUT. Como entrada, o pino de I/O, não tem efeito no circuito, mas pode
detectar sinais de alta ou baixa. Logo que o pino de I/O liberta o circuito, o capacitor
descarrega e alimenta a corrente através do resistor. Assim que o capacitor descarregar,
a voltagem entre seus terminais fica cada vez menor (decai).
INPUT 7
No capítulo que fala sobre botões, você usou o BASIC Stamp para detectar um sinal
alto ou baixo usando as variáveis IN3 e IN4. Lá, um sinal de alta Vdd foi considerado e
um sinal de baixa Vss foi considerado. Na verdade, para o BASIC Stamp, um sinal de
alta é qualquer voltagem acima de cerca de 1,4 V. É claro que poderia ser de até 5 V. Da
mesma forma, um sinal de baixa é qualquer coisa entre 1,4 V e 0 V. Este DO...LOOP
verifica P7 cada 100 ms até o valor de IN7 mudar de 1 para 0, o que indica que a
voltagem do capacitor decaiu para 1,4 V.
DO
PAUSE 100
DEBUG ? IN7
DEBUG DEC5 timeCounter, CR, CRSRUP, CRSRUP
LOOP UNTIL IN7 = 0
O resultado é então exibido e o programa termina.
DEBUG CR, CR, CR, "O tempo de queda RC foi ",
END
DEC timeCounter, CR,
"décimos de segundo.", CR, CR
Sua Vez – Circuito Mais Rápido
Ao usar um capacitor, que tem cerca de 1/3 da capacidade para armazenar carga, a
medição de tempo, para cada valor do resistor, utilizada no circuito será reduzida em
1/3. Posteriormente, na próxima atividade, você vai usar um capacitor que tem 1/33 000
de capacidade! O BASIC Stamp ainda vai medir o tempo para você, usando o comando
chamado RCTIME.
 Desconecte a energia do seu Board of Education ou do HomeWork Board.
Página - 124
 Substitua o capacitor de 3300 µF pelo capacitor de 1000 µF.
 Verifique se a polaridade do seu capacitor está correta. O terminal negativo deve
ser conectado a Vss.
 Repita as etapas do Programa de Exemplo na seção: PolledRcTimer.bs2, e grave
as suas medições de tempo na Tabela 5-2.
 Compare suas medições de tempo com as que você obteve anteriormente na
Tabela 5-1. Quão próximas elas estão do valor das medições de 1/3 realizadas
com o capacitor 3300 µF?
Tabela 5-2: Resistência e RC-time para C =
1000 µF
Resistência (Ω)
Medida de tempo (s)
470
1k
2k
10 k
ATIVIDADE #3: LENDO UM SELETOR COM O BASIC STAMP
Na Atividade #1, um potenciômetro foi utilizado como um resistor variável. O resistor
no circuito variou, dependendo da posição do botão de regulagem do potenciômetro. Na
Atividade # 2, um circuito RC-time foi usado para medir as diferentes resistências.
Nesta atividade, você vai construir um circuito RC-time para ler o potenciômetro, e usar
o BASIC Stamp para fazer as medições de tempo. O resistor utilizado vai ser muito
pequeno e as medições de tempo vão estar em intervalos de microssegundos. Mesmo
que as medidas sejam de períodos muito curtos de tempo, o BASIC Stamp vai lhe dar
uma excelente indicação da resistência entre os terminais A e W do potenciômetro que
por sua vez indicará a posição do botão.
Peças para Leitura do RC-Time com o BASIC Stamp
(2) Fios
(1) Capacitor – 0.1 µF
Estes capacitores não têm terminais + e -. Eles são não-polarizados. Assim,
você pode conectar, com segurança, esses capacitores em um circuito sem se
preocupar com os terminais positivos e negativos.
Página - 125
104
0.1 µF
0.01 µF
103
Figura 5-10
Capacitores de
cerâmica
Capacitor 0.1 µF (à
esquerda)
Capacitor 0.01 µF (à
direita)
Construindo um Circuito de Tempo RC para o BASIC Stamp
Figura 5-11 mostra um esquema e diagrama de fiação para o circuito rápido com RCtime. Este é o circuito que você vai usar para monitorar a posição do botão do
potenciômetro com a ajuda do BASIC Stamp e do programa PBASIC.
Figura 5-11
Esquema e diagrama
de fiação para o
circuito RCTIME do
BASIC Stamp com
potenciômetro
Programando as Medidas com RC-Time
O programa de exemplo na Atividade #2 mediu o tempo de queda RC, verificando se
IN7 = 0 a cada 100 ms, mantendo o controle de quantas vezes ele teve que fazer a
verificação. Quando IN7 mudou de 1 para 0, indicou que a voltagem do capacitor
decaiu para 1,4 V. O resultado, quando foi feita uma pesquisa do programa, foi que a
variável timeCounter armazenou um número em décimos de segundo levando a
voltagem do capacitor a decair para 1,4 V.
O seguinte programa de exemplo usa um comando PBASIC chamado RCTIME que faz
com que o BASIC Stamp meça o tempo de queda RC em termos de unidades de 2 μs.
Então, ao invés de usar segundos, o resultado RCTIME 7, 1, time armazena na
variável time na unidade de dois milionésimos de segundo para que a voltagem do
capacitor decaia abaixo de 1,4 V. Uma vez que o comando RCTIME tem essas unidades
de medida finas, você pode reduzir o tamanho do capacitor de 3300 μF para 0,1 ou
Página - 126
também 0,01 μF, e ainda obter medições de tempo que indicam o valor do resistor. Uma
vez que a resistência entre o terminal A do potenciômetro muda quando você gira o
botão, a medição RCTIME lhe dará a medida de tempo correspondente a posição do
botão do potenciômetro.
Exemplo de Programa: ReadPotWithRcTime.bs2
 Coloque e execute ReadPotWithRcTime.bs2
 Tente girar o botão do potenciômetro durante a monitorização do valor da
variável de tempo, utilizando o DEBUG Terminal.
Lembre-se de aplicar um pouco de pressão para baixo para manter o
potenciômetro preso ao protoboard quando você girar o seu botão. Se o seu servo
começar a se mexer, de forma inesperada, em vez de manter a sua posição, um
potenciômetro mal colocado pode ser o culpado.
' O que é um Microcontrolador - ReadPotWithRcTime.bs2
' Leia o potenciômetro no circuito de tempo RC usando o comando
' RCTIME.
' {$STAMP BS2}
' {$PBASIC 2.5}
time VAR Word
PAUSE 1000
DO
HIGH 7
PAUSE 100
RCTIME 7, 1, time
DEBUG HOME, "time = ", DEC5 time
LOOP
Sua Vez – Alterando o Tempo Pela Mudança do Capacitor
 Substitua o capacitor de 0,1 µF pelo capacitor 0,01 µF.
 Experimente as mesmas posições, que você fez na atividade principal, no
potenciômetro e compare o valor exibido no DEBUG Terminal com os valores
obtidos para o capacitor de 0,1 µF. São as medidas RCTIME cerca de um décimo
do valor para uma determinada posição do potenciômetro?
 Volte para o capacitor 0,1 µF.
 Com o capacitor 0,1 µF de volta no circuito e o capacitor 0,01 µF removido, gire
o botão do potenciômetro ao seu limite em ambos os sentidos e faça anotações
dos maiores e menores valores para a próxima atividade. Maior:_________
Menor:_________
Como Funciona o ReadPotWithRcTime.bs2
A Figura 5-12 mostra como os comandos HIGH, PAUSE e RCTIME no
ReadPotWithRcTime.bs2 interagem com o circuito na Figura 5-11.
Página - 127
Figura 5-12: Voltagem para P7 entre HIGH, PAUSE, e RCTIME
À esquerda, o comando HIGH 7 faz com que o BASIC Stamp conecte internamente o
seu pino de I/O P7 a 5 V de alimentação (Vdd). A corrente de alimentação flui através
do resistor do potenciômetro e também carrega o capacitor. Quanto mais próximo o
capacitor estiver de alcançar a sua carga final (quase 5 V), menos corrente passa através
dele. O comando PAUSE 100 faz, principalmente, uma atualização do display do
DEBUG Terminal cerca de 10 vezes por segundo; PAUSE 1 é geralmente suficiente
para carregar o capacitor. À direita, o comando RCTIME 7, 1, time muda a direção
do pino de I/O de saída para entrada e começa a contar o tempo em incrementos de 2 μs.
Como entrada, o pino de I/O, não fornece o circuito com 5 V. Na verdade, a entrada, é
praticamente invisível para o circuito RC. Assim, o capacitor começa a perder sua carga
através do potenciômetro. Como o capacitor perde sua carga, sua voltagem decai. O
comando RCTIME mantém a contagem de tempo até P7 sentir um sinal baixo, ou seja, a
voltagem através do capacitor decai para 1,4 V, no ponto em que ele armazena a sua
medição na variável time.
A Figura 5-12 também mostra um gráfico de voltagem através do capacitor durante os
comandos HIGH, PAUSE e RCTIME. Em resposta ao comando HIGH 7, que liga o
circuito de 5 V, o resistor carrega rapidamente. Então, ele permanece em seu nível de
voltagem final durante a maior parte do comando PAUSE 100. Quando o programa
chega ao comando RCTIME 7, 1, a direção do pino de I/O muda, assim o capacitor
começa a descarregar através do potenciômetro. Quando o capacitor descarrega, a
voltagem de P7 decai. Quando a voltagem decai para 1,4 V (marca de 150 μs neste
exemplo), o comando RCTIME para a contagem de tempo e armazena o resultado da
medição da variável time. Uma vez que o comando RCTIME conta o tempo em duas
unidades μs, o resultado de 150μs que fica armazenado na variável time é 75.
Página - 128
I/O Pin Logic Threshold: 1,4 V é o limite da lógica de um pino de I/O do
BASIC Stamp 2. Quando o pino de I/O está configurado para entrada, armazena
um 1 na sua entrada de registro se a voltagem aplicada for superior a 1,4 V ou um
0 se a voltagem de entrada for de 1,4 V ou inferior. No primeiro exemplo de
botão no Capítulo 3, Atividade #2 foi aplicado 5 V ou 0 V para P3. Desde 5 V
seja acima de 1,4 V, IN3 armazena um 1, e desde 0 V seja inferior a 1,4 V, IN3
armazena um 0.
Argumento State do RCTIME: Em ReadPotWithRcTime.bs2, a voltagem
através do capacitor decai quase 5 V, e quando alcança 1,4 V, o valor em IN7
registra alterações 1 a 0. Nesse ponto, o comando RCTIME armazena a sua
medição em Duration, que é a variável de tempo no programa de exemplo. O
comando RCTIME argumento State é de 1 em RCTIME 7, 1, time, que
informa ao comando RCTIME que o IN7 irá armazenar a 1 quando a medição
começar. O comando RCTIME mede quanto tempo o registro IN7 leva para
mudar para o lado oposto, o que acontece quando a voltagem decai abaixo de
1,4V do limite da lógica do pino de I/O.
Para mais informações: Procure o comando RCTIME tanto no manual do
BASIC Stamp como no BASIC Stamp Editor’s Help.
A Figura 5-13 mostra como o tempo de decaimento muda com a resistência do
potenciômetro para o circuito na Figura 5-11. Cada posição do botão do potenciômetro
o ajusta em uma determinada resistência. Se girar em uma direção a resistência aumenta
e em outra a resistência diminui. Quando a resistência for maior, o decaimento demora
mais tempo, e o comando RCTIME armazena um valor maior da variável time. Quando a
resistência é menor, o decaimento leva um tempo mais curto, e o comando RCTIME
armazena um valor menor na variável time. O comando DEBUG em
ReadPotWithRcTime.bs2 exibe esta medição de tempo no DEBUG Terminal, desde que
as mudanças de tempo de decaimento com a resistência do potenciômetro, que por sua
vez variam com a posição do botão do potenciômetro, o número exibido no DEBUG
Terminal indica a posição do botão.
Figura 5-13
Como a resistência do
potenciômetro afeta o tempo
de decaimento
Página - 129
Por que a carga do capacitor tem uma voltagem mais baixa, quando o
potenciômetro tem menos resistência?
Dê uma olhada no esquema, no canto superior esquerdo da Figura 5-12 na página
3. Sem o resistor de 220 Ω, o pino de I/O seria capaz de carregar o capacitor a 5
V, mas o resistor de 220 Ω é necessário para evitar possíveis danos do pino de
I/O a partir de uma corrente de ligação quando o capacitor começar a ser
carregado. Ele também impede que o potenciômetro extraia muito mais corrente
se estiver a 0 Ω, enquanto o pino de I/O envia seu sinal de alta de 5 V.
Com 5 V aplicado através da resistência 220 Ω em cadeia com o potenciômetro,
a voltagem entre eles tem que ter alguma fração de 5 V. Quando duas resistências
do condutor de corrente são colocadas em cadeia, que resulta em uma voltagem
intermediária, o circuito é chamado divisor de voltagem (voltage divider). Assim,
resistor de 220 Ω e o potenciômetro formam um circuito divisor de tensão, e para
obter qualquer resistência do potenciômetro (Rpot), você pode usar esta
equação para calcular a voltagem sobre o potenciômetro (Vpot):
Vpot V = 5 × Rpot ÷ (Rpot + 220 Ω)
O valor da Vpot estabelece o limite de tensão do capacitor. Em outras palavras,
qualquer voltagem através do potenciômetro poderia ser se o capacitor não
estivesse ligado, é a voltagem que o capacitor pode carregar, e não superiores.
Para a maioria das faixas do botão do potenciômetro, os valores de resistência
estão em kΩ, e quando você calcular Vpot para valores, Rpot em kΩ os
resultados estarão muito mais próximos de 5 V. O resistor de 220 Ω não impede
Vpot carregar acima de 1,4 V até que o valor do potenciómetro esteja abaixo de
85,6 Ω, que é inferior a 1% da amplitude de movimento do potenciômetro. Este
1% resultaria em menores medições de qualquer maneira, por isso é difícil dizer
que as medições nesta escala são nada fora do comum. Mesmo com o adicional
de 220 Ω os resistores construídos no BASIC Stamp HomeWork Board com
conexões de pinos I/O, apenas a faixa do potenciômetro menor que 1,7% é
afetada, por isso ainda é praticamente imperceptível.
Assim, o resistor de 220 Ω protege o pino de I/O, com um impacto mínimo sobre
a capacidade de medição de decaimento RC e mostra onde posicionou o botão do
potenciômetro.
ATIVIDADE #4: CONTROLANDO O SERVO COM UM POTENCIÔMETRO
Os Joysticks de polegar, como o mostrado na Figura 5-14, são comumente encontrados
em controladores de vídeo games. Cada joystick normalmente tem dois potenciômetros
que permitem que os componentes eletrônicos no interior do controlador do jogo
relatem a posição do joystick para o console de videogame. Um potenciômetro gira com
o movimento horizontal do joystick (esquerda/direita), e o outro gira com movimento
vertical do joystick (frente/trás).
Página - 130
Potenciômetro
Horizontal
Figura 5-14
Potenciômetros dentro
do módulo Joystick de
polegar da Parallax
Potenciômetr
o Vertical
Outra aplicação do joystick de polegar que usa potenciômetros é o controlador de rádio
RC e o modelo de avião na Figura 4-1 na página 79. O controlador possui dois joysticks,
e cada um tem dois potenciômetros. Cada posição do potenciômetro é responsável por
controlar um servo diferente sobre o plano de RC.
Nesta atividade, você vai usar um potenciômetro semelhante aos encontrados em
joysticks de polegar para controlar a posição de um servo. Gire o botão do
potenciômetro, o horn de servo irá espelhar este movimento. Esta atividade utiliza dois
circuitos, o circuito do potenciômetro da Atividade #3, neste capítulo, e o circuito do
servo do Capítulo 4, Atividade #1. O programa PBASIC apresentado neste capítulo
mede repetidamente a posição do potenciômetro com um comando RCTIME e, em
seguida, utiliza a medição e um pouco de matemática para controlar a posição do servo
com um comando PULSOUT.
O BASIC Stamp pode medir a posição do joystick. Uma vez que existem dois
potenciômetros em cada joystick de polegar, cada um deles pode, por si só,
substituir o suporte do potenciômetro nos circuitos na figura 5-11, na página 125.
Um comando RCTIME pode medir a posição do potenciômetro vertical, e outra
pode medir o potenciômetro horizontal.
Peças do Servo Controlado por Potenciômetro
(1) Capacitor – 0,1 µF
(1) Servo padrão da Parallax
(2) Fios
O HomeWork Board também vai precisar de:
(1) Conector de 3 pinos macho-macho
(4) Fios
Página - 131
Construindo o Circuito do Servo Controlado por Potenciômetro
Esta atividade vai usar dois circuitos que você já construiu individualmente: circuito do
potenciômetro da atividade recentemente concluída e o circuito do servo do capítulo
anterior.
 Deixe o seu circuito RC-time do potenciômetro da Atividade # 3 na área de
prototipagem. Se você precisar reconstruí-lo, use a Figura 5-11 na página 125.
Certifique-se de usar o capacitor 0,1 µF, e não o capacitor 0,01 µF.
 Adicione seu circuito do servo do Capítulo 4, Atividade #1 ao projeto. Lembrese que o circuito do servo será diferente, dependendo da sua placa de suporte.
Abaixo estão as páginas das seções que você precisa ir:
o Página 80: Board of Education Servo Circuit
o Página 82: BASIC Stamp HomeWork Board Servo Circuit
Programando o Servo Controlado por Potenciômetro
Você precisará do menor e o maior valor da variável de tempo que você gravou de seu
circuito RC-time enquanto estava usando um capacitor de a 0,1 µF.
 Se você ainda não completou a seção “Sua Vez” da atividade anterior, retorne e
a conclua agora.
No próximo exemplo, estão os valores de tempo medidos por um técnico da Parallax;
seus valores, provavelmente, serão um pouco diferentes:
•
•
Máximo no sentido horário: 1
Máximo no sentido anti-horário: 691
Como ajustar estes valores de entrada para mapear o intervalo de 500-1000 ao controlar
o servo com o comando PULSOUT? A resposta é usando multiplicação e adição.
Primeiro, multiplique os valores de entrada por algo que faça a diferença entre os
valores de 500 em vez de 700 no sentido horário (mínimo) e anti-horário (máximo). Em
seguida, adicione um valor constante ao resultado de modo que a sua média seja entre
500 e 1000, em vez de 1 a 500. Na eletrônica, essas operações são chamadas scaling e
offset.
Veja como funciona o cálculo de multiplicação (scaling):
500
= 691 × 0.724 = 500
691
500
time(minimum) = 1 ×
= 0.724
691
time(maximum) = 691×
Depois que os valores são escalados, aqui estão os passos da adição (offset).
time(maximum) = 500 + 500 = 1000
time(minimum) = 0.724 + 500 = 500
Página - 132
O sinal operador */ que foi introduzido na página 69 é construído em PBASIC para o
dimensionamento de valores fracionários, como 0,724. Aqui estão os passos para a
utilização */ aplicado a 0,724:
1. Coloque o valor ou variável que você deseja multiplicar por um valor fracionário
antes do operador */.
time = time */
2. Pegue o valor fracionário que você deseja usar e multiplique por 256.
new fractional value = 0.724 × 256 = 185.344
3. Livre-se de qualquer coisa à direita do ponto decimal.
new fractional value = 185
4. Coloque esse valor após o operador */ .
time = time */ 185
Isso cuidará da escala, agora tudo o que precisamos fazer é adicionar o deslocamento de
500. Isto pode ser feito com um segundo comando, que adiciona 500 ao time:
time = time */ 185
time = time + 500
Agora, o time está pronto para ser reciclado no argumento Duration do comando
PULSOUT.
time = time */ 185
time = time + 500
PULSOUT 14, time
' Scale by 0.724.
' Offset by 500.
’ Envie um pulso para o servo.
Exemplo de Programa: ControlServoWithPot.bs2
 Coloque e execute o programa, depois gire o botão do potenciômetro, e
certifique-se que os movimentos do servo são reflexo dos movimentos do
potenciômetro.
' O que é um Microcontrolador - ControlServoWithPot.bs2
' Lê o potenciômetro no circuito de tempo RC usando o comando RCTIME.
' Multiplica o tempo por 0,724 e adiciona 500 para o servo.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DEBUG "Programa funcionando!"
time
VAR
Word
Página - 133
DO
HIGH 7
PAUSE 10
RCTIME 7, 1, time
time = time */ 185
time = time + 500
PULSOUT 14, time
' Multiplica por 0,724 (X 256 para */).
' Adiciona 500.
' Envia pulso ao servo.
LOOP
Sua Vez – Multiplicando a Relação do Servo com o Seletor
Seu potenciômetro e capacitor, provavelmente, darão valores de tempo que são um
pouco diferentes dos discutidos nesta atividade. Estes são os valores que você coletou
na seção “Sua Vez” na atividade anterior.
 Repita o cálculo discutido na seção “Programando o Servo Controlado por
Potenciômetro” na página 131, usando seu valores máximos e mínimos.
 Substitua sua escala e valores de deslocamento em ControlServoWithPot.bs2.
 Comente DEBUG "Programa funcionando!" com um apóstrofo no início da linha.
 Adicione esta linha de código entre os comandos PULSOUT e LOOP para que
você possa ver os seus resultados:
DEBUG HOME, DEC5 time
‘ Mostra o valor de tempo ajustado
 Execute o programa modificado e verifique o seu andamento. Como os valores
foram arredondados, os limites podem não ser exatamente 500 e 1000, mas eles
devem ser muito próximos.
Declarando Constantes e Diretivas Pin
Em programas maiores, você pode terminar usando o valor ScaleFactor (que foi de 185)
e o deslocamento (que era de 500) muitas vezes no programa. Números como 185 e 500
em seu programa são chamados constantes, porque ao contrário das variáveis, seus
valores não podem ser alterados enquanto o programa está sendo executado. Em outras
palavras, o valor continua a ser "constante". Você pode criar nomes para essas
constantes com as diretivas CON:
ScaleFactor
Offset
delay
CON
CON
CON
185
500
10
Estas diretivas CON são quase sempre declaradas próximas ao início do
programa, de modo que elas são fáceis de encontrar.
Uma vez que aos valores constantes foram dados nomes com as diretivas CON, você
pode usar o ScaleFactor no lugar de 185 e deslocamento (offset) no lugar de 500 em seu
programa. Por exemplo:
time = time */ scaleFactor
time = time + offset
500”.
“ ' Escala de 0.724.”
“ ' Deslocamento de
Página - 134
Com os valores nós nomes às constantes com diretivas CON, os comandos são:
time = time */ 185
time = time + 500
“ ' Escala de 0.724”.
“ ' Deslocamento de 500.”
Uma vantagem importante para o uso de constantes é que você pode alterar uma diretiva
CON, e atualizar cada instância desse nome constante no seu programa. Por exemplo, se
você escrever um programa grande que usa o ScaleFactor constante em 11 locais
diferentes, uma mudança do ScaleFactor CON ..., em todas as instâncias de
ScaleFactor em seu programa, usará esse valor atualizado para baixar o próximo
programa. Então, se você mudou o ScaleFactor CON 500 para ScaleFactor CON
510, todos os comandos com ScaleFactor vão usar 510 em vez de 500.
Você também pode dar aos pinos de I/O nomes usando as diretivas PIN. Por exemplo,
você pode declarar uma diretiva PIN para o pino de I/O P7 assim:
RcPin
PIN 7
Existem dois pontos no exemplo de programa anterior, onde o número 7 é utilizado para
se referir ao pino de I/O P7. O primeiro pode agora ser escrito como:
HIGH RcPin
O segundo pode ser escrito como:
RCTIME RcPin, 1, time
Se mais tarde você mudar o seu circuito para usar diferentes pinos de I/O, tudo que você
tem a fazer é alterar o valor na sua diretiva PIN, e ambos os comandos HIGH e RCTIME
serão atualizados automaticamente. Da mesma forma, se você tem que recalibrar o scale
factor ou offset, você também pode simplesmente mudar as diretivas CON no início do
programa.
A diretiva PIN tem um recurso adicional: O compilador PBASIC pode
detectar se o nome do pino é usado como uma entrada ou saída, e substituir o
número do pino de I/O para saída ou o correspondente registro de entrada da
variável bit para entrada. Por exemplo, você poderia declarar duas diretivas de
pinos, como LedPin PIN 14 e ButtonPin PIN 3. Em seguida seu código
pode fazer uma declaração como IF ButtonPin = 1 THEN HIGH
LedPin. O compilador PBASIC converte isso para IF IN3 = 1 THEN
HIGH 14. O IF ButtonPin = 1... fez uma comparação, e o
compilador PBASIC sabe que você está usando ButtonPin como entrada.
Por isso, utiliza o registro de entrada bit IN3, em vez do número 3. Da mesma
forma, o compilador sabe que o PBASIC HIGH LedPin usa o pino com o
nome LedPin como valor constante 14 para uma operação de saída, então ele
substitui HIGH 14.
Programa de Exemplo: ControlServoWithPotUsingDirectives.bs2
 Coloque e execute ControlServoWithPotUsingDirectives.bs2.
Página - 135
 Observe como este programa responde ao potenciômetro e verifique se ele se
comporta da mesma maneira com o ControlServoWithPot.bs2
' O que é um Microcontrolador - ControlServoWithPotUsingDirectives.bs2
' Lê o potenciômetro no circuito de tempo RC usando o comando RCTIME.
' Aplica fator de escala e offset, então envia o valor para o servo.
' {$STAMP BS2}
' {$PBASIC 2.5}
rcPin
servoPin
PIN
PIN
7
14
' Definições de pinos de I/O
scaleFactor
offset
delay
CON
CON
CON
185
500
10
' Declaração de constantes
time
VAR
Word
' Declaração de variáveis
PAUSE 1000
' Inicialização
DO
HIGH rcPin
PAUSE delay
RCTIME rcPin, 1, time
time = time */ scaleFactor
time = time + offset
PULSOUT servoPin, time
DEBUG HOME, DEC5 time
' Rotina principal
' Medição de queda RC
' Escala scaleFactor.
' Offset por offset.
' Envia pulso ao servo.
' Mostra valor do tempo ajustado.
LOOP
Sua vez – Atualizando a Diretiva PIN
Como mencionado anteriormente, se você ligar o circuito RC a um pino de I/O
diferente, você pode simplesmente mudar o valor da diretiva RcPin PIN, e esta
mudança automaticamente se reflete nos comandos time HIGH RcPin e RCTIME
RcPin, 1.
 Salve o exemplo de programa com um novo nome.
 Altere scaleFactor e compense os únicos valores que você determinou na sua
seção anterior “Sua Vez” para o circuito RC.
 Execute o programa modificado e verifique se ele funciona corretamente.
 Modifique o circuito movendo a conexão do circuito RC–time do pino de I/O P7
para o pino de I/O P8.
 Modifique a declaração rcPin para que seja lido assim:
rcPin
PIN 8
 Reexecute o programa e verifique se os comandos HIGH e RCTIME ainda estão
funcionando corretamente sobre os diferentes pinos de I/O com apenas uma
alteração da diretiva PIN RcPin.
Página - 136
SUMÁRIO
Este capítulo apresentou o potenciômetro, peça frequentemente encontrada em vários
botões e seletores. O potenciômetro tem um elemento resistivo que tipicamente conecta
seus dois terminais externos e um terminal do limpador que contata um ponto variável
sobre o elemento resistivo. O potenciômetro pode ser utilizado como uma resistência
variável, se o terminal do limpador e um dos dois terminais externos for utilizados num
circuito.
O capacitor também foi introduzido neste capítulo. Um capacitor pode ser usado para
armazenar e libertar carga. A quantidade de carga que um capacitor pode armazenar
está relacionada com o seu valor, que é medido em farads (F). O símbolo µ é a notação
de engenharia para micro, e significa um milionésimo. Os condensadores utilizados nas
atividades deste capítulo variaram de 0,01 para 3300 µF.
Uma resistência e um condensador podem ser ligados entre si num circuito que leva um
certo período de tempo para carga e descarga. Este circuito é comumente referido como
um circuito RC-time. O R e o C em RC-time significam resistência e condensador.
Quando um valor (C nas atividades deste capítulo) é constante, a variação de tempo
necessária para que o circuito descarregue está relacionada com o valor de R. Quando o
valor de R muda, o valor do tempo que leva para o circuito carregar e descarregar
também muda. O tempo total que o circuito RC-time leva para descarregar pode ser
dimensionado usando um condensador de um tamanho diferente.
O assentamento foi utilizado para monitorar o tempo de descarga de um capacitor em
um circuito RC onde o valor de C, era muito grande. Vários resistores diferentes foram
utilizados para mostrar como as alterações do tempo de descarga mudam quando o valor
do resistor no circuito muda. O comando RCTIME foi então usado para monitorar um
potenciômetro (um resistor variável) de um circuito RC-time com capacitores de valor
menor. Embora esses capacitores façam com que os tempos de descarga na faixa de
cerca de 2 a 1500 µs (milionésimos de segundo), o BASIC Stamp não tem nenhum
problema de rastreamento dessas medições de tempo com o comando RCTIME. O pino
de I/O deve ser estabelecido HIGH e então o capacitor no circuito RC-time poderá ser
carregado usando PAUSE antes do comando RCTIME.
Programação em PBASIC pode ser usada para medir um sensor resistivo tal como um
potenciômetro e dimensionar seu valor de modo que seja útil para outro dispositivo, tal
como um servo motor. Trata-se de realizar operações matemáticas sobre o tempo de
descarga RC medido, que um comando RCTIME armazena em uma variável. Esta
variável pode ser ajustada pela adição de um valor constante para isso, o que é útil para
o controle de um servo. Na seção Projetos, você pode encontrar também multiplicação e
divisão.
A diretiva CON pode ser utilizada no início de um programa para substituir um nome por
um valor constante (um número). Depois que uma constante foi nomeada, o nome pode
ser usado no lugar do número em todo o programa. Isto pode ajudar, especialmente se
você precisa usar o mesmo número em 2, 3, ou até mesmo 100 lugares diferentes no
programa. Você pode alterar o número na diretiva CON, e todas 2, 3, ou até 100
diferentes instâncias desse número serão atualizadas automaticamente na próxima vez
que você executar o programa. Diretivas PIN permitem nomear pinos de I/O. O nome
Página - 137
do pino I/O é sensível ao contexto, assim o compilador PBASIC substitui o número do
pino de I/O correspondente pelo nome do pino nos comandos como HIGH, LOW, e
RCTIME. Se o nome do pino vir a ser habitual em uma instrução condicional ele
substituirá o registro de entrada por IN2, IN3 etc.
Questões
1. Quando você gira o seletor ou o botão em um aparelho de som, qual componente
você está provavelmente ajustando?
2. Em um potenciômetro típico, a resistência entre os dois terminais externos pode
ser ajustada?
3. Quão semelhante é um capacitor de uma bateria recarregável? Como ele se
diferencia?
4. O que você pode fazer com um circuito RC-time para lhe dar uma indicação do
valor de um resistor variável?
5. O que acontece com o tempo de descarga RC, se o valor de R (o resistor) tornarse maior ou menor?
6. O que a diretiva CON faz? Explique isto em termos de um nome e de um número.
Exercícios
1. Vamos dizer que você tem um capacitor 0,5 µF no circuito RC timer, e você
quer que a medida fique dez vezes maior. Calcule o valor do novo capacitor.
Projetos
1. Adicione um circuito de LED bicolor na Atividade # 4. Modifique o programa
de exemplo para que o LED bicolor fique vermelho quando o servo estiver
girando no sentido anti-horário, verde quando o servo estiver girando no sentido
horário, e desligado quando o servo permanecer na sua posição.
2. Use IF...THEN para modificar o primeiro exemplo de programa da Atividade
#4 para que o servo só gire entre os valores PULSOUT de 650 e 850.
Soluções
Q1.O Potenciômetro.
Q2.Não, ela é fixa. A resistência variável é entre um terminal externo e o wiper
terminal (meio).
Q3.Um capacitor é semelhante a uma bateria recarregável, que pode ser carregado
para manter a tensão. A diferença é que ele só aguenta a carga por um período
muito curto de tempo.
Q4. Você pode medir o tempo que leva para o capacitor descarregar (ou carregar).
Este tempo está relacionado com a resistência e a capacitância. Se a capacitância
for conhecida e a resistência variável, o tempo de descarga dará a indicação da
resistência.
Q5.Se R ficar maior, o tempo de descarga RC aumentará na proporção direta ao
aumento de R. Se R ficar menor, o tempo de descarga RC diminuirá na
proporção direta à diminuição de R.
Q6.As diretivas CON substituem um nome por um número.
E1. Novo capacitor = (10 x valor do velho capacitor) = (10 x 0.5µF) = 5 µF
Página - 138
E1. Atividade #4 com LED bicolor adicionado.
P13
Esquema do Potenciômetro da Figura
5-11 na página 125, servo do
Capítulo 4m Atividade #1, e LED
bicolor da Figura 2-19 na página 45
com P15 e P14 mudados para P13 e
P12, como mostrado.
1
2
P12
470 Ω
'
'
'
'
'
'
'
'
O que é um Microcontrolador - Ch5Prj01_ControlServoWithPot.bs2
Lê o potenciômetro no circuito de tempo RC usando o comando
RCTIME.
Usa o resultado RCTIME na variável time para controlar a
posição do servo.
LED bicolor em P12, P13 dita a direção de rotação do servo:
verde para SH, vermelho para SAH, apagado quando o servo está
parado.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
time
prevTime
VAR
VAR
Word
Word
' Leitura de tempo do potenciômetro
' Leitura anterior
DO
prevTime = time
HIGH 7
PAUSE 10
RCTIME 7, 1, time
time = time */ 185
time = time + 500
PULSOUT 14, time
' Armazena leitura de tempo anterior
' Lê potenciômetro usando RCTIME
' Escala de 0,724 (X 256 for */).
' Offset de 500.
IF ( time > prevTime + 2) THEN ' Aumenta, potenciômetro gira SAH
HIGH 13
LOW 12
ELSEIF ( time < prevTime - 2) THEN 'Diminui potenciômetro gira SH
LOW 13
' LED bicolor verde
HIGH 12
ELSE
' Servo mantém posição
LOW 13
' LED apagado
LOW 12
ENDIF
LOOP
P2. A chave é adicionar blocos de IF ... THEN, um exemplo é mostrado abaixo.
CLREOL é um personagem de controle de depuração útil que significa "claro
para o fim da linha".
' O que é um Microcontrolador - Ch5Prj02_ControlServoWithPot.bs2
' Lê o potenciômetro no circuito de tempo RC usando o commando
' RCTIME.
Página - 139
'
'
'
'
Modificado com IF…THEN para que o servo apenas gire de 650 a
850.
A variável time vai de 1 a 691, então um offset de, no mínimo,
649 é necessário.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
time VAR Word
DO
HIGH 7
PAUSE 10
' Lê o potenciômetro com RCTIME
RCTIME 7, 1, time
time = time + 649
IF (time
time =
ENDIF
IF (time
time =
ENDIF
< 650) THEN
650
' Escala time para variação do servo
' Restringe variação para 650 a 850
> 850) THEN
850
PULSOUT 14, time
DEBUG HOME, "time = ", DEC4 time, CLREOL
LOOP
Página - 140
Capítulo 6: Display Digital
O DISPLAY DIGITAL COTIDIANO
A Figura 6-1 mostra um display na parte da frente da porta de um forno. Quando o
aparelho não está em uso, ele exibe a hora. Quando em uso exibe o temporizador do
forno, configurações para cozimento, e pisca ao mesmo tempo que um alarme soa para
que você saiba que a comida está pronta. Um microcontrolador dentro da porta do forno
monitora os botões e atualiza os mostradores. Ele também monitora os sensores dentro
dos dispositivos do forno e muda os dispositivos que ligam os componentes de
aquecimento em ligado e desligado.
Figura 6-1
Relógio digital de
display de 7
segmentos na porta
do forno.
Cada um dos três dígitos na Figura 6-1 é chamado de display de 7 segmentos. Neste
capítulo, você vai programar o BASIC Stamp para exibir números e letras em um
display de 7 segmentos.
O QUE É UM DISPLAY DE 7 SEGMENTOS?
Um display de 7 segmentos é um bloco retangular de 7 linhas de igual comprimento que
podem ser iluminadas com LEDs seletivamente, para exibir dígitos e algumas letras. A
Figura 6-2 mostra uma parte do desenho do display do LED de 7 segmentos que você
vai usar nas atividades deste capítulo. Também tem um ponto que pode ser usado como
um ponto decimal. Cada um dos segmentos (A a G) e do ponto contém um LED
separado, que pode ser controlado individualmente. A maioria dos pinos tem um
número junto com uma etiqueta que corresponde a um dos segmentos de LED. O pino 5
rotulado DP significa ponto decimal. Os pinos 3 e 8 são rotulados como "cátodo
comum" (“common cathode”), e eles serão explicados quando o esquema para esta
parte for introduzido.
Common
Cathode
10 9 8 7 6
A B
G F
A
F
B
G
C
E
D
E D
C DP
1 2 3 4 5
Common
Cathode
Figura 6-2
Desenho da peça e mapa de
pinos do display de 7 segmentos
de LED
Página - 141
Mapa de pinos: A Figura 6-2 é um exemplo de mapa de pinos. O mapa de pinos
contém informações úteis que ajudam você a conectar uma peça a outros
circuitos. Mapas de pinos, usualmente, mostram o número e o nome de cada
pino e a sua referência.
Dê uma olhada na Figura 6-2. Cada pino é numerado, e o nome de cada pino é
a letra segmento próxima ao pino. A referência para esta parte é o ponto decimal.
Oriente a área para que o ponto decimal fique no canto inferior direito. Então
você pode ver a partir do pino no mapa que o pino 1 no canto inferior esquerdo, e
os números dos pinos aumentam no sentido anti-horário em torno do caixa.
A Figura 6-3 mostra um esquema dos LEDs dentro do display de LED de 7 segmentos.
Cada ânodo do LED está ligado a um pino individual. Todos os cátodos estão ligados
entre si por fios no interior da peça. Porque todos os cátodos partilham uma ligação
comum, o display de LED de 7 segmentos pode ser chamado de um display de cátodo
comum. Ao ligar tanto o pino 3 ou 8 na peça para Vss, você vai conectar todos os
cátodos do LED para Vss.
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
LED’s
3
Figura 6-3
Esquema do display
de LED de 7
segmentos
8
ATIVIDADE #1: CONSTRUINDO E TESTANDO O DISPLAY DE LED DE 7
SEGMENTOS
Nessa atividade, você construirá manualmente circuitos para testar cada segmento do
display.
Peças para o Teste do Display de LED de 7 Segmentos
(1) Display de LED de 7 segmentos
(5) Resistores – 1 kΩ (marrom-preto-vermelho)
(1) Fio
Teste dos Circuitos do Display de LED de 7 Segmentos
 Com a energia do seu Board of Education ou HomeWork Board desconectada,
construa o circuito mostrado na Figura 6-4 e na Figura 6-5.
 Reconecte a energia e verifique se o segmento A emite luz.
O que é o x com o nc acima dele no esquema? O nc representa não conectado
ou sem conexão. Ele indica que um determinado pino no display de LED de 7
segmentos não está ligado a nada. O x na extremidade do pino, também significa
não ligado. Esquemas, às vezes, usam apenas o x ou apenas o nc.
Página - 142
Vdd
nc
X
X
X
nc
nc
nc
X
nc
X
nc
X
nc
X
1 kΩ
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
Figura 6-4
Esquema do teste de
circuito para o
segmento “A” do
display de LED
LED’s
8
X
3
nc
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Figura 6-5
do teste de circuito
para o segmento “A”
do display de LED
Vss
 Desconecte a energia e modifique o circuito conectando o resistor à entrada do
LED B conforme mostrado na Figura 6-6 e na Figura 6-7.
Vdd
X
nc
nc
nc
X
X
nc
X
nc
X
nc
X
nc
X
1 kΩ
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
LED’s
8
X
3
Vss
nc
Figura 6-6
Esquema do teste de
circuito para o
segmento “B” do
display de LED
Página - 143
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Figura 6-7
do teste de circuito
para o segmento “B”
do display de LED
Vss
 Reconecte a energia e verifique se o segmento B emite luz.
 Usando o mapa de pinos da Figura 6-2 como guia, repita esses passos para os
segmentos C a G.
Sua Vez – O Número 3 e a Letra H
A Figura 6-8 e a Figura 6-9 mostram o digito “3” conectado no display de LED de 7
segmentos.
Vdd
Vdd
Vdd
Vdd
Vdd
1 kΩ (all)
nc
nc
X
X
X
nc
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
Figura 6-8
Dígito “3”
conectado.
LED’s
8
X
3
nc
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Vss
Figura 6-9
Diagrama de
Fiação para a
Figura 6-8
 Construa e teste o circuito mostrado nas Figura 6-8 e Figura 6-9, e verifique se o
número 3 é exibido.
Página - 144
 Desenhe um esquema que mostra o número 2 no LED de 7 segmentos.
 Construa e teste o circuito, para verificar se ele funciona. Solucione o problema,
se necessário.
 Determine o circuito necessário para a letra "H" e, em seguida, construa-o e
teste.
ATIVIDADE #2: CONTROLANDO O DISPLAY DE LED DE 7 SEGMENTOS
Nesta atividade, você vai conectar o display de LED de 7 segmentos no BASIC Stamp
e, em seguida, executar um programa simples para testar e ter certeza se cada LED está
conectado corretamente.
Peças do Display de LED de 7 Segmentos
(1) Display LED de 7 segmentos
(8) Resistores - 1 kΩ (marrom-preto-vermelho)
(5) Fios
Conectando o Display de LED de 7 Segmentos no BASIC Stamp
A Figura 6-11 mostra o esquema e a Figura 6-12 mostra o diagrama de fiação para este
exemplo de controle de display de LED de 7 segmentos do BASIC Stamp.
Esquema e Mapa de Pinos: Se você está tentando construir o esquema de
circuito da Figura 6-11 sem depender da Figura 6-12, certifique-se de consultar o
mapa de pinos do display de LED de 7 segmentos, mostrado aqui novamente na
Figura 6-10 por conveniência.
Common
Cathode
10 9 8 7 6
A B
G F
A
F
B
G
C
E
D
E D
C DP
1 2 3 4 5
Common
Cathode
Figura 6-10
Desenho da peça e mapa de
pinos do display de LED de 7
segmentos.
Página - 145
1 kΩ
(All)
P15
P14
P13
P12
P11
P10
P9
P8
E
C
G
DP
F
A
LED’s
B
Figura 6-11
Esquema
display de
LED de 7
segmentos
controladado
pelo BASIC
Stamp
common
Vss
Tenha cuidado com os resistores ligados a P13 e P14. Olhe atentamente para
os resistores ligados a P13 e P14 na Figura 6-12. Há um vão entre esses dois
resistores. O vão é mostrado porque o pino 8 no display de 7 segmentos do LED
é deixada desligada. Um resistor conecta o pino de I/O P13 para o pino 9 do
display de LED de 7 segmentos. Outro resistor liga P14 ao pino 7 do display de
LED de 7 segmentos.
DP
EDC GFAB
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Figura 6-12
Diagrama de Fiação
para a Figura 6-11
Vin
Vss
Use as letras de
segmento acima
desse diagrama como
referência.
Dispositivo Paralelo: O display de LED de 7 segmentos é chamado de
dispositivo paralelo, porque o BASIC Stamp tem que usar um grupo de linhas de
I/O para enviar dados (informação de alta e baixa) para o dispositivo. No caso
deste display de LED de 7 segmentos, são necessários 8 pinos de I/O para instruir
ao dispositivo o que exibir.
Barramento Paralelo: Os fios que transmitem os sinais de baixa / alta do
BASIC Stamp para o display de LED 7 segmentos são chamados de barramento
paralelo. Note-se que estes fios são desenhados como linhas paralelas na Figura
6-11. O termo "paralelo" faz sentido, dada a geometria do esquema.
Página - 146
Programando o Teste do Display de LED de 7 Segmentos
Os comandos de HIGH e LOW vão aceitar uma variável como um argumento Pin. Para
testar cada segmento, um de cada vez, basta colocar os comandos HIGH e LOW em um
loop FOR ... NEXT, e usar o índice para definir o pino I/O de alta, depois o de baixa
novamente.
 Digite e execute SegmentTestWithHighLow.bs2.
 Verifique se todos os segmentos do LED de 7 segmentos acendem as luzes
brevemente, ligando e em seguida desligando novamente.
 Relacione qual segmento o pino de I/O controla.
Programa de Exemplo: SegmentTestWithHighLow.bs2
' O que é um Microcontrolador - SegmentTestWithHighLow.bs2
' Teste individualmente cada segment em um display de LED de 7
' segmentos.
'{$STAMP BS2}
'{$PBASIC 2.5}
pinCounter
VAR
Nib
PAUSE 1000
DEBUG "Pino de I/O", CR,
"-------", CR
FOR pinCounter = 8 TO 15
DEBUG DEC2 pinCounter, CR
HIGH pinCounter
PAUSE 1000
LOW pinCounter
NEXT
Sua Vez - um Padrão Diferente
Removendo o comando LOW pinCounter, será obtido um efeito interessante:
 Comente o comando LOW pinCounter adicionando um apóstrofo à esquerda.
 Execute o programa modificado e observe o efeito.
ATIVIDADE #3: EXIBINDO DÍGITOS
Se você incluir o ponto decimal, há oito pinos de I/O diferentes no BASIC Stamp que
enviam sinais de baixa / alta para o display de LED de 7 segmentos. São oito comandos
HIGH ou LOW diferentes para exibir apenas um número. Se você contar de zero a nove,
seria uma vasta quantidade de programação. Felizmente, existem variáveis especiais que
você pode usar para definir os valores máximos e mínimos para os grupos dos pinos de
I/O.
Nesta atividade, você vai usar números binários de 8 dígitos em vez dos comandos
HIGH e LOW para controlar os sinais de alta/baixa enviados pelos pinos de I/O para o
BASIC Stamp. Ao definir variáveis especiais chamadas DIRH e OUTH iguais aos
Página - 147
números binários, você será capaz de controlar os sinais de baixa/alta enviados por
todos os pinos de I/O conectados ao circuito de 7 segmentos do LED com um único
comando PBASIC.
8 bits: Um número binário que tem 8 dígitos diz-se que tem 8 bits. Cada bit é um
slot onde você pode armazenar ou 1 ou 0.
Um byte é uma variável, que contém 8 bits. Existem 256 combinações
diferentes de zeros e uns, que você pode usar para contar de 0 a 255, com 8 bits.
É por isso que uma variável de byte pode armazenar um número entre 0 e 255.
Peças e Circuito para Exibição de Dígitos
As mesmas da atividade anterior
Programando Padrões de On / Off Usando Números Binários
Nesta atividade, você vai experimentar as variáveis DIRH e OUTH. DIRH é uma variável
que controla a direção (entrada ou saída) dos pinos de I/O P8 a P15. OUTH controla os
sinais altos ou baixos que cada um destes pinos de I/O envia. Você verá brevemente que
OUTH é especialmente útil, pois você pode usá-lo para definir os sinais de alta/baixa
para oito pinos de I/O diferentes de uma só vez com apenas um comando. Aqui está um
exemplo de programa que mostra como essas duas variáveis podem ser usadas para
contar de 0 a 9, no display de 7 segmentos do LED, sem usar os comandos HIGH e LOW:
Programa de Exemplo: DisplayDigits.bs2
Esse programa de exemplo irá fazer com que o display de LED de 7 segmentos alterne
os dígitos de 0 à 9.
 Coloque e execute DisplayDigits.bs2.
 Verifique se os dígitos de 0 a 9 são exibidos.
' O que é um Microcontrolador - DisplayDigits.bs2
' Exibe dígitos de 0 à 9 no display de LED de 7 segmentos.
'{$STAMP BS2}
'{$PBASIC 2.5}
DEBUG "Program Running!"
OUTH = %00000000
DIRH = %11111111
'
BAFG.CDE
OUTH = %11100111
PAUSE 1000
OUTH = %10000100
PAUSE 1000
OUTH = %11010011
PAUSE 1000
OUTH = %11010110
PAUSE 1000
OUTH = %10110100
PAUSE 1000
OUTH = %01110110
PAUSE 1000
' OUTH inicializado em baixa.
' Configura P8-P15, todas saídas em baixa.
' Dígito:
' 0
' 1
' 2
' 3
' 4
' 5
Página - 148
OUTH = %01110111
PAUSE 1000
OUTH = %11000100
PAUSE 1000
OUTH = %11110111
PAUSE 1000
OUTH = %11110110
PAUSE 1000
' 6
DIRH = %00000000
' Pinos de I/O para entrada,
' Segmentos apagados.
' 7
' 8
' 9
END
Como Funciona o DisplayDigits.bs2
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
X3
Vdd
Vin
Vss
A Figura 6-13 mostra como você pode usar as variáveis DIRH e OUTH para controlar a
direção e definir os estados (de alta/baixa) dos pinos de I/O P8 a P15.
Figura 6-13
Usando DIRH e OUTH
para configurar todos
os pinos de I/O para
saída baixa.
OUTH = %00000000
DIRH = %11111111
O primeiro comando:
OUTH = %00000000
... deixa todos os pinos de I/O (P8 a P15) prontos para enviar os sinais de baixa. Se
todos eles enviarem sinais de baixa, eles desligarão todos os segmentos no display de
LED de 7 segmentos. Se você quisesse que todos os pinos de I/O enviassem um sinal de
alta, você poderia usar OUTH =% 11111111.
O que % faz? O formatador binário % é usado para dizer ao BASIC Stamp Editor
que o número é um número binário. Por exemplo, o número binário
%00001100 é o mesmo que o número decimal 12. Como você vai ver nesta
atividade, números binários podem fazer facilmente muitas tarefas de
programação.
Os sinais de baixa não serão realmente enviados pelos pinos de I/O até que você use a
variável DIRH para mudar todos os pinos de I/O de entrada para a saída. O comando:
DIRH = %11111111
Página - 149
... define os pinos de I/O P8 a P15 para a saída. Assim que este comando é executado,
de P8 a P15, todos, começarão a enviar sinais de baixa. Isso ocorre porque o comando
OUTH = %00000000 foi executado pouco antes do comando DIRH. Assim que o
comando DIRH definir todos os pinos de I/O para a saída, eles começarão a enviar seus
sinais de baixa. Você também pode usar DIRH =% 00000000 para mudar todos os
pinos de I/O de volta para entrada.
Antes dos pinos de I/O se tornarem saídas: até os pinos de I/O serem alterados
de entrada para saída, eles apenas ficam atentos aos sinais e atualizam a variável
INH. Esta é a variável que contém IN8, IN9 até IN15. Essas variáveis podem
ser usadas da mesma forma que IN3 e IN4 foram usadas para leitura dos botões
no Capítulo 3.
Todos os pinos de I/O no BASIC Stamp começam como entrada. Isso é
chamado de padrão (default). Você tem que dizer ao pino de I/O do BASIC
Stamp para iniciar como saída, antes que ele comece enviar um sinal de alta ou
baixa. Ambos os comandos HIGH e LOW mudam automaticamente a direção de
um pino de I/O do BASIC Stamp para saída. Colocar um 1 na variável DIRH
também muda um dos pinos de I/O para saída.
Sempre definir valores em um determinado registro OUT antes de fazer as
saídas com os valores no registro DIR correspondente. Isso evita o envio de
breves sinais não intencionais. Por exemplo, se DIR5 = 1 é seguido por OUT5
= 1, no início de um programa, será enviado um breve sinal de baixa, não
intencional, antes de mudar para alta porque OUT5 armazena 0, quando o
programa é iniciado. (Inicializar todas as variáveis/registros no PBASIC com 0.)
Se OUT5 = 1 for seguido por DIR5 = 1, o pino de I / O irá enviar um sinal
de alta, tão logo ele se torne uma saída.
Uma vez que os valores armazenados são 0 por todas as variáveis padrão
quando o programa é iniciado, o comando OUTH =% 00000000 é
realmente redundante.
 A Figura 6-14 mostra como usar a variável OUTH, para seletivamente, enviar
sinais de alta e baixa para P8 a P15. O binário-1 é usado para enviar um sinal de
alta, e binário-0 é usado para enviar um sinal de baixa. Esse exemplo mostra o
número três no display de LED de 7 segmentos:
'
BAFG.CDE
OUTH = %11010110
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
X3
Vdd
Vin
Vss
Página - 150
Figura 6-14
Usando OUTH para
controlar os sinais de
alta e baixa do P8 –
P15
‘
BAFG.CDE
OUTH = %11010110
O display está ligado e o número três no display está de cabeça para baixo, para mostrar,
de modo mais claro, os valores da linha OUTH até os pinos de I/O. O comando OUTH =%
11010110 usa zeros binários para definir pinos de I/O P8, P11, P13 baixo, e usa os
binários para definir P9, P10, P12, P14 e P15 alto. A linha pouco antes do comando é
um comentário que mostra os rótulos do segmento alinhados com o valor binário que
transforma esse segmento on / off.
Dentro dos comandos HIGH e LOW:
HIGH 15
...é o mesmo que:
OUT15 = 1
DIR15 = 1
Da mesma forma, o comando :
LOW 15
...é o mesmo que:
OUT15 = 0
DIR15 = 1
Se você quiser retornar P15 para entrada, use DIR15 = 0. Você pode então
usar IN15 para detectar (em vez de enviar) sinais de alta / baixa.
Sua Vez – Exibindo de A à F
 Descubra quais padrões de bits (combinações de zeros e outros) você precisará
para exibir as letras A, b, C, d, E e F.
 Modifique DisplayDigits.bs2 para que ele exiba A, b, C, d, E, F.
Decimal vs. Hexadecimal Os dígitos básicos no sistema de numeração
decimal (base 10) são:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
No sistema hexadecimal (base-16) os números básicos são:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, b, C, d, E, F.
A base-16 é amplamente utilizada em computadores e na programação de
microcontroladores. Depois de descobrir como exibir os caracteres de A à F,
você pode modificar o seu programa para que ele conte em hexadecimal de 0 a F.
Página - 151
Mantendo Listas de Padões On / Off
O comando LOOKUP escreve um código para o display de LED de 7 segmentos exibir
padrões com mais facilidade. O comando LOOKUP permite "procurar" elementos em
uma lista. Aqui está um exemplo de código que usa o comando LOOKUP:
LOOKUP index, [7, 85, 19, 167, 28], value
Há duas variáveis utilizadas neste comando, index e value. Se index é 0, valeu armazena
7. Se o index é 1, value armazena 85. No próximo programa de exemplo, index é
definido como 2, para o comando LOOKUP colocar 19 em value, e é isso que o DEBUG
Terminal exibe.
Programa de Exemplo: SimpleLookup.bs2




Coloque e execute SimpleLookup.bs2.
Execute o programa como está, com a variável index igual a 2.
Tente configurar a variável index igual para números entre 0 e 4.
Reexecute o programa depois de cada alteração na variável index e note que o
valor da lista é colocado na variável value.
 Opcional: Modifique o programa, colocando o comando LOOKUP em um loop
FOR ... NEXT que conta de 0 a 4.
' O que é um Microcontrolador - SimpleLookup.bs2
' Debug um valor usando index e uma tabela de consulta.
' {$STAMP BS2}
' {$PBASIC 2.5}
value
index
VAR
VAR
Byte
Nib
index = 2
PAUSE 1000
DEBUG ? index
LOOKUP index, [7, 85, 19, 167, 28], value
DEBUG ? value, CR
DEBUG "Mude a variável index para um ", CR,
"número diferente (entre 0 e 4).", CR, CR,
"Execute o programa modificado e ", CR,
"verifique qual número o comando ", CR,
"LOOKUP coloca na variável ", CR,
"value."
END
Programa de Exemplo: DisplayDigitsWithLookup.bs2
Este programa de exemplo mostra como o comando LOOKUP pode ser realmente útil
para armazenar os padrões de bits usados na variável OUTH. Novamente, a variável
index é utilizada para selecionar o valor binário que é colocado na variável OUTH. Este
Página - 152
Programa de Exemplo tem a contagem de 0 a 9 novamente. A diferença entre este
programa e DisplayDigits.bs2 é que este programa é muito mais versátil. É muito mais
rápido e mais fácil de ajustar para sequências de números diferentes, utilizando tabelas
de consulta.
 Coloque e execute DisplayDigitsWithLookup.bs2.
 Verifique se ele faz a mesma coisa que o programa anterior (com muito menos
trabalho).
 Dê uma olhada no DEBUG Terminal enquanto o programa esta sendo
executado. Ele mostra como o valor de index é usado pelo comando LOOKUP
para carregar o valor binário correto da lista para OUTH.
' O que é um Microcontrolador - DisplayDigitsWithLookup.bs2
' Use uma tabela de consulta para armazenar e exibir dígitos com o
' display de LED de 7 segmentos.
'{$STAMP BS2}
'{$PBASIC 2.5}
index
VAR
Nib
OUTH = %00000000
DIRH = %11111111
PAUSE 1000
DEBUG "index
"-----
OUTH
", CR,
--------", CR
FOR index = 0 TO 9
LOOKUP index, [ %11100111, %10000100, %11010011,
%11010110, %10110100, %01110110,
%01110111, %11000100, %11110111, %11110110 ], OUTH
DEBUG "
", DEC2 index, "
PAUSE 1000
NEXT
", BIN8 OUTH, CR
DIRH = %00000000
END
Sua Vez – Exibindo 0 à F novamente
 Modifique DisplayDigitsWithLookup.bs2 para que ele conte de 0 à F em
hexadecimal. Não se esqueça de atualizar o argumento EndValue do loop
FOR...NEXT.
ATIVIDADE #4: EXIBINDO A POSIÇÃO DE UM DIAL
No Capítulo 5, Atividade #4 utilizou o potenciômetro para controlar a posição de um
servo. Nesta atividade, você vai mostrar a posição do potenciômetro usando o display
de LED de 7 segmentos.
Peças do Dial e Display
(1) Display LED de 7 segmentos
(8) Resistores – 1 kΩ (marrom-preto-vermelho)
Página - 153
(1) Capacitor – 0,1 µF
(7) Fios
Construindo o Circuito do Dial e Display
A Figura 6-15 mostra um diagrama esquemático do circuito do potenciômetro que deve
ser adicionado ao projeto. A Figura 6-16 mostra o diagrama de fiação do circuito a
partir da Figura 6-15 combinado com o circuito da Figura 6-11, na página 146.
 Adicione o circuito do potenciômetro ao circuito do display de LED de 7
segmentos, conforme mostrado na Figura 6-16.
Figura 6-15
Esquema do circuito
do potenciômetro
adicionado ao projeto
Figura 6-16
para a Figura 6 -15
Programando o Dial e o Display
Há um comando bastante útil denominado LOOKDOWN, e sim, ele é o inverso do
comando LOOKUP. Enquanto o comando LOOKUP lhe dá um número com base em um
índice, o comando LOOKDOWN lhe dá um índice baseado em um número.
Programa de Exemplo: SimpleLookdown.bs2
Este programa de exemplo demonstra como o comando LOOKDOWN funciona.
 Coloque e execute SimpleLookdown.bs2.
 Execute o programa como está, com a variável value definida igual a 167, e use
o DEBUG Terminal para observar o valor de index.
 Tente configurar a variável value igual a cada um dos números listados pelo
comando LOOKDOWN: 7, 85, 19, 28.
 Reexecute o programa depois de cada alteração na variável value e note qual
valor da lista foi colocado na variável index.
Página - 154
Pegadinha: O que acontece se o seu valor for maior que 167? Esta pequena
variação no comando LOOKDOWN pode causar problemas porque o comando
LOOKDOWN não faz qualquer alteração no índice.
' O que é um Microcontrolador - SimpleLookdown.bs2
' Debug um índice usando um valor e uma tabela de consulta.
' {$STAMP BS2}
' {$PBASIC 2.5}
value
index
VAR
VAR
Byte
Nib
value = 167
PAUSE 1000
DEBUG ? value
LOOKDOWN value, [7, 85, 19, 167, 28], index
DEBUG ? index, CR
DEBUG "Mude a variável value para um ", CR,
" número diferente dessa lista:", CR,
"7, 85, 19, 167, or 28.", CR, CR,
"verifique qual o número o comando ", CR,
"LOOKDOWN colocou na variável ", CR,
"index."
END
A menos que você diga a ele para fazer um tipo diferente de comparação, o comando
LOOKDOWN verifica se o valor está igual a uma entrada na lista. Você também pode
verificar se um valor é maior que, menor que ou igual a, etc. Por exemplo, para
procurar uma entrada em que a variável value é menor que ou igual a, use o operador <=
pouco antes da primeira faixa que inicia a lista. Em outras palavras, o operador retorna o
índice do primeiro valor na lista que faz a indicação na instrução real.
 Modifique SimpleLookdown.bs2 substituindo este valor e a declaração
LOOKDOWN no lugar dos já existentes:
value = 35
LOOKDOWN value, <= [ 7, 19, 28, 85, 167 ], index
 Modifique o comando DEBUG para que se leia:
DEBUG "Mude a variável value para um ", CR,
"número diferente, nesta faixa:", CR,
"0 à 170.", CR, CR
"verifique qual o número o comando ", CR,
"LOOKDOWN colocou na variável ", CR,
Página - 155
"index."
 Experimente com valores diferentes e veja se a variável index mostra o que
você tinha em mente.
Programa de Exemplo: DialDisplay.bs2
Este programa de exemplo espelha a posição do botão do potenciômetro iluminando os
segmentos externos do display de LED de 7 segmentos, conforme mostrado na Figura
6-17.
Figura 6-17
Exibindo a posição do
potenciômetro com o display de
LED de 7 segmentos.
 Coloque e execute DialDisplay.bs2.
 Gire o botão do potenciômetro e verifique se ele funciona. Lembre-se de
pressioná-lo para baixo para mantê-lo preso à placa do protoboard.
 Quando você executar o programa de exemplo, a execução pode não ser tão
precisa como mostrada na Figura 6-17. Ajuste os valores na tabela de LOOKDOWN
para que o display digital exiba uma posição mais precisa do potenciômetro.
' O que é um Microcontrolador - DialDisplay.bs2
' Exibe a posição do potenciômetro usando um display de LED de 7
' segmentos.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
index
time
VAR
VAR
Nib
Word
OUTH = %00000000
DIRH = %11111111
DO
HIGH 5
PAUSE 100
RCTIME 5, 1, time
LOOKDOWN time, <= [40, 150, 275, 400, 550, 800], index
LOOKUP index, [ %11100101, %11100001, %01100001,
%00100001, %00000001, %00000000 ], OUTH
LOOP
Página - 156
Como Funciona o DialDisplay.bs2
Este programa de exemplo toma uma medida RCTIME do potenciômetro e a armazena
em uma variável chamada time.
HIGH 5
PAUSE 100
RCTIME 5, 1, time
A variável time é então usada numa tabela LOOKDOWN. A tabela LOOKDOWN decide
qual o número na lista time é menor, em seguida, carrega o número de entrada (de 0 a
5, neste caso) para a variável index.
LOOKDOWN time, <= [40, 150, 275, 400, 550, 800], index
Em seguida, a variável index é usada em uma tabela LOOKUP para escolher o valor
binário a ser carregado na variável OUTH.
LOOKUP index, [ %11100101, %11100001, %01100001,
%00100001, %00000001, %00000000 ], OUTH
Sua Vez – Adicionando um Segmento
DialDisplay.bs2 só liga cinco dos seis segmentos quando você gira o botão. A sequência
para acender os LEDs no DialDisplay.bs2 é E, F, A, B, C, mas não D.
 Salve DialDisplay.bs2 como DialDisplayYourTurn.bs2.
 Modifique DialDisplayYourTurn.bs2 para que ele faça todos os seis LEDs
externos ligarem na mesma sequência, conforme o potenciômetro é girado. A
sequência deve ser: E, F, A, B, C e D;
Dica: Deixe o seu circuito do seu display de LED de 7 segmentos na sua placa.
Nós usaremos o LED de 7 segmentos novamente com outros circuitos no
Capítulo 7, Atividade #4.
SUMÁRIO
Este capítulo introduziu o display de LED de 7 segmentos, e como ler um mapa de
pinos. Este capítulo introduziu também algumas técnicas para dispositivos e circuitos
que têm entradas paralelas. As variáveis DIRH e OUTH foram introduzidas como um
meio de controlar os valores dos pinos de I/O P8 a P15 no BASIC Stamp. Os comandos
LOOKUP e LOOKDOWN foram introduzidos como um meio de recorrer às listas de valores
usados para exibir letras e números.
Questões
1. Em um display de LED de 7 segmentos, qual é o ingrediente ativo que faz com
que o display fique legível quando um microcontrolador envia um sinal de alta
ou baixa?
2. O que significa cátodo comum? O que você acha que ânodo comum significa?
3. Qual é o grupo de fios que conduzem sinais de e para um dispositivo chamado
paralelo?
Página - 157
4. Quais são os nomes dos comandos neste capítulo que são usados para lidar com
listas de valores?
Exercícios
1. Escreva um comando OUTH para definir P8, P10, P12 altos e P9, P11, P13
baixos. Supondo que todos os seus pinos de I/O começaram como entrada,
escreva o comando DIRH que fará com que os pinos de I/O P8 a P13 enviem
sinais de alta / baixa, deixando P14 e P15 configurados como entradas.
2. Adicione os valores de OUTH necessários para fazer as letras: a, C, d, F, H, I, n,
P, S.
Projeto
1. Soletre "FISH CHIPS And dIP" várias vezes com o seu display de LED de 7
segmentos. Faça com que cada letra dure 400 ms.
Soluções
Q1.O ingrediente ativo é um LED.
Q2.Cátodo comum significa que todos os cátodos estão ligados entre si, ou seja, que
partilham um ponto de ligação comum. Ânodo comum significa que todos os
ânodos são ligados entre si.
Q3.Um barramento paralelo.
Q4.LOOKUP e LOOKDOWN usam listas de valores.
E1. O primeiro passo para configurar OUTH é definido como "1" em cada posição de
bit especificado como HIGH. Então bits 8, 10 e 12 são definidos “1". Em
seguida, coloque um "0" para cada baixa, então os bits 9, 11 e 13 recebem um
"0", como mostrado. Para configurar DIRH, os pinos especificados como 8, 10,
12, 9, 11 e 13 devem ser definidos como saídas, definindo os bits para "1". 15 e
14 estão configurados como entradas, colocando zeros nos bits 15 e 14. O
segundo passo é traduzir isso para uma declaração PBASIC.
Bit 15 14 13 12 11 10
OUTH 0 0 0 1 0 1
OUTH = %00010101
9
0
8
1
Bit 15 14 13 12 11 10
DIRH 0 0 1 1 1 1
9
1
8
1
DIRH = %00111111
E2. A chave para resolver este problema é desenhar cada letra e notar quais
segmentos devem estar acesos. Coloque um 1 em cada segmento que está aceso.
Traduza para o valor binário OUTH. A lista dos segmentos BAFG.CDE para bits
em OUTH estão na Figura 6-14 na página 152.
Página - 158
Letras
LED
Segmentos
B A F G.C D E
OUTH Valor =
a
e, f, a, b, c, g
11110101
%11110101
C
a, f, e, d
01100011
%01100011
d
b, c, d, e, g
10010111
%10010111
F
a, f, e, g
01110001
%01110001
H
f, e, b, c, g
10110101
%10110101
I
f, e
00100001
%00100001
n
e, g, c
00010101
%00010101
P
all but c and d
11110001
%11110001
S
a, f, g, c, d
01110110
%01110110
Da Figura 6-2 na página 140.
Common
Cathode
10 9 8 7 6
G F
A B
A
F
B
G
C
E
D
E D
C DP
1 2 3 4 5
Common
Cathode
P1. Usar o esquema da Figura 6-11 da página 146. Para resolver esse problema,
modifique DisplayDigitsWithLookup.bs2, usando os padrões de letras
trabalhadas no Exercício 2. Na solução, as letras foram criadas como constantes
para tornar o programa mais intuitivo. Usando os valores binários é muito mais
fácil, mas mais propenso a erros.
'
'
'
'
O que é um Microcontrolador - Ch6Prj01_FishAndChips.bs2
Use uma tabela de consulta para armazenar e exbir dígitos com
o display de LED de 7 segmentos. Soletre a mensagem: FISH
CHIPS And dIP
'{$STAMP BS2}
'{$PBASIC 2.5}
' Padrões do display de LED de 7 segmentos para criar letras
A
CON
%11110101
C
CON
%01100011
d
CON
%10010111
F
CON
%01110001
H
CON
%10110101
I
CON
%00100001
n
CON
%00010101
P
CON
%11110001
S
CON
%01110110
space
CON
%00000000
index
VAR
Byte
OUTH = %00000000
DIRH = %11111111
' 19 caracteres na mensagem
' Todos apagados para começar
' Todos os LEDs devem ser saídas
PAUSE 1000
' 1 s antes da 1a mensagem
DO
DEBUG "index
"-----
OUTH
", CR,
--------", CR
FOR index = 0 TO 18
' 19 caracteres na mensagem
LOOKUP index, [ F, I, S, H, space, C, H, I, P, S, space,
Página - 159
A, n, d, space, d, I, P, space ], OUTH
DEBUG "
PAUSE 400
NEXT
LOOP
", DEC2 index, "
", BIN8 OUTH, CR
' 400 ms entre letras
Página - 160
Capítulo 7: Medição de Luz
DISPOSITIVOS QUE CONTÉM SENSORES DE LUZ
Os capítulos anteriores introduziram botões como sensores de contato e pressão e
potenciômetros como sensores de rotação e posição. Ambos os sensores são comuns em
produtos eletrônicos, basta pensar em quantos dispositivos com botões e mostradores
você usa diariamente. Outro sensor comum encontrado em muitos produtos, é o sensor
de luz. Aqui estão alguns exemplos de dispositivos que necessitam de sensores de luz
para funcionar corretamente:
•
•
•
•
•
•
Faróis de carros que, automaticamente, acendem quando está escuro.
Iluminação pública que, automaticamente, acende quando está começando a
escurecer.
Iluminação de segurança ao ar livre, que liga quando alguém passa por ela (mas
só à noite).
O visor do notebook fica mais brilhante em áreas bem iluminadas e mais escuro
em áreas mal iluminadas.
Câmeras com ajustes de exposição automática.
Sensores dentro de TVs, aparelhos de DVD e outros componentes de sistemas
de entretenimento que detectam a luz infravermelha de um controle remoto.
Os três primeiros exemplos da lista falam em acendimento automático, e eles dependem
de sensores de luz ambiente para distinguir o dia da noite. Os dispositivos eletrônicos
dentro desses equipamentos só precisam saber se está claro ou escuro, para que possam
tratar seus sensores de luz como saídas binárias, como botões. Notebooks e câmeras de
ajuste de exposição automática ajustam para área iluminada condições de obter
informação dos sensores de luz sobre quão claro ou escuro está. Eles têm que tratar os
seus sensores de luz como saídas analógicas que fornecem um número que indica o
quão clara ou escuras estão, muito parecido com os exemplos de potenciômetros do
Capítulo 5 onde o número indica a posição do botão.
Os sensores de luz dentro das TVs e de outros componentes de sistemas de
entretenimento detectam infravermelho (IR), que é uma luz não visível ao olho humano,
mas pode ser detectada por vários dispositivos eletrônicos. Por exemplo, se você olhar
para o final do controle remoto que você aponta para uma TV ou outros dispositivos de
entretenimento, você encontrará um LED IR. Quando você pressionar o botão do
controle remoto, ele enviará sinais codificados para o componente do sistema de
entretenimento, piscando o IR LED on / off. Como não podemos ver a luz
infravermelha, temos a impressão de que o LED do controle remoto não faz nada
quando você pressiona o botão. No entanto, se você tentar fazer isso enquanto olha para
o LED através da lente de uma câmera digital, o LED vai ficar quase branco. A luz
branca contém todas as cores do espectro. Os sensores verdes, azuis e vermelhos dentro
de uma câmera com chip, todos, reportarão que detectam luz em resposta a luz branca.
Acontece que os sensores de vermelho / verde / azul todos detectam a luz infravermelha
do IR LED do controle remoto também. Assim, a câmara também interpreta a luz de um
LED de infravermelhos como branca.
Página - 161
Mais sobre LEDs infravermelhos e detectores:
Robótica com o Boe-Bot tem exemplos onde o robô Boe-Bot controlado pelo
BASIC Stamp usa o LED IR, encontrado dentro dos controles remotos de TV, e
o receptor IR, encontrado dentro dos aparelhos de TV, para detectar objetos em
frente dele. O Boe-Bot usa o LED IR como uma pequena lanterna, e o receptor
IR encontrado dentro das TVs para detectar o IR reflexo das lanternas em objetos
na frente dele. O controle remoto IR para o Boe-Bot explica como os controles
remotos de TV codificam as mensagens que eles enviam para as TVs e tem
exemplos de como programar o microcontrolador BASIC Stamp para decodificar
as mensagens do controle remoto para que você possa enviar mensagens para o
seu robô Boe-Bot, e até mesmo conduzi-lo ao redor, tudo com um controle
remoto de TV.
O tipo de luz que um determinado dispositivo detecta depende do que ele foi projetado
para fazer. Por exemplo, sensores de luz para dispositivos que se ajustam às condições
de iluminação do ambiente precisam sentir a luz visível. Os sensores de pixels
vermelhos, verdes e azuis dentro câmeras digitais vão detectar cada um dos níveis de
cores específicas de uma imagem digital. O sensor IR dentro de uma TV está à procura
de luz infravermelha, que está piscando on / off próximo 40 kHz. Estes são apenas
alguns exemplos, e cada aplicação requer um tipo diferente de sensor de luz.
A Figura 7-1 mostra alguns exemplos dos muitos sensores de luz disponíveis para
vários requisitos dos sensores de luz. Da esquerda para a direita, ele mostra um
fototransistor, fotoresistor de sulfeto de cádmio, sensor de luz linear, fotodiodo azul
realçado, luz para conversor de frequência, fototransistor infravermelho e um receptor
remoto infravermelho de uma TV.
Figura 7-1: Exemplos de sensores de luz
Sobre a célula de sulfeto de cádmio (CdS) ou Fotoresistor
A célula de sulfeto de cádmio (CdS), ou fotoresistor, foi um dos sensores de luz
ambiente mais comuns em iluminação automática. Com o advento da diretiva da
União Europeia da restrição do uso de determinadas Substâncias Perigosas
(RoHS), os fotoresistores de sulfeto de cádmio já não podem ser incorporados na
maioria dos dispositivos importados ou fabricados na Europa. Isto tem
aumentado a utilização de um certo número de produtos em substituição ao
fotoresistor, incluindo o fototransistor e sensor de luz linear. Como resultado
destas alterações, esta edição apresenta agora um fototransistor que detecta níveis
de luz no lugar do fotoresistor de sulfeto de cádmio.
A documentação para cada sensor de luz descreve o tipo de luz que ele detecta em
termos de comprimento de onda. Comprimento de onda é a medida da distância entre as
formas ou ciclos de repetição. Por exemplo, imagine uma onda que viaja através do
Página - 162
oceano, subindo e descendo. O comprimento desta onda seria a distância entre cada pico
(ou whitecap) de seu ciclo. O comprimento de uma onda de luz pode ser medido de
forma semelhante, em vez disto, estamos medindo a distância entre os dois picos nas
oscilações eletromagnéticas de luz. Cada cor de luz tem o seu próprio comprimento de
onda e é considerada uma luz visível, o que significa que pode ser detectada pelo olho
humano. A Figura 7-2 mostra dois comprimentos de onda para a luz visível, bem como
para alguns tipos de luz que o olho humano não consegue detectar, incluindo radiação
ultravioleta e infravermelha. Estes comprimentos de onda são medidos em nanômetros,
que é abreviado nm. Um nanômetro é um bilionésimo de um metro.
Figura 7-2: Comprimentos de onda e as suas cores correspondentes
Comprimento de 10…380
450 495
570 590 620
onda (nm)
Violeta
Verde Laranj
Cor
Ultraviolet
Azul
Amarel
750…100,00
Infravermelh
Vermelho
o
NOTA: Se você estiver vendo isso no livro impresso em escala de cinza, você pode
baixar em PDF, totalmente colorido, pelo site www.parallax.com/go/WAM.
INTRODUÇÃO DO FOTOTRANSISTOR
Um transistor é como uma válvula que permite que certa quantidade de corrente elétrica
passe através de dois dos seus terminais. O terceiro terminal de um transistor controla
apenas a quantidade de corrente que passa através dos outros dois. Dependendo do tipo
de transistor, o fluxo de corrente pode ser controlado pela tensão, corrente, ou, no caso
do fototransistor, pela luz. Figura 7-3 mostra o esquema e desenho da peça para o
fototransistor em seu kit “O que é um Microcontrolador. Quanto mais luz atingir o
terminal da base do fototransistor (B), mais corrente será conduzida no seu coletor
terminal (C), que fluirá para fora do seu emissor terminal (E). Por outro lado, menos luz
que brilha sobre o terminal de base resulta em menos corrente conduzida.
B
Figura 7-3
Símbolo esquemático do
Fototransistor e desenho da
peça.
C
B
E
E
C
Este pico de sensibilidade do fototransistor é de 850 nm, o que de acordo com a Figura
7-2, está na gama de infravermelhos. Ele também responde a luz visível, embora de
maneira um pouco menos sensível, especialmente para os comprimentos de onda abaixo
de 450 nm, mostrado em azul na Figura 7-2. A luz halógena e lâmpadas incandescentes
e, especialmente, luz solar são fontes muito mais fortes do infravermelho do que as
lâmpadas fluorescentes. O transistor infravermelho responde bem a todas estas fontes de
Página - 163
luz, mas é mais sensível à luz do sol, em seguida, com lâmpadas de halogêneo e
incandescente, e um pouco menos sensível às lâmpadas fluorescentes.
Projetos de circuitos, usando o transistor, podem ser ajustados para funcionar melhor em
certos tipos de condições de iluminação, e os circuitos do Fototransistor, neste capítulo,
são projetados para uso interno. Existe um aplicativo de detecção de luz ao ar livre, mas
usaria um dispositivo diferente que possa parecer à primeira vista como um candidato
improvável para um sensor de luz: um diodo emissor de luz.
ATIVIDADE #1: CONSTRUINDO E TESTANDO O MEDIDOR DE LUZ
O Capítulo 5 introduziu medidas de queda de RC com o comando RCTIME para medir o
tempo que o capacitor levou para perder sua carga através de um resistor variável dentro
de um potenciômetro. Com maior resistência (para o fluxo de corrente elétrica), o
potenciômetro desacelerou o ritmo, o capacitor perdeu sua carga, e as resistências
menores aceleraram o ritmo. A medição do tempo de queda deu uma indicação da
resistência do potenciômetro, que por sua vez possibilitou ao BASIC Stamp saber a
posição do seletor do potenciômetro.
Quando colocado em um circuito de queda RC, um fototransistor, que permite a
passagem de mais ou menos corrente, quando mais ou menos luz brilha sobre ele, se
comporta de maneira semelhante ao potenciômetro. Quando brilha mais luz sobre o
fototransistor, ele conduz mais corrente, e o capacitor perde sua carga mais
rapidamente. Com menos luz, o fototransistor permite a passagem de menos corrente e
o capacitor perde sua carga mais devagar. Assim, a mesma medida RCTIME que nos deu
uma indicação da posição da marcação com um potenciômetro no Capítulo 5, pode ser
agora usada para medir os níveis de luz com um fototransistor.
Nesta atividade, você vai construir e testar um circuito de queda RC que mede o tempo
que leva para a carga do capacitor cair através de um fototransistor. A medição de queda
RC vai lhe dar uma ideia dos níveis de luz detectados pela área de luz sentida pelo
fototransistor. Tal como acontece com os testes do potenciômetro, os valores de tempo
medidos pelo comando RCTIME serão exibidos no DEBUG Terminal.
Peças para o Teste do Detector de Luz
(1) Fototransistor
(2) Capacitores – 0,01 µF (rotulado 103)
(1) Capacitor – 0,1 µF (rotulado 104)
(1) Fio
Construindo o Circuito Tempo RC com um Fototransistor
A Figura 7-4 mostra um diagrama esquemático e diagrama de fiação do circuito RCtime que você vai usar neste capítulo. Este circuito é diferente do circuito do
potenciômetro do Capítulo 5, Atividade #3, de duas maneiras. Em primeiro lugar, o
pino de I/O utilizado para medir o tempo de queda é diferente (P2). Em segundo lugar, o
potenciômetro foi substituído por um fototransistor.
Página - 164
Dica: Deixe o seu LED de 7 segmentos conectado, e adicione o circuito de
fototransistor à sua placa. Nós vamos usar o LED de 7 segmentos com o
fototransistor na Atividade #4.
 Certifique-se de que o coletor do fototransistor e os terminais emissores (C e E)
estejam conectados conforme mostrado no diagrama de fiação.
Vdd
Vin
Figura 7-4
Esquema e3 diagrama
de fiação do circuito
tempo RC com um
fototransistor
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Longer pin
(C) terminal
Comece com o
capacitor de 0,01 µF,
rotulado 103.
Flat spot
(E) terminal
Programando o Teste do Fototransistor
O primeiro programa de exemplo (TestPhototransistor.bs2) é realmente apenas uma
versão ligeiramente revisada de ReadPotWithRcTime.bs2 do Capítulo 5, Atividade #3.
O circuito do potenciômetro do Capítulo 5 foi ligado ao pino de I / O P7. O circuito
nesta atividade está ligado a P2. Devido a essa diferença, o programa de exemplo tem
que ter dois comandos atualizados para fazê-lo funcionar. O comando HIGH 7 do
programa de exemplo anterior é agora HIGH 2, pois o circuito do fototransistor está
ligado a P2 e não P7. Pela mesma razão, o comando RCTIME 7, 1, time foi alterado
para RCTIME 2, 1, time.
Exemplo de Programa: TestPhototransistor.bs2
O coletor de luz de superfície do fototransistor está na cúpula de plástico transparente,
que é o terminal de base (B), mostrado na Figura 7-3. Um quadradinho preto deve ser
visível através dessa cúpula. Esse quadrado preto é o fototransistor real, um pequeno
pedaço de silício. O resto do dispositivo é a “embalagem”, incluindo caixa de plástico,
quadro condutor e eletrodos.
Em vez de girar o botão do potenciômetro, como fizemos no Capítulo 5, este circuito é
testado através da exposição da superfície de coleta de luz do fototransistor a diferentes
níveis de luz. Quando o programa de exemplo estiver sendo executado, o DEBUG
Página - 165
Terminal deverá exibir valores pequenos para as condições de luz brilhante e grandes
para condições de baixa luminosidade.
Evite luz solar direta! O circuito e o programa que você está usando são
projetados para detectar variações na iluminação interna e não trabalham na luz
solar direta. Deixe as luzes internas ligadas, mas feche as cortinas, caso o sol
esteja entrando através das janelas mais próximas.
 Coloque e execute o TestPhototransistor.bs2.
 Anote a variável time no DEBUG Terminal sob condições normais de
iluminação.
 Lance uma sombra sobre o circuito com a sua mão e verifique a variável time
novamente. Deve mostrar um número maior.
 Coloque a mão sobre o circuito para lançar uma sombra mais escura, o DEBUG
Terminal deve exibir um valor significativamente maior para time.
' O que é um Microcontrolador - TestPhototransistor.bs2
' Lê Fototransistor em circuito RC-time usando comando RCTIME.
' {$STAMP BS2}
' {$PBASIC 2.5}
time
PAUSE 1000
VAR
Word
DO
HIGH 2
PAUSE 100
RCTIME 2, 1, time
DEBUG HOME, "time =
LOOP
", DEC5 time
Sua Vez – Usando um Capacitor Diferente Para Diferentes Condições de
Luminosidade
As medições do tempo, com um capacitor de 0,1 μF, levarão dez vezes mais tempo do
que aquelas feitas com um capacitor de 0,01 μF, o que significa que o valor da variável
time exibido pelo DEBUG Terminal deverá ser dez vezes maior. Substituir o capacitor
de 0,01 μF por um capacitor de 0,1 μF pode ser útil para salas mais iluminadas onde
você costuma ver medidas menores com um capacitor de 0,01 μF. Por exemplo, vamos
dizer que as condições de iluminação são muito brilhantes, e as medidas são de 1 a 13,
com um capacitor de 0,01 μF. Se você substituí-lo por um capacitor de 0,1 μF, suas
medidas, ao contrário, vão variar de 1 a 130, e sua aplicação será mais sensível às
variações de luz dentro da sala.
 Modifique o circuito substituindo o capacitor de 0,01 μF, por um capacitor de
0,1 μF (rotulado 104).
 Reexecute o TestPhototransistor.bs2 e verifique se as medidas de RC-time são
cerca de dez vezes seus valores anteriores.
O intervalo de tempo mais longo que o comando RCTIME pode medir é de 65.535
unidades de 2 µs cada, o que corresponde a um tempo de queda de: 65535 × 2 µs = 131
Página - 166
ms = 0,131 segundos. Se o tempo de queda for superior a 0,131 segundos, o comando
RCTIME retorna para 0, para indicar que o tempo máximo de medição foi excedido.
 Você pode lançar uma sombra bem escura sobre o fototransistor e ultrapassar a
medida máxima 65535 e fazer o comando RCTIME voltar a 0?
A próxima atividade contará com o menor dos dois capacitores.
 Antes de passar para a próxima atividade, retorne o circuito ao original como
mostrado na Figura 7-4, remova o capacitor de 0,1 μF e substitua-o pelo
capacitor de 0,01 μF.
ATIVIDADE #2: RASTREANDO EVENTOS DE LUZ
Uma das características mais úteis da memória do programa do módulo BASIC Stamp é
que você pode desligar a alimentação da placa, sem perder o seu programa. Assim como
a energia é restabelecida, o programa começa a correr a partir do início. Desde que o
código para a sua aplicação não encha a memória do módulo BASIC Stamp, qualquer
parte que não for usada para o programa poderá ser usada para armazenar dados. Esta
memória é especialmente boa para o armazenamento de dados que você não deseja que
o BASIC Stamp esqueça. Enquanto os valores armazenados por variáveis são apagados
quando a energia é desligada, o BASIC Stamp ainda vai se lembrar de todos os valores
armazenados em sua memória de programa quando o aparelho for religado.
O que é um registro de dados? O registro de dados é o que um
microcontrolador faz quando grava e armazena as medições periódicas do sensor
por um determinado período de tempo. Dispositivos de registro de dados, ou
dataloggers, são especialmente úteis em pesquisas científica. Por exemplo, em
vez de enviar uma pessoa para um local distante para fazer as medições
meteorológicas, pode ser implantada uma estação meteorológica de registro de
dados, que registra as medições periódicas, e os cientistas visitam-na de vez em
quando para coletar os dados, ou em alguns casos, eles transferem suas medições
para um computador por telefone celular, rádio ou satélite.
O chip do BASIC Stamp que armazena a memória do programa e os dados é mostrado
na Figura 7-5. Este chip é chamado de EEPROM, que significa Electrically Erasable
Programmable Read-Only Memory, (que é, basicamente, em tradução livre, uma
memória que pode ser apagada várias vezes, eletricamente). Isso é um pouco
complicado de se pronunciar, soletra-se cada uma das primeiras letras da palavra
EEPROM. Quando as pessoas falam sobre uma EEPROM, elas costumam pronunciar:
EE-Prom.
Página - 167
2 KB da
EEPROM
armazena o
código de fonte
do seu PBASIC
Figura 7-5
Chip EEPROM no
Módulo BASIC Stamp
Este EEPROM
armazena seu código
de programa e
quaisquer outros
dados que o programa
coloca lá, mesmo
quando a energia é
desligada.
Figura 7-6 mostra a janela do mapa de memória do BASIC Stamp Editor. Você pode
visualizar esta janela clicando no BASIC Stamp Editor Run no menu e selecionar
Memory Map.
O Mapa de memória usa cores diferentes para mostrar como ambos os módulos do
BASIC Stamp RAM (variáveis na memória de acesso aleatório) e EEPROM (memória
de programa) estão sendo usados. O quadrado vermelho na barra de rolagem no canto
esquerdo indica que parte da EEPROM é visível no mapa da EEPROM. Você pode
clicar e arrastar esta área para cima e para baixo para ver as várias porções da memória
EEPROM. Ao arrastar aquele quadrado vermelho até o fundo, você pode ver quanto
espaço de memória EEPROM é usado por TestPhototransistor.bs2 de Atividade #1. Os
bytes que contêm símbolos do programa são destacados em azul, e apenas 35 bytes fora
dos 2048 bytes EEPROM são usados para o programa. Os restantes 2.013 bytes são
livres para armazenar dados.
Figura 7-6
Mapa da Memória
Para visualizar esta
janela, clique em
“Run” (Executar), e
selecione “Memory
Map” (Mapa da
Memória).
O Mapa EEPROM mostra os endereços como valores hexadecimais, que foram
discutidos brevemente na caixa “Decimal vs Hexadecimal” na página 150. Os valores
ao longo do lado esquerdo mostram o endereço de partida de cada linha de bytes. Os
números na parte superior mostram o número de bytes no interior dessa linha, de 0 a F
em hexadecimal, que é de 0 a 15 em decimal. Por exemplo, na Figura 6-7, o valor
hexadecimal C1 é armazenado no endereço 7E0. CC é armazenado no endereço 7E1,
6D é armazenado em 7E2, e assim por diante até E8, que é armazenado no endereço
7EF. Se você rolar para cima e para baixo com a barra de rolagem, você verá que os
maiores endereços de memória estão na parte inferior do mapa da EEPROM e os
endereços menores estão no topo, com a linha superior iniciando em 000.
Página - 168
Os programas PBASIC são sempre armazenados em endereços maiores na EEPROM,
mostrados na parte inferior do mapa da EEPROM. Assim, se o seu programa for
armazenar dados na EEPROM, deve começar com os endereços menores, iniciando
com o endereço 0. Isso ajuda a garantir que os dados armazenados não sobrescreverão o
seu programa PBASIC, o que resultará em um acidente de programa. No caso do Mapa
EEPROM mostrado na Figura 6-7, o programa PBASIC reside em endereços 7FF a
7DD, começando no endereço maior para a construção de endereços menores. Portanto,
sua aplicação pode armazenar dados de endereços 000 a 7DC, construídos desde o
menor até o maior. Em decimal os endereços são de 0 a 2012.
Se você planeja armazenar dados na memória EEPROM, é importante que você faça a
conversão de hexadecimal para decimal, a fim de calcular o maior endereço gravável.
Abaixo segue o cálculo para converter o número 7DC hexadecimal para decimal.
Hexadecimal é um sistema numérico com uma base de 16, o que significa que usa 16
dígitos diferentes para representar seus valores. Os dígitos 0 à 9 representam os
primeiros 10 valores, e as letras A à F representam valores de 10 à 15. Ao converter a
partir de hexadecimal para decimal, cada dígito da direita representa uma maior
potência de dezesseis. O dígito mais à direita é o número de uns, que é o número de
160s. O dígito seguinte, a partir da direita, é o número de 16s, que é o número de 161s. O
terceiro dígito é o número de 256s, que é o número de 162s.
Hexadecimal 7DC
=
=
=
=
=
(7 × 162) + (D × 161) + (C × 160)
(7 × 162) + (13 × 161) + (12 × 160)
(7 × 256) + (13 × 16) + (12 × 1)
1792 + 208 + 12
2012 (valor decimal)
Esta abordagem de conversão funciona da mesma forma em outras bases, incluindo a
base de 10 valores decimais. Por exemplo:
2102 = (2 × 103) + (1 × 102) + (0 × 101) + (2 × 100)
= (2 × 1000) + (1 × 100) + (0 × 10) + (2 × 1)
2048 bytes = 2 KB.
Embora tanto a maiúscula quanto a minúscula “K” sejam chamadas
"quilo", elas são ligeiramente diferentes. Em eletrônica e computação, a
maiúscula K é usada para indicar um kilobyte binário, que é 1 × 210 = 1024. Ao
se referir a exatamente 1.000 bytes, use a minúscula k, que significa quilo e é 1 x
103 = 1000 no sistema métrico.
Além disso, a maiúscula "B" 'significa bytes, enquanto a minúscula "b"
significa bits. Isso pode fazer uma grande diferença porque significa 2 Kb 2048
bits, que são 2048 números diferentes, mas cada número é limitado a um valor de
0 ou 1. Em contraste, 2 KB são 2048 bytes, em cada um pode ser armazenado um
valor na gama de 0 a 255.
Usar o EEPROM para o armazenamento de dados pode ser muito útil para aplicações
remotas. Um exemplo de uma aplicação remota seria um monitor de temperatura
colocado num veículo que transporta alimentos congelados. Ele controlaria a
temperatura durante toda a viagem verificando se ela se manteve fria o suficiente e que
Página - 169
nada no desembarque estava descongelado. Um segundo exemplo é uma estação
meteorológica. Uma das peças de registro de dados de uma estação meteorológica que
pode ser armazenada para posterior recuperação é a dos níveis de luz. Isso pode dar uma
indicação da nebulosidade em momentos do dia, alguns estudos usam para monitorar os
efeitos da poluição e de trilhas de condensação de rastros de avião (com trilhas) em
níveis de luz que atingem a superfície da Terra.
Com o acompanhamento do nível de luz na mente, esta atividade apresenta uma técnica
para armazenar os níveis de iluminação medidos para a EEPROM e depois recuperá-los
novamente. Nesta atividade, você vai executar um exemplo de programa PBASIC que
armazena uma série de medições de luz na EEPROM do módulo BASIC Stamp. Depois
que o programa estiver concluído, você vai correr um segundo programa que recupera
os valores da EEPROM e os exibe no DEBUG Terminal.
Programando o Armazenamento de Dados a Longo Prazo
O comando WRITE é utilizado para armazenar valores na EEPROM, e o comando READ
é utilizado para obter esses valores.
A sintaxe do comando é:
WRITE Location, {WORD} Value
Por exemplo, se você quer escrever o valor de 195 para endereçar 7 na EEPROM, você
pode usar o comando:
WRITE 7, 195
Os valores de WORD podem estar entre 0 e 65565, enquanto os valores de byte podem
conter apenas os números de 0 a 255. O valor da palavra ocupa o espaço de dois bytes.
Se você quiser escrever o tamanho do valor da palavra na EEPROM, você tem que usar
o modificador WORD opcional. Porém, tenha cuidado: Uma vez que a palavra ocupa dois
bytes, você tem que pular um dos endereços do tamanho dos bytes da EEPROM antes
de escrever outra palavra. Vamos dizer que você precisa para salvar dois valores de
palavra para EEPROM: 659 e 50012. Se você deseja armazenar o primeiro valor no
endereço 8, você terá que escrever o segundo valor para o endereço 10.
WRITE 8, Word 659
WRITE 10, Word 50012
Página - 170
É possível escrever sobre o seu programa? Sim, e se você fizer isso, é provável
que o programa comece a se comportar de modo estranho ou pare de funcionar
completamente. Uma vez que os sinais do programa PBASIC residem nos
maiores endereços da EEPROM, é melhor usar os menores valores de Location
para armazenar números com o comando WRITE.
Como eu sei se o Location que estou usando é muito grande? Você pode usar
o mapa de memória para descobrir o maior valor não utilizado pelo seu programa
PBASIC. A explicação após a Figura 7-6 na página 168 descreve como calcular
quantos endereços de memória estão disponíveis. Como um atalho para converter
hexadecimal para decimal, você pode usar o formatador DEC e o formatador $
hexadecimal do comando DEBUG assim:
DEBUG DEC $7DC
O programa vai exibir o valor decimal de 7DC hexadecimais porque o
formatador $ hexadecimal diz ao comando DEBUG que 7DC é um número
hexadecimal. Então, o formatador DEC faz com que o comando DEBUG exiba
esse valor em formato decimal.
Exemplo de Programa: StoreLightMeasurementsInEeprom.bs2
Este programa de exemplo demonstra como usar o comando WRITE, tomando medições
de luz cada 5 segundos por 2 minutos e meio e as armazenando na EEPROM. Como
exemplo de programa da atividade anterior, ele exibe as medições no DEBUG
Terminal, mas também armazena cada medição na EEPROM para posterior recuperação
por um programa diferente, que usa o comando READ.
 Coloque e execute StoreLightMeasurementsInEeprom.bs2.
 Registre os valores apresentados pelo DEBUG Terminal para que você possa
verificar as medições e relê-las na EEPROM.
 Aumente gradualmente a sombra sobre o fototransistor durante o período de
teste de 2 ½ minutos para dados significativos.
Especialmente se você tem uma placa USB, ligá-la ao computador poderia restabelecer
o BASIC Stamp e reiniciar o programa, neste caso, ele começaria a tomar um novo
conjunto de medições.
 Após o término de StoreLightMeasurementsInEeprom.bs2, desconecte a
alimentação de sua placa imediatamente e deixe-a desligada até que você esteja
pronto
para
executar
o
próximo
programa
de
exemplo:
ReadLightMeasurementsFromEeprom.bs2.
Você pode alterar as pausas no loop FOR...NEXT. Este exemplo de
programa tem cinco segundos de pausa, que enfatizam as medições periódicas
que os dispositivos de registro de dados tem. Eles podem parecer meio longos,
por isso, você pode reduzir o PAUSE 5000 para PAUSE 500 para fazer o
programa executar dez vezes o teste mais rápido.
Página - 171
' O que é um Microcontrolador - StoreLightMeasurementsInEeprom.bs2
' Escreve medições de luz para EEPROM.
' {$STAMP BS2}
' {$PBASIC 2.5}
time
eepromAddress
VAR
VAR
Word
Byte
PAUSE 1000
DEBUG "Iniciando medições...", CR, CR
"Valor da medição", CR,
"---------------", CR
FOR eepromAddress = 0 TO 58 STEP 2
HIGH 2
PAUSE 5000
RCTIME 2, 1, time
DEBUG DEC2 eepromAddress,
"
", DEC time, CR
WRITE eepromAddress, Word time
NEXT
DEBUG "Pronto. Agora, execute:", CR,
"ReadLightMeasurementsFromEeprom.bs2"
END
Como Funciona StoreLightMeasurementsInEeprom.bs2
O loop FOR...NEXT que mede os valores de RC-time e os armazena na EEPROM tem
que contar em intervalos de 2, porque os valores da palavra estão escritos na EEPROM.
FOR eepromAddress = 0 to 58 STEP 2
O comando RCTIME carrega a medição do tempo de queda para o tamanho da palavra
na variável time.
RCTIME 2, 1, time
O valor que a variável time armazena é copiado para o endereço na EEPROM obtido
pelo valor atual da variável eepromAddress cada vez através do loop. Lembre-se de
que o endereço de um comando WRITE é sempre em termos de bytes. Assim, a variável
eepromAddress é incrementada por dois de cada vez através do loop, porque uma
variável Word ocupa dois bytes.
WRITE eepromAddress, Word time
NEXT
Programando a Recuperação de Dados
Para recuperar os valores que você acabou de gravar a partir da EEPROM, você pode
usar o comando READ. A sintaxe para o comando READ é:
READ Location, {WORD} Variable
Enquanto o comando WRITE pode copiar tanto um valor de uma constante ou de uma
variável para a EEPROM, o comando READ tem que copiar o valor armazenado no
Página - 172
endereço da EEPROM para a variável, assim como o próprio nome sugere, o argumento
variável deve ser uma variável.
Tenha em mente que as variáveis são armazenadas na memória RAM do módulo
BASIC Stamp. Ao contrário da EEPROM, os valores de RAM são apagados
sempre que a alimentação for desligada e também sempre que o botão Reset na
sua placa for pressionado.
O BASIC Stamp 2 tem 26 bytes de RAM, mostrados no lado direito do mapa de
memória na Figura 7-6 na página 167. Se você declarar uma variável Word,
você está usando dois bytes. A declaração da variável byte usa um byte, um
nibble usa metade de um byte, e um bit utiliza 1/8 de um byte.
Digamos que eepromValueA e eepromValueB são variáveis de Word e littleEE é
uma variável Byte. Estas variáveis têm de ser definidas no início do programa com
declarações de variáveis VAR. Aqui estão alguns comandos para recuperar os valores
que foram armazenados anteriormente em determinados endereços EEPROM com
comandos WRITE, talvez até mesmo em um programa diferente.
READ 7, littleEE
READ 8, Word eepromValueA
READ 10, Word eepromValueB
O primeiro comando recupera um valor byte do endereço EEPROM 7 e copia para a
variável denominado littleEE. O próximo comando copia a palavra ocupando
EEPROM byte endereços 8 e 9 e as armazena em eepromValueA da variável word. O
último dos três comandos copia a palavra ocupando EEPROM byte endereços 10 e 11 e
as armazena na variável eepromValueB.
Exemplo de Programa: ReadLightMeasurementsFromEeprom.bs2
Este programa de exemplo demonstra como utilizar o comando READ para recuperar as
medições
de
luz
que
foram
armazenadas
na
EEPROM
por
StoreLightMeasurementsInEeprom.bs2.
 Reconecte a energia de sua placa.
 Coloque ReadLightMeasurementsFromEeprom.bs2 no BASIC Stamp Editor.
 Se você tiver desligado a energia de sua placa, quando a reconectar, clique
imediatamente no botão Run do BASIC Stamp Editor para baixar o programa
para o BASIC Stamp.
Não espere mais de 6 segundos entre reconectar a energia e carregar
ReadLightMeasurementsFromEeprom.bs2 no BASIC Stamp ou o programa que
ainda está na memória de programa (StoreLightMeasurementsInEeprom.bs2) vai
começar a gravar sobre as medições anteriores. Além disso, se você reduziu
Duration do comando PAUSE 5000 para 500, você terá apenas 1,5
segundo!
 Compare a tabela do DEBUG Terminal apresentada neste programa, com a
exibida no StoreLightMeasurementsInEeprom.bs2, e verifique se os valores são
os mesmos.
Página - 173
' O que é um Microcontrolador - ReadLightMeasurementsFromEeprom.bs2
' Lê as medições de luz da EEPROM.
' {$STAMP BS2}
' {$PBASIC 2.5}
time
eepromAddress
VAR
VAR
Word
Byte
PAUSE 1000
DEBUG "Recuperando as medições", CR, CR,
"Valor da medição", CR,
"--------------", CR
FOR eepromAddress = 0 TO 58 STEP 2
READ eepromAddress, Word time
DEBUG DEC2 eepromAddress, "
", DEC time, CR
NEXT
END
Como Funciona o ReadLightMeasurementsFromEeprom.bs2
Tal como acontece com o comando WRITE, o comando READ conta com endereços de
byte. Se nós quisermos ler os valores da palavra da EEPROM, a variável
eepromAddress tem que ter dois adicionado a ela cada vez através do loop
FOR...NEXT.
FOR eepromAddress = 0 to 58 STEP 2
O comando READ recebe o valor do tamanho da palavra em eepromAddress, que é
copiado para a variável time.
READ eepromAddress, Word time
Os valores do tempo e as variáveis eepromAddress são exibidas em colunas
adjacentes, como uma tabela no DEBUG Terminal.
DEBUG DEC2 eepromAddress, "
NEXT
", DEC time, CR
Sua Vez – Mais Medições
 Modifique StoreLightMeasurementsInEeprom.bs2 para que ele leve e registre o
dobro de medições na mesma quantidade de tempo.
 Modifique ReadLightMeasurementsFromEeprom.bs2 para que exiba todas as
medições já modificadas do StoreLightMeasurementsInEeprom.bs2.
ATIVIDADE #3: MEDIÇÕES GRÁFICAS DE LUZ (OPCIONAL)
Listas de medições como as da Atividade #2 podem ser tediosas de analisar. Imagine ler
centenas de números sem interrupção até o sol se por. Ou talvez você esteja olhando
Página - 174
para um evento especial, como quando o sensor de luz foi brevemente coberto. Você
pode até estar a olhar para um padrão na forma como muitas vezes o sensor de luz foi
coberto. Esta informação pode ser útil se o sensor de luz for colocado em uma área onde
uma pessoa ou animal caminhar sobre ela, ou um objeto que passar por cima de uma
correia transportadora precisar ser registrado e analisado. Independentemente da
aplicação, se tudo que você tem para trabalhar é uma longa lista de números, encontrar
esses eventos e padrões podem ser uma tarefa difícil e demorada.
Se você fizer um gráfico da lista de medições será muito mais fácil encontrar eventos e
padrões. A pessoa, animal ou objeto que passar sobre o sensor de luz vai aparecer como
um ponto alto ou pico nas medições. A Figura 7-7 mostra um exemplo de um gráfico
que indica a taxa quando os objetos sobre uma correia transportadora estão passando
sobre o sensor. Os picos no gráfico ocorrem quando as medições forem grandes. No
caso de uma correia transportadora, indicaria que um objeto passou sobre o sensor
lançando uma sombra. Este gráfico facilita com um olhar de relance ver que um objeto
passa sobre o sensor aproximadamente a cada 7 segundos, mas que o objeto esperado
em 28 segundos não estava lá.
Figura 7-7: Gráfico de medições de luz do fototransistor
Decay Time Vs. Time
for Phototransistor RC Circuit
9000
8000
Decay Time (2 us)
7000
6000
5000
4000
3000
2000
1000
0
0
"Decay Time"
10
20
30
40
50
60
Tim e (s)
O gráfico da figura 7-7 foi gerado copiando e colando valores no DEBUG Terminal
para um arquivo de texto que foi, em seguida, importado para uma planilha do
Microsoft Excel. Alguns utilitários gráficos podem tomar o lugar do DEBUG Terminal
e traçar os valores diretamente, em vez de exibi-los como listas de números. A Figura 78 mostra um exemplo de um desses utilitários, chamado StampPlot LITE.
Página - 175
Figura 7-8: StampPlot LITE
Nesta atividade opcional, você pode ir para www.parallax.com/go/WAM e seguir o link
“Dados de Plotagem” (Data Plotting) para tentar uma série de atividades que
demonstram como plotar valores utilizando várias planilhas e gráficos de pacotes de
software de utilitários.
ATIVIDADE #4: SIMPLES MEDIDOR DE LUZ
As informações do sensor de luz podem ser transmitidas de várias formas. O medidor de
luz que você vai trabalhar nessa atividade altera a taxa das cintilações dependendo da
intensidade de luz que ele detecta.
Peças do Medidor de Luz
(1) Fototransistor
(1) Resistor – 220 Ω (vermelho-vermelho-marrom)
(2) Capacitores – 0,01 μF (rotulado 103)
(1) Capacitor – 0,1 μF (rotulado 104)
(1) Display de LED de 7 segmentos
(8) Resistores – 1 kΩ (marrom-preto-vermelho)
(6) Fios
Construindo o Circuito do Medidor de Luz
Figura 7-9 mostra o display de LED de 7 segmentos e esquemas de circuitos do
fototransistor que serão utilizados para fazer o medidor de luz, e a Figura 7-10 mostra o
diagrama de fiação dos circuitos. O circuito do fototransistor é o mesmo que você usou
nas duas últimas atividades, e o circuito do display do LED de 7 segmentos é o mesmo
da Figura 6-11 na página 145.
 Construa o circuito mostrado na Figura 7-9 e na Figura7-10.
Página - 176
 Teste o display de LED de 7 segmentos para ter certeza de que está conectado
corretamente, usando o programa SegmentTestWithHighLow.bs2 do Capítulo 6,
Atividade #2, que começa na página 144.
Figura 7-9
Esma do circuito
do medidor de
luz
Figura 7-10
Diagrama de
fiação para a
Figura 7-9
Utilizando Sub-rotinas
A maioria dos programas que você escreveu até agora operam dentro de um
DO...LOOP. Uma vez que a atividade principal de todo o programa acontece dentro do
DO...LOOP, ela é normalmente chamada de rotina principal. À medida que você
adicionar mais circuitos e funções mais úteis ao seu programa, poderá ficar um pouco
difícil manter o controle de todo o código na rotina principal. Seus programas serão
muito mais fáceis de trabalhar se você em vez organizá-los em pequenos segmentos de
código para fazer determinados trabalhos. O PBASIC tem alguns comandos que você
pode usar para fazer o programa saltar para fora da rotina principal, fazer um trabalho e,
em seguida, retornar para o mesmo local na rotina principal. Isto irá permitir que você
mantenha cada segmento de código que faz um trabalho específico em algum lugar
diferente da rotina principal. Cada vez que você precisar do programa para fazer um
Página - 177
desses trabalhos, você pode escrever um comando dentro da rotina principal que diz ao
programa para saltar para esse trabalho, fazê-lo, e voltar quando o trabalho estiver feito.
Os trabalhos são chamados de sub-rotinas e este processo está chamando uma subrotina.
A Figura 7-11 mostra um exemplo de uma sub-rotina e como ela é usada. O comando
GOSUB Subroutine_Name faz com que o programa salte para a Subroutine_Name:
label. Quando o programa chega a esse rótulo, ele continua correndo e executa
comandos até chegar a um comando RETURN. Então, o programa volta ao comando que
vem após o comando GOSUB. No caso do exemplo mostrado na Figura 7-11, o próximo
comando é: DEBUG "Next command”.
DO
GOSUB Subroutine_Name
DEBUG "Next command"
LOOP
Subroutine_Name:
Figura 7-11
Como as sub-rotinas
trabalham
DEBUG "This is a subroutine..."
PAUSE 3000
RETURN
O que é um label? Label é um nome que pode ser usado como um espaço
reservado em seu programa. GOSUB é um dos comandos que você pode usar
para saltar para um label. Alguns outros são GOTO, ON GOTO, e ON GOSUB.
O label deve terminar com dois pontos, e por uma questão de estilo, palavras
separadas terão o caractere sublinhado para ficar mais fácil de reconhecer. Ao
escolher um nome para um label, certifique-se de não usar uma palavra reservada
ou um nome que já está sendo usado em uma variável ou constante. O resto das
regras para o nome do label são os mesmos que os nomes das variáveis, que
estão listadas na caixa de informações na página 36.
Exemplo de Programa: SimpleSubroutines.bs2
Este programa de exemplo mostra como sub-rotinas operam enviando mensagens para o
DEBUG Terminal.
 Examine SimpleSubroutines.bs2 e tente adivinhar a ordem em que os comandos
DEBUG serão executados.
 Coloque e execute o programa.
 Compare o comportamento atual de seu programa com suas previsões.
' O que é um Microcontrolador - SimpleSubroutines.bs2
' Demonstra como sub-rotinas funcionam.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DO
Página - 178
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
CLS, "Inicia rotina principal.", CR
2000
First_Subroutine
"Retorna à principal.", CR
2000
Second_Subroutine
"Repete principal...", CR
2000
LOOP
First_Subroutine:
DEBUG " Executando primeira "
DEBUG "sub-rotina.", CR
PAUSE 3000
RETURN
Second_Subroutine:
DEBUG " Executando segunda "
DEBUG "sub-rotina.", CR
PAUSE 3000
RETURN
Como Funciona SimpleSubroutines.bs2
A Figura 7-12 mostra como a chamada First_Subroutine na rotina principal
(DO...LOOP) funciona. O comando GOSUB First_Subroutine envia o programa
para a First_Subroutine: label. Em seguida, os três comandos dentro dessa subrotina são executados. Quando o programa chega ao comando RETURN, ele pula de volta
para o comando que vem logo após GOSUB First_subroutine, que é DEBUG
"Retorna à principal", CR.
O que é uma chamada de sub-rotina? Quando você usa o comando GOSUB
para fazer o programa saltar para uma sub-rotina, isso é chamado de chamada de
sub-rotina.
PAUSE 2000
GOSUB First_Subroutine
DEBUG "Back in main.", CR
First_Subroutine:
DEBUG "
Executing first "
DEBUG "subroutine.", CR
PAUSE 3000
RETURN
Figura 7-12
Primeira Chamada de
Sub-rotina
Página - 179
A Figura 7-13 mostra um segundo exemplo do mesmo processo com a chamada da
segunda sub-rotina (GOSUB Second_Subroutine).
PAUSE 2000
GOSUB Second_Subroutine
DEBUG "Repeat main...", CR
Second_Subroutine:
DEBUG "
Executing second "
Figura 7-13
Chamada de Segunda
Sub-rotina
DEBUG "subroutine", CR
PAUSE 3000
RETURN
Sua Vez – Adicionando Identando Sub-Rotinas
Você pode adicionar sub-rotinas após as duas que estão no programa e chamá-las de
dentro da rotina principal.
 Adicione
a sub-rotina mostrada na Figura 7-11, na página 177 à
SimpleSubroutines.bs2.
 Faça os ajustes necessários aos comandos DEBUG, de modo que o visor pareça
correto com todas as três sub-rotinas.

Você também pode chamar uma sub-rotina de dentro de outra. Isso é chamado de
identamento de sub-rotinas.
 Tente mover o comando GOSUB que chama SUBROUTINE_NAME em uma das
outras sub-rotinas, e ver como ele funciona.
Ao identar as sub-rotinas, a regra é: não mais do que quatro. Consulte o
Manual de BASIC Stamp ou Ajuda do BASIC Stamp Editor para mais
informações. Localize GOSUB e RETURN.
Medidor de Luz Utilizando Sub-rotinas
O programa seguinte, LightMeter.bs2, utiliza rotinas para controlar o display de LED de
7 segmentos de acordo com o nível de luz detectada pelo fototransistor. O ciclo do
display dos segmentos on e off em um padrão circular, fica mais rápido quando a luz no
fototransistor fica mais brilhante. Quando a luz fica mais fraca, o padrão circular vai
mais devagar. O exemplo de programa LightMeter.bs2 utiliza uma sub-rotina
denominada Update_Display para controlar a ordem em que os segmentos do
medidor de luz avançam. O programa que executa o medidor de luz vai lidar com três
operações diferentes:
1. Ler o Fototransistor.
2. Calcular o tempo de espera antes de atualizar o display de LED de 7 segmentos.
3. Atualizar o display de LED de 7 segmentos.
Página - 180
Cada operação está contida dentro de sua própria sub-rotina, e a rotina principal
DO...LOOP chamará cada uma em sequência, repetidamente.
Exemplo de Programa: LightMeter.bs2
Condições controladas de iluminação fazem uma grande diferença! Para
melhores resultados, realize este teste em uma sala iluminada por lâmpadas
fluorescentes com pouca, ou nenhuma, luz solar direta (feche as cortinas). Para
obter informações sobre como calibrar este medidor para outras condições de
iluminação, consulte a seção “Sua Vez”.
 Coloque e execute LightMeter.bs2.
 Verifique se a velocidade do ciclo do teste padrão circular exibido pelo LED de
7 segmentos é controlada pelas condições de iluminação que o fototransistor está
percebendo. Para fazer isso, projete uma sombra sobre ele com a mão ou um
pedaço de papel e verifique se a taxa de exibição do padrão circular desacelera.
' O que é um Microcontrolador - LightMeter.bs2
' Indica nível de luz usando display de LED de 7 segmentos.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
index
time
VAR
VAR
Nib
Word
' Declaração de variáveis.
OUTH = %00000000
DIRH = %11111111
' Inicializa display de 7 segmentos.
DO
' Rotina principal.
GOSUB Get_Rc_Time
GOSUB Delay
GOSUB Update_Display
LOOP
Get_Rc_Time:
' Sub-rotinas
' Sub-rotina RC-time
HIGH 2
PAUSE 3
RCTIME 2, 1, time
RETURN
Delay:
' Sub-rotina de espera
PAUSE time / 3
RETURN
Update_Display:
' Sub-rotina de atualização do display
Página - 181
IF index = 6 THEN index = 0
'
BAFG.CDE
LOOKUP index, [ %01000000,
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ], OUTH
index = index + 1
RETURN
Como Funciona LightMeter.bs2
As duas primeiras linhas do programa declararam variáveis. Não importa se essas
variáveis são utilizadas em sub-rotinas ou na rotina principal, é sempre melhor declarar
variáveis (e constantes) no início de seu programa.
Uma vez que esta é uma prática bastante comum, esta seção de código tem um nome,
"Declarações de variáveis". Este nome é mostrado no comentário à direita da primeira
declaração de variável.
index VAR Nib
time VAR Word
' Declaração de variáveis.
Muitos programas também têm coisas que precisam ser feitas uma vez no início do
programa. Definir todos os pinos de I/O de 7 segmentos como baixos e, em seguida,
torna-los saídas é um exemplo. Esta seção de um programa PBASIC também tem um
nome, "Inicialização"
OUTH = %00000000
DIRH = %11111111
' Inicializa display de 7 segmentos
O próximo segmento de código é chamado de rotina principal. A rotina principal chama
primeiro a sub-rotina Get_Rc_Time. Em seguida, ela chama a sub-rotina Delay e,
depois disso, ela chama a sub-rotina Update_Display. Lembre-se que o programa
passa por três sub-rotinas tão rápido quanto possível, repetidamente.
DO
GOSUB Delay
GOSUB Update_Display
LOOP
' Rotina principal
Todas as sub-rotinas são, normalmente, colocadas após a rotina principal. O nome da
primeira sub-rotina é Get_Rc_Time: e assume as medidas de RC-time do circuito do
fototransistor. Esta sub-rotina tem um comando PAUSE que carrega o capacitor. A
duração deste comando é pequena, porque ele só precisa fazer uma pausa longa o
suficiente para garantir que o capacitor esteja carregado. Note-se que o comando
RCTIME define o valor da variável time. Esta variável vai ser utilizada na segunda subrotina.
Get_Rc_Time:
HIGH 2
' Sub-rotinas
' Sub-rotina RC-time
Página - 182
PAUSE 3
RCTIME 2, 1, time
RETURN
O segundo nome da sub-rotina é Delay, e tudo que ela contém é PAUSE time / 3. O
comando PAUSE permite que o tempo de queda medido (quão brilhante é a luz) controle
o atraso ao ligar cada segmento de luz no mostrador giratório circular do LED de 7
segmentos. O valor a direita do operador de divisão / pode ser feito maior para uma
rotação mais rápida, em condições inferiores de luz, ou menor para retardar a exibição
das condições de luz mais brilhantes. Você também pode usar * para multiplicar a
variável time por um valor, em vez de dividir para fazer a exibição ficar muito mais
lenta, e para um controle mais preciso sobre a taxa, não se esqueça dos operadores */.
Mais informações sobre este operador na seção “Sua Vez”.
Delay:
PAUSE time / 3
RETURN
A terceira sub-rotina é chamada Update_Display. O comando LOOKUP nesta subrotina contém uma tabela com seis padrões de bits que são usados para criar o padrão
circular em torno do exterior do visor do LED de 7 segmentos. Ao adicionar 1 a
variável index cada vez que a sub-rotina é chamada, ele faz com que o padrão de bits na
próxima sequência seja colocado na OUTH. Existem apenas seis entradas na tabela
LOOKUP para os valores index de 0 a 5. O que acontece quando o valor do índice recebe
6? O comando PROC não sabe voltar automaticamente para a primeira entrada, mas você
pode usar uma instrução IF...THEN para corrigir esse problema. O comando IF
index = 6 THEN index = 0 redefine o valor do índice de 0 a cada vez que recebe
6. Ele também faz com que a sequência de padrões de bits colocados em OUTH repita
alternadamente. Este, por sua vez, faz com que o LED de 7 segmentos repita seu padrão
circular uma e outra vez.
Update_Display:
IF index = 6 THEN index = 0
'
BAFG.CDE
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ], OUTH
index = index + 1
RETURN
Sua Vez – Ajuste do Hardware e Software do Medidor
Há duas maneiras de alterar a sensibilidade do medidor. Primeiro, o "software", que é o
programa PBASIC, pode ser alterado para ajustar a velocidade. Como mencionado
anteriormente, dividindo a variável tempo na sub-rotina Delay comando PAUSE time / 3
por números maiores que 3 vai acelerar a exibição, e os números menores vão retardá-
Página - 183
la. Para realmente retardá-la, o tempo também pode ser multiplicado por valores com o
operador de multiplicação *, e para ajustá-los há o operador */.
Ao conectar os capacitores em paralelo, seus valores se somam. Então, se você conectar
um segundo capacitor de 0,01 μF ao lado do primeiro, como mostrado na Figura 7-14 e
na Figura 7-15, a capacitância será 0,02 μF. Com o dobro da capacidade, a queda de
medição para o mesmo nível de luz vai demorar o dobro do tempo.
 Ligue o segundo capacitor de 0,01 μF ao lado do primeiro na parte do sensor de
luz do circuito medidor de luz na Figura 7-14 e Figura 7- 15.
 Execute LightMeter.bs2 e observe o resultado.
Se as medições do tempo forem duas vezes maior, o teste padrão circular do LED de 7
segmentos deverá girar a metade da velocidade.
Figura 7-14
Dois capacitores de
0,01 μF em paralelo =
0,02 μF
Figura 7-15
Circuitos de medidor
de luz com dois
capacitores de 0,01
μF em paralelo
Em vez de metade da velocidade de um capacitor de 0,01 μF, que tal um com um
décimo da velocidade? Você pode fazer isso através da substituição dos dois capacitores
de 0,01 μF por um capacitor de 0,1 μF. Ele vai trabalhar bem em salas iluminadas, mas
provavelmente vai ser um pouco lento para a iluminação normal. Lembre-se que quando
você usa um capacitor que é dez vezes maior, a medição RC-time vai demorar dez vezes
mais tempo.
 Substitua os capacitores de 0,01 μF capacitores por um capacitor de 0,1 μF.
 Execute o programa e veja se ocorreu o efeito previsto.
 Antes de continuar, restaure o circuito para um capacitor de 0,01 em paralelo
com o fototransistor como mostrado na Figura 7-9 e Figura 7-10, começando na
página 176.
 Antes de continuar, teste seu circuito restaurado para verificar se ele funciona.
Página - 184
O que é melhor, ajustar o software ou o hardware? Você deve sempre tentar
usar o melhor dos dois mundos. Escolha um capacitor que lhe de as medições
mais precisas sobre a ampla gama de níveis de luz. Uma vez que seu hardware é
o melhor que pode ser, use o software para ajustar automaticamente o medidor de
luz para que ele funcione bem para o usuário sob as mais diversas condições. Isso
leva uma quantidade considerável de testes e refinamento, mas isso é tudo parte
do processo de elaboração do produto.
ATIVIDADE #5: SAÍDAS ON/OFF DO FOTOTRANSISTOR
Antes dos microcontroladores se tornarem comuns nos produtos, os fotoresistores foram
usados em circuitos que variavam em sua saída de tensão. Quando a tensão ficou aquém
do limite, indicando o anoitecer, outros circuitos no aparelho acenderam as luzes.
Quando a tensão ultrapassou o limite, indicando o dia, os outros circuitos no aparelho
apagaram as luzes. Este comportamento do interruptor de binário de luz pode ser
emulado com o mesmo BASIC Stamp e circuito de queda do RC, basta modificar o
programa PBASIC. Alternativamente, o circuito pode ser modificado para que ele envie
um 1 ou 0 para um pino de I/O de acordo com a quantidade de tensão fornecida ao pino,
semelhante à maneira como um botão de pressão faz. Nesta atividade, você vai tentar
essas duas abordagens.
Ajustando o Programa para Situações On / Off
O PhototransistorAnalogToBinary.bs2 pega a gama de medida do fototransistor e
compara-a ao ponto a meio caminho entre as medidas maiores e menores. Se a medida
estiver acima do ponto a meio caminho, ele exibe "Acenda a luz”; caso contrário, ele
exibe “Apague a luz”. O programa usa diretivas constantes para definir as maiores e as
menores medidas que o programa deve esperar do circuito do fototransistor.
valMax
valMin
CON
CON
4000
100
O programa também utiliza operadores MIN e MAX para garantir que os valores fiquem
dentro desses limites antes de usá-los para tomar qualquer decisão. Se o tempo é maior
do que valMax (4000 no programa de exemplo), a instrução define o tempo para
valMax = 4000. Da mesma forma, se o tempo é menor do que valMin (100 no
programa de exemplo), a instrução define o tempo para valMin = 100.
time = time MAX valMax MIN valMin
Uma declaração IF...THEN...ELSE converte o intervalo de valores analógicos
digitalizados em uma saída binária que assume a forma de mensagens de luz acesa ou
luz apagada.
IF time > (valMax - valMin) / 2 THEN
DEBUG CR, "Acenda a luz "
ELSE
DEBUG CR, "Apague a luz"
ENDIF
Página - 185
Para que este programa funcione corretamente, antes você tem que calibrar as condições
de iluminação da seguinte forma:
 Verifique se o circuito do fototransistor para se certificar de que tem apenas um
capacitor 0,01 μF (rotulado 103).
 Coloque o PhototransistorAnalogToBinary.bs2 no BASIC Stamp Editor.
Certifique-se de adicionar um espaço extra após o "z" na mensagem "Acenda a
luz ". Caso contrário, você vai ter um "z" fantasma da mensagem "Apague a
luz", que tem um caractere a mais nela.
 Carregue o programa para o BASIC Stamp.
 Assista ao DEBUG Terminal quando você aplicar as condições de iluminação
mais escuras e mais brilhantes que você deseja testar, e faça anotações dos
valores de tempo mínimos e máximos resultantes.
 Coloque esses valores em valMax e valMin na diretivas COM do programa.
Agora, seu programa está pronto para ser executados e testado.
 Carregue o programa modificado para o BASIC Stamp.
 Teste para verificar se as condições de iluminação fraca resultarão na mensagem
“Acenda a luz” e as condições de iluminação brilhante resultarão na mensagem
"Apague a luz".
' O que é um Microcontrolador - PhototransistorAnalogToBinary.bs2
' Mude a medida analógica digitalizada do Fototransistor para um
' resultado binário.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
CON
CON
4000
100
time
VAR
Word
PAUSE 1000
DO
HIGH 2
PAUSE 100
RCTIME 2, 1, time
DEBUG HOME, "time = ", DEC5 time
ELSE
ENDIF
Página - 186
LOOP
Sua Vez – Diferentes Limites para Claro e Escuro
Se você tentar incorporar o PhototransistorAnalogToBinary.bs2 em um sistema
automático de iluminação, ele terá um defeito potencial. Vamos dizer que está bastante
escuro lá fora para fazer a medição do tempo ficar aquém (valMax - valMin) / 2,
assim as luzes acendem. Mas se o sensor detectar luz, faria a medição ficar abaixo
(valMax - valMin) / 2, então a luz desligaria novamente. Este ciclo lightson/lights-off poderia se repetir rapidamente a noite toda!
A Figura 7-16 mostra como isso poderia funcionar em um gráfico. À medida que o nível
de luz cai, o valor das variáveis de tempo aumenta, e quando ultrapassa o limite, as
luzes automáticas acedem. Uma vez que o fototransistor detectar a luz que acabou de
acender, a medição da variável tempo cai para abaixo do limite, assim que as luzes
apagarem. Em seguida, o valor da variável tempo aumenta novamente, e ultrapassa o
limite, então as luzes acendem e a variável de tempo cai abaixo do limite novamente, e
assim por diante...
valMax
"Turn light on "
Figura 7-16
Oscilações
acima/abaixo do limite
(valMax - valMin) / 2
"Turn light off"
valMin
Uma solução para este problema consiste em adicionar uma segunda entrada, tal como
ilustrado na Figura 7-17. A entrada “Acenda a luz” só acende a luz depois que ficou
muito escuro, e a entrada “Apague a luz” só reacende a luz depois que ficou muito
claro. Com este sistema, a luz acende depois que alcançasse a área “Acenda a luz”. A
luz acesa tornou mais clara, assim o tempo caiu um pouco, mas desde que não caiu para
baixo após a entrada “Apague a luz”, nada mudou, e a luz ficará acesa como deveria. O
termo histerese é utilizado para descrever este tipo de sistema, que tem dois limites de
entradas diferentes que afetam a sua saída juntamente com uma zona de transição entre
elas.
valMax
"Turn light on "
(valMax - valMin) / 4 * 3
No transition
(valMax - valMin) / 4
Figura 7-17
Usando diferentes
limites de alta e baixa
para evitar oscilações
"Turn light off"
valMin
Você pode implementar este sistema de duas entradas em seu código PBASIC
modificando a declaração IF...THEN...ELSEIF PhotransistorAnalogToBinary.bs2 's.
Aqui está um exemplo:
Página - 187
IF time > (valMax - valMin) / 4 * 3 THEN
ELSEIF time < (valMax - valMin ) / 4 THEN
ENDIF
O primeiro bloco de código IF...THEN exibe “Acenda a luz ”, quando a variável
time armazena um valor que é mais do que ¾ do caminho para o maior valor do tempo
(luz mais baixa). O bloco de código ELSEIF exibe apenas “Apague a luz” quando a
variável tempo armazena um valor que é menos de ¼ do caminho acima do menor valor
do tempo (mais brilhante).
 Salve PhototransistorAnalogToBinary.bs2 como PhotransistorHysteresis.bs2.
 Antes de modificar PhotransistorHysteresis.bs2, teste-o para certificar-se se a
entrada existente funciona. Se a iluminação mudou, repita as etapas de
calibração valMin e valMax (antes do código de exemplo
PhototransistorAnalogToBinary.bs2).
 Substitua a declaração IF...ELSE...ENDIF do PhotransistorHysteresis.bs2 's
por IF...ENDIF...ELSEIF que acabamos de discutir.
 Carregue o PhotransistorHysteresis.bs2 para o BASIC Stamp.
 Teste e verifique se a entrada “Acenda a luz” está mais escura, e a entrada
“Apague a luz” está mais clara.
Se você adicionar um circuito de LED e modificar o código para que ele ligue e
desligue o LED, algumas coisas interessantes podem acontecer. Especialmente se você
colocar o LED próximo ao fototransistor, você ainda pode ver o comportamento ligado
e desligado quando fica escuro, mesmo com a histerese programada. Quão longe do
fototransistor o LED tem que estar para obter os dois limiares e evitar comportamento
on / off? Assumindo que valMin e valMax são as mesmas em ambos os programas, a
que distância o LED tem que estar para o PhototransistorAnalogToBinary.bs2 sem
modificações funcionar corretamente?
Página - 188
TTL Vs. Gatilho Schmitt
Seu pino de I/O do BASIC Stamp envia e recebe sinais usando a lógica
transistor-transistor (TTL). Como saída, o pino de I/O envia um sinal de 5 V de
alta ou 0 V de sinal de baixa. O lado esquerdo da Figura 7-18 mostra como o
pino de I/O comportando-se como uma entrada. O pino de I/O no registro IN
(IN0, IN1, IN2 etc.) armazena 1 se a tensão aplicada está acima de 1,4 V,
ou se está abaixo de 1,4 V. Estes são mostrados como Logic 1 e Logic 0 na
figura.
Um gatilho de Schmitt é um circuito representado pelo símbolo no centro da
Figura 7-18. O lado direito da Figura 7-18 mostra como um pino de I/O
configurado como entrada se comportaria se tivesse um circuito de disparo
Schmitt construído nele. O gatilhos de Schmitt tem histerese da mesma forma
que o código PBASIC com duas entradas tem. O valor de entrada armazenada
pelo registro INx do pino de I/O não muda de 0 a 1 até que a tensão de entrada
esteja acima de 4,25 V. Da mesma forma, não muda de 1 para 0 até que a tensão
de entrada passe abaixo de 0,75 V. O BASIC Stamp 2px tem um comando
PBASIC que permite que você configure seus pinos de entrada para Schmitt.
Figura 7-18 TTL Vs. Limites do Gatilho Schmitt e Símbolo
Limite TTL
Símbolo do Gatilho de
Schmitt
5V
Limite Gatilho
de Schmitt
5V
Logic 1
≈4.25 V
Logic 1
No Change
≈1.4 V
Logic 0
≈0.75 V
0V
0V
Logic 0
Ajustando o Circuito para Situações de On / Off
Como mencionado no Capítulo 5, Atividade #2, o limite de tensão para um pino de I/O
do BASIC Stamp é de 1,4 V. Quando um pino de I/O é definido como entrada, tensões
acima de 1,4 V aplicada ao pino I/O resultam em um binário 1 e tensões abaixo de 1,4 V
resultam em um binário 0. O nó Vo no circuito representado na figura 7-19 varia em
tensão com a luz. Este circuito pode ser ligado a um pino de I/O do BASIC Stamp, e
com pouca luz, a tensão vai passar abaixo do limiar de 1.4 V do BASIC Stamp e o
registro de entrada do pino de I/O vai armazenar 0. Em condições de luz brilhante, Vo
ultrapassa 1,4 V, e o registro de entrada do pino de I/O vai armazenar 1.
Figura 7-19
Saída de Tensão do
Circuito de Luz
+
V
–
=R
I
Página - 189
A razão pela qual a tensão Vo muda com os níveis de luz é devido a Lei de Ohm, que
indica que a tensão através de uma resistência (V na Figura 7-19) é igual à corrente que
passa através dessa resistência (I), multiplicada pela resistência do resistor (R).
V=I×R
Lembre-se que um fototransistor deixa passar mais corrente quando exposto a mais luz
e menos energia quando exposto a menos luz. Vamos dar uma olhada mais detalhada no
circuito de exemplo na Figura 7-19 e calcular a quantidade de corrente que o resistor
teria que passar para criar uma queda de 1,4 V sobre o resistor. Primeiro, sabemos que o
valor do resistor é de 10 kΩ, ou 10 000 Ω. Nós também sabemos que queremos que a
tensão seja igual a 1,4 V, por isso precisamos modificar a Lei de Ohm para resolver I.
Para fazer isso, divida ambos os lados da equação V = I × R por R, o que resulta em I =
V ÷ R. Em seguida, substitua os valores que você conhece (V = 1,4 V e R = 10 kΩ) e
resolver para I.
I
=
=
=
=
=
=
V÷R
1.4 V ÷ 10 kΩ
1.4 V ÷ 10,000 Ω
0.00014 V/Ω
0.00014 A
0.14 mA
Agora, se o transistor permitisse que por duas vezes mais corrente passasse por ele,
porque está mais brilhante, qual seria a tensão através do resistor? Por duas vezes a
corrente, I = 0,28 mA, e a resistência ainda é 10 kΩ, então agora estamos de volta para
resolver V da equação original V = I × R com I = 0,28 mA e R = 10 kΩ.
V
=
=
=
=
=
I×R
0.28 mA × 10 kΩ
0.00028 A × 10,000 Ω
2.8 AΩ
2.8 V
Com 2,8 V aplicada a um pino de I/O, o seu registro de entrada iria armazenar 1 desde
que 2,8 V esteja acima de 1,4 V da tensão de entrada do pino de I/O.
Sua Vez – Mais Cálculos
E se o fototransistor permitisse a metade da tensão da corrente de entrada (0,07 mA)
através do circuito, qual seria a voltagem através da resistência? Além disso, qual seria
o registro de entrada que o pino de I/O armazenaria?
Teste do Sensor Binário de Luz
O teste do circuito do sensor binário de luz é muito parecido com o teste do circuito de
botão do Capítulo 3. Quando o circuito é ligado a um pino de I/O, a tensão será ou
acima ou abaixo do limiar de 1,4V do pino de I/O do BASIC Stamp o que resultará em
um 1 ou um 0, que poderá ser exibido com o DEBUG Terminal.
Página - 190
Peças para o Sensor de Luz Analógico para Binário
(1) Fototransistor
(1) Resistor – 4.7 kΩ (amarelo-violeta-vermelho)
(1) Resistor – 100 kΩ (marrom-preto-amarelo)
(2) Fios
Circuito para o Sensor de Luz Analógico para Binário
Com o circuito mostrado na Figura 7-20, o circuito se comporta como uma sombra
controlada pelo botão. A sombra resulta em in2 = 0, luz brilhante resulta em in2 =
1. Tenha em mente que um pino de I/O configurado como entrada não afeta o circuito
que monitora porque não aumenta ou reduz qualquer corrente. Isto faz com que tanto o
pino de I/O e quanto o resistor de 220 Ω fiquem essencialmente invisíveis para o
circuito. Assim, os resultados de tensão de circuito dos nossos cálculos a partir da
secção anterior sejam os mesmos com ou sem o resistor de 220 Ω e pino de I/O ligados.
Figura 7-20: Esquema e Diagrama de fiação para circuito do sensor de luz
analógico para binário ligado a um pino de I / O
Código De Teste Para O Sensor De Luz Analógico Para Binário
TestBinaryPhototransistor.bs2 é uma versão modificada do ReadPushbuttonState.bs2 do
Capítulo 3, Atividade #2. Além de ajustar as observações, há uma mudança para o
programa atual que é a linha DEBUG? IN2, que era DEBUG? IN3 no programa de
exemplo de botão, porque o botão de pressão foi ligado a P3 em vez de P2.
 Reveja o Capítulo 3, Atividade #2 (página 55).
 Use o TestBinaryPhototransistor.bs2 abaixo para verificar se a luz brilhante do
fototransistor resulta em 1, enquanto a escuridão resulta em 0. Você pode
precisar de uma luz bem forte. Se a sua iluminação interna ainda resultar em 0,
tente luz do sol ou use uma lanterna bem de perto. Um recurso alternativo para
baixa iluminação é substituir o resistor de 10 kΩ por um resistor de 100 kΩ.
Página - 191
' O que é um Microcontrolador - TestBinaryPhototransistor.bs2
' Verifique o estado da saída binária do circuito do fototransistor a
' cada ¼ de segundo.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN2
PAUSE 250
LOOP
Testando Resistências em Série
Dê uma olhada nos cálculos V = I × R cálculos anteriormente realizados nesta atividade.
Se a resistência em série é de 1/5, o valor da tensão através da resistência será de 1/5
para as mesmas condições de iluminação. Da mesma forma, uma resistência que é 10
vezes maior do que isso fará com que a tensão seja dez vezes maior.
O que isso faz para o seu circuito? Um resistor de 100 kΩ no lugar de um resistor de 10
kΩ significa que o fototransistor só tem de conduzir a corrente 1/10 para cruzar o limiar
de 1,4V do pino de I/O do BASIC Stamp, o que significa que ele leva menos luz para
desencadear um binário 1 na entrada do pino de I/O e se fazer notar. Isto pode funcionar
como um sensor num ambiente que é supostamente escuro, uma vez que será sensível a
pequenas quantidades de luz. Em contraste, 1/5 do valor da resistência significa que o
fototransistor tem que conduzir 5 vezes corrente para obter a tensão através da
resistência e atravessar o limiar de 1,4 V, que por sua vez significa levar mais luz para
acionar o binário 1 no registro de entrada do pino de I/O. Assim, este circuito seria
melhor para detectar luz mais forte.
 Experimente os resistores de 2 kΩ, 4,7 kΩ, 10 kΩ e 100 kΩ e compare as
alterações na sensibilidade à luz com cada resistor.
Sua Vez – Indicador de Baixo Nível de Luz
 Escolha um resistor com a melhor resposta a 1/0 a baixos níveis de luz em sua
área de trabalho.
 Adicione o LED apresentado no Capítulo 3, Atividade #3, para o circuito limiar
do fototransistor.
 Coloque algo entre o LED e o fototransistor para que o fototransistor não possa
"ver" o LED. Isto elimina o potencial de interferência entre os dois dispositivos.
 Modifique o programa para que ele faça piscar a luz quando a sombra é
projetada sobre o fototransistor.
ATIVIDADE #6: PARA DIVERSÃO - MEÇA A LUZ EXTERNA COM UM LED
Como mencionado anteriormente, o circuito introduzido na Atividade #1 é projetado
para medições de luz no interior. E se o seu aplicativo precisar fazer as medições de luz
ao ar livre? Uma opção seria encontrar um fototransistor que gerasse menos corrente
para a mesma quantidade de luz. Outra opção seria a utilização de um dos outros
sensores de luz do kit “O que é um Microcontrolador”. Eles estão disfarçados de LEDs
e executam muito bem as medições de luz mais intensas.
Página - 192
Quando a corrente elétrica passa através do LED, que emite luz, o que você acha que
acontece quando a luz brilha em um LED? Sim, de fato, ela pode causar uma corrente
elétrica que flua através de um circuito. Figura 7-21 mostra um circuito de LED para
detectar os níveis de luz ao ar livre e em outras áreas com luz mais intensa. Enquanto o
fototransistor permite que a corrente passe é aplicada uma pressão elétrica fornecida
(voltagem), o LED é mais parecido com um pequeno painel solar que cria a sua própria
tensão para fornecer a corrente. Na medida em que a deterioração do circuito RC é a
causa, o resultado com um LED é praticamente o mesmo. O LED conduz mais corrente
e drena a carga do capacitor mais rapidamente, com mais luz, conduz menos corrente e
drena mais lentamente com menos luz.
Yello
Figura 7-21
Esquema para o LED
no circuito do sensor
de luz RC-Time
Porque o LED é ligado para trás? No Capítulo 2, o ânodo do LED foi ligado
ao resistor de 220Ω e o cátodo foi ligado ao terra. Esse circuito fez o LED emitir
luz como resultado da passagem de corrente elétrica através do LED quando a
tensão foi aplicada ao circuito. Quando a luz está brilhando sobre o LED, cria
uma pequena tensão que gera uma pequena corrente no sentido oposto. Assim, o
LED tem que ser ligado para trás de modo que ele conduza a corrente e permita
que o capacitor drene através dele para as medições de queda de RC.
Peças do Sensor de Luz do LED
(1) LED – amarelo
(1) LED – verde
(1) LED – vermelho
(1) Fio
Circuito do Sensor de Luz de LED
Uma diferença importante entre o LED e o fototransistor é que o LED conduz muito
menos corrente para a mesma quantidade de luz, por isso é preciso muita luz para o
LED conduzir corrente suficiente para descarregar o capacitor de forma suficientemente
rápida para a medição RCTIME. Lembre-se que a máxima medição de tempo que
RCTIME pode medir é 65535 × 2 µs ≈ 131 ms. Assim, para boas medidas de queda de
RC com o BASIC Stamp, é necessário um capacitor muito menor. Na verdade, o
circuito trabalha melhor sem qualquer capacitor externo. O LED tem uma pequena
quantidade de capacitância dentro dele, chamada capacitância de junção, e os clipes de
metal que prendem os fios que você pluga na placa de ensaio também têm capacitância.
Esta é a razão de um capacitor ser duas placas metálicas separadas por um isolador
chamado dielétrico. Assim, dois clipes de metal dentro do protoboard, separados por
plástico e ar, formam um capacitor. A combinação de junção capacitância do LED e
capacitância do clip do protoboard faz com que você possa usar o LED sem capacitor
externo, como mostrado na Figura 7-22.
Página - 193
 Construa o circuito mostrado na Figura 7-22 e na Figura 7-23, usando o LED
amarelo. Certifique-se de observar a polaridade representada nas figuras!

Figura 7-202
Esquema do Circuito
de LED RCTIME
Local plano e mais
curto
do
pino
cátodo
Figura 7-23
Diagrama de Fiação
do Circuito RC Time
do LED.
Pino ânodo mais longo
Testando o Sensor de Luz de LED com Código
O circuito de detecção de luz com LED pode ser testado em uma sala bem iluminada ou
ao ar livre durante o dia. Em uma sala mal iluminada os tempos de medição são
susceptíveis de exceder 65535, caso em que RCTIME vai armazenar a zero na variável
resultado. Na maioria das situações, o código é o mesmo código de Atividade #1,
TestPhototransistor.bs2.
Se você estiver em uma sala bem iluminada tente o seguinte:
 Execute TestPhototransistor.bs2 da Atividade #1.
 Aponte o LED para a fonte de luz mais brilhante, colocando sua placa em
direção a ela.
 Gradualmente, leve a placa para longe da fonte de luz mais brilhante na sala, os
valores indicados pelo DEBUG Terminal devem ficar maiores conforme a luz
ficar mais fraca.
Se você tem uma lanterna brilhante, tente o seguinte:
 Elimine fontes de luz mais brilhantes, como a luz do sol entrando pelas janelas.
 Ligue a lanterna e aponte para o topo do LED, a uma distância de cerca de 10
cm. Se possível, desligue algumas das luzes fluorescentes de forma que os níveis
de luz ambiente fiquem baixos.
Página - 194
 Veja as medições que o DEBUG Terminal exibe conforme você aumenta
gradualmente a distância da lanterna do topo do LED. Isto permitirá que você
determine a distância entre a lanterna e o LED.
Se você está em uma sala só com luzes fluorescentes e sem fontes de luz brilhantes:
 Elimine as fontes de luz mais brilhantes, como a luz do sol nas janelas. Se
possível, desligue algumas das luzes fluorescentes de modo que os níveis de luz
fiquem baixos.
 Aponte o LED para o seu computador como se ele tivesse quase tocando-o e
veja se as medidas permitem distinguir entre as várias cores da tela.
Testes ao ar livre:




Execute StoreLightMeasurementsInEeprom.bs2 da Atividade #2.
Desligue o cabo de programação e leve sua placa para fora.
Aponte sua placa de forma que o LED esteja apontando diretamente para o sol.
Pressione e solte o botão Reset da sua placa para reiniciar o programa de registro
de dados.
 Aos poucos rode sua placa longe do sol por mais de 2 ½ minutos.
 Leve sua placa de volta para dentro e volte a ligar ao PC.
 Execute ReadLightMeasurementsFromEeprom.bs2 e examine as medições de
luz. Desde que você, gradualmente, levou o LED para longe do sol, as medições
sucessivas devem ficar maiores.
Sua Vez – O Seu BASIC Stamp Consegue Diferenciar Vermelho de Verde?
Na Figura 7-2, verde está no centro do espectro, e vermelho está a direita. Se você
baixar a versão colorida em PDF deste livro do site www.parallax.com, você pode
colocar o verde e, em seguida, o LED vermelho contra a tela e registra medições de luz
em todo o espectro de cores. Então, comparando as menores medições com cada LED,
você pode detectar que seu LED é colocado contra verde ou vermelho na tela.
 Comece o circuito de detecção de luz com um LED verde na Figura 7-22 e





Figura 7-23.
Baixe a versão em PDF “O que é um microcontrolador do site
www.parallax.com/go/WAM.
Exiba o espectro de cores mostrado na Figura 7-2 (página 162) em seu monitor,
e dê um zoom na imagem.
Com o programa TestPhototransistor.bs2 exibindo medições no DEBUG
Terminal, segure a placa de modo que a cúpula do LED verde esteja apontando
diretamente para o monitor, todo o espectro de cores. Para melhores resultados,
a cúpula do LED deve apenas estar mal tocando o monitor, e os níveis de luz na
sala devem ser bastante baixos.
Deslize o LED verde lentamente ao longo da barra do espectro exibido no
monitor e observe a cor que resultou na menor medida.
Repita com o LED vermelho. Será que o LED vermelho relatou medições mais
baixas sobre o vermelho, enquanto o LED verde relatou medições menores sobre
o verde?
Página - 195
As menores medições do LED vermelho devem ocorrer ao longo da cor vermelha na
tela, e as menores medições para o LED verde devem ocorrer ao longo do verde na tela.
SUMÁRIO
Este capítulo introduziu sensores de luz e descreveu como eles são utilizados em uma
variedade de produtos. Sensores de luz diferentes detectam diferentes tipos de luz, e
suas folhas de dados descrevem sua sensibilidade relativa ao comprimento das ondas de
luz. Este capítulo focou no fototransistor, um dispositivo que controla a corrente através
de seus terminais coletores e emissores pela quantidade de luz que brilha no seu
terminal de base. Porque a luz pode controlar a quantidade de corrente que conduz um
fototransistor, a técnica para medir a posição do botão de um potenciômetro no Capítulo
5 circuito RC também funciona para medir a luz que brilha em um fototransistor. O
tempo que leva para um capacitor perder sua carga resulta de uma medição RC Time no
fototransistor que fornece um número que corresponde ao brilho da luz sobre o
fototransistor.
Os registros de dados, armazenando medições de luz na parte não utilizada a memória
de programa EEPROM do módulo BASIC Stamp também foi introduzido. Os
comandos WRITE e READ foram usados para armazenar valores e para recuperar
valores da EEPROM do módulo BASIC Stamp. O volume de números envolvidos no
registro de dados pode ser difícil de analisar, mas colocando os dados em um gráfico
fica mais fácil de ver padrões, tendências e eventos. Os dados registrados podem ser
transferidos para planilhas eletrônicas convencionais e gráficas, alguns utilitários
gráficos podem até substituir o DEBUG Terminal, e podem traçar os valores do BASIC
Stamp em um gráfico, ao invés de exibi-los como texto. Um exemplo de aplicação do
medidor de luz também foi desenvolvido, demonstrando como medições de luz podem
ser utilizadas para controlar outro processo, neste caso, a taxa de um padrão circular
exibida por um LED de 7 segmentos. Estas aplicações também são usadas nas subrotinas para realizar três empregos diferentes para a aplicação do medidor de luz.
O BASIC Stamp pode ser programado para converter uma medida de tempo de queda
RC para um valor binário com declarações IF...THEN. Além disso, o programa pode
tomar uma série de medidas de queda de RC e aplicar histerese com uma entrada
"Acenda a luz" que está na área escura das medidas e um entrada "Apague a luz" que
está na faixa mais leve. Isto pode ajudar a prevenir oscilações de ligar / desligar que
possam ocorrer quando o sensor relatar escuridão e o dispositivo ligar uma luz na área.
Sem histerese, o dispositivo pode sentir esta luz, desligar e repetir este ciclo
indefinidamente.
Uma abordagem de hardware para detecção de ligar/desligar a luz é a aplicação de
energia em série para o fototransistor com um resistor. De acordo com a Lei de Ohm, a
quantidade de corrente que o fototransistor conduz afeta a tensão sobre o resistor. Esta
tensão variável pode ser conectada a um pino de I/O, e resultará num binário 1, se a
tensão for superior a limiar de 1,4 V do pino de I/O, ou um binário 0 se for abaixo do
limiar.
O LED (diodo emissor de luz) que emite luz quando a corrente passa por ele também se
comporta como um pequeno painel solar quando a luz incide sobre ele, gerando uma
Página - 196
pequena tensão que por sua vez pode levar corrente elétrica para os circuitos. As
correntes que o LED gera são suficientemente pequenas para que uma combinação da
própria capacitância de junção do LED e a capacitância inerente aos grampos dentro da
protoboard forneçam capacitância suficiente para um circuito RC com nenhuma queda
do resistor externo. Enquanto o fototransistor do kit “O que é um Microcontrolador?”
tem melhor desempenho dentro de casa, o LED é excelente para medições de luz mais
intensa e ao ar livre.
Questões
1. Quais são alguns exemplos de aplicações de iluminação automática que
dependem de sensores de luz ambiente?
2. Quais são alguns exemplos de produtos que respondem às mudanças no brilho
da luz ambiente?
3. Qual a faixa de comprimento de onda que o espectro de luz visível está situada?
4. Quais são os nomes dos terminais do fototransistor, e qual deles controla a
quantidade de corrente que o dispositivo permite passar?
5. O que significa EEPROM?
6. Quantos bytes podem armazenar a EEPROM do módulo BASIC Stamp?
Quantos bits ele pode armazenar?
7. Qual comando você usa para armazenar um valor em uma EEPROM? Qual
comando que você usa para recuperar um valor de uma EEPROM? Qual delas
requer uma variável?
8. O que é um rótulo?
9. O que é uma sub-rotina?
10. Que comando é usado para chamar uma sub-rotina? Qual comando é usado para
terminar uma sub-rotina?
Exercícios
1. Desenhe o esquema de um circuito RC-time de fototransistor conectado a P5.
2. Modifique TestPhototransistor.bs2 de modo que ele funcione em um circuito
ligado a P5, em vez de P2.
3. Explique como você poderia modificar LightMeter.bs2 para que o teste de
padrão circular exibido pelo display de LED de 7 segmentos vá na direção
oposta.
Projetos
1. Faça um pequeno protótipo de um sistema que automaticamente feche as
cortinas quando fica muito brilhante e abra novamente quando fica menos
brilhante. Use o servo para um atuador mecânico. Dica: Para obter o código,
você pode adicionar dois comandos de controle do servo para
PhototransistorAnalogToBinary.bs2, e mudar o comando PAUSE 100 para
PAUSE 1. Certifique-se de seguir as instruções do texto para calibrar as
condições de luz na área antes de testar.
2. Como crédito extra, melhore a sua solução para o projeto 1, incorporando as
modificações de histerese discutidas na Atividade #5.
Página - 197
Soluções
Q1.Os faróis dos carros, postes e luzes de segurança ao ar livre que ligam
automaticamente quando está escuro.
Q2.Monitores portáteis e câmeras com exposição automática.
Q3.380 nm a 750 nm de acordo com a Figura 7-2, na página 162.
Q4.Coletor, base e emissor. A base controla a quantidade de corrente passa para o
coletor e volta para fora do emissor.
Q5.Electrically Erasable Programmable Read-Only Memory.
Q6.2048 bytes. 2048 x 8 = 16,384 bits.
Q7.Para armazenar um valor - WRITE, Para recuperar um valor - READ, o comando
READ requer uma variável.
Q8.A etiqueta é um nome que pode ser usado como um marcador em um programa
PBASIC.
Q9.Uma sub-rotina é um pequeno segmento de código que faz um determinado
trabalho.
Q10.
Chamando: GOSUB; terminando: RETURN
E1. Esquema baseado na Figura 7-4, na página 164, com P2 mudou para P5.
E2. As modificações necessárias são muito semelhantes as descritas na página 164.
DO
HIGH 5
PAUSE 100
RCTIME 5, 1, time
DEBUG HOME, "time =
LOOP
", DEC5 time
E3. Para ir em direção oposta, os padrões devem ser exibidos na ordem inversa. Isso
pode ser feito mudando os padrões em ao redor da instrução PROC, ou
invertendo a ordem em que se olhou para cima. Aqui estão duas soluções feitas
com sub-rotinas alternativas UPDATE_DISPLAY.
Solução 1
Solução 2
Update_Display:
IF index = 6 THEN index =
0
'
BAFG.CDE
LOOKUP index, [
%01000000,
Index = 5 '<<Add after Index
variable
Update_Display:
'
BAFG.CDE
%10000000,
Página - 198
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ],
%00000100,
%00000010,
%00000001,
%00100000
], OUTH
index = index + 1
RETURN
OUTH
IF (index = 0) THEN
index = 5
ELSE
index = index - 1
ENDIF
RETURN
P1. Fototransistor da Figura 7- 4 na página 164, esquema do servo para a sua placa
do Capítulo 4, Atividade # 1.
' O que é um Microcontrolador - Ch07Prj01_Blinds_Control.bs2
' Controla a posição do servo usando luz.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
time
CON
CON
VAR
4000
100
Word
PAUSE 1000
DO
HIGH 2
PAUSE 1
RCTIME 2, 1, time
DEBUG HOME, "time =
' PAUSE 100 -> PAUSE 1
", DEC5 time
DEBUG CR, "Abre cortina "
PULSOUT 14, 500
ELSE
DEBUG CR, "Fecha cortina "
PULSOUT 14, 1000
ENDIF
' Modifique
' Adicione
' Modifique
' Adicione
LOOP
P2. Funcionalidade de Histerese adicionada como crédito extra:
' O que é um Microcontrolador ' Ch07Prj02_Blinds_Control_Extra.bs2
' Controla a posição do servo usando luz e incluindo histerese.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
CON
CON
4000
100
Página - 199
time
VAR
Word
PAUSE 1000
DO
HIGH 2
PAUSE 1
RCTIME 2, 1, time
DEBUG HOME, "time =
' PAUSE 100 -> PAUSE 1
", DEC5 time
IF time > (valMax - valMin) / 4 * 3 THEN
DEBUG CR, "Abre cortina "
PULSOUT 14, 500
ELSEIF time < (valMax - valMin ) / 4 THEN
DEBUG CR, "Fecha cortina"
PULSOUT 14, 1000
ENDIF
LOOP
' Modifique
' Adicione
' Modifique
' Adicione
Página - 200
Capítulo 8: Frequência e Som
O SEU DIA E BIPS ELETRÔNICOS
Aqui estão alguns exemplos de bips que você pode ouvir durante um dia normal: O
forno de micro-ondas emite um bip sonoro quando sua comida está pronta. O telefone
celular tem diferentes tons de bips que se assemelham a músicas para chamar sua
atenção quando alguém te liga. O caixa eletrônico emite um bip para lembrá-lo de não
esquecer seu cartão. Os bips da caixa registradora da loja deixam o contador saber qual
código de barras de um item do supermercado foi lido pelo digitalizador. Muitas
calculadoras emitem bips quando as teclas são pressionadas de forma errada. Você pode
ter começado o dia com um bip de seu despertador.
MICROCONTROLADORES, ALTO-FALANTES E SINAIS ON/OFF
Praticamente todos os bips eletrônicos que você ouve durante a sua rotina diária são
feitos por microcontroladores conectados a alto-falantes. O microcontrolador cria esses
bips enviando sinais rápidos de alta/baixa para vários tipos de alto-falantes. A taxa
desses sinais de alta/baixa é chamada de frequência, e determina o tom ou a intensidade
do bip. Cada vez que um sinal de alta/baixa se repete, ele é chamado de um ciclo.
Muitas vezes você vai ver o número de ciclos por segundo referidos como hertz, e é
abreviado Hz. Por exemplo, uma das frequências mais comuns de bips que as máquinas
de ajuda usam para chamar sua atenção é de 2 kHz. Isso significa que os sinais de
alta/baixa se repetem 2 000 vezes por segundo.
APRESENTANDO O SPEAKER PIEZOELÉTRICO
Nesta atividade, você vai experimentar enviar uma variedade de sinais para um altofalante comum, pequeno e barato chamado piezoelétrico. Um alto-falante piezoelétrico
é comumente referido como um alto-falante ou uma campainha piezo. Seu símbolo
esquemático e desenho da peça são mostrados na Figura 8- 1.
Figura 8-1
Desenho da peça e símbolo
esquemático do alto-falante
piezoelétrico.
ATIVIDADE #1: CRIANDO E TESTANDO O ALTO-FALANTE
Nesta atividade, você vai construir e testar o circuito de alto-falante piezoelétrico.
Peças do Circuito do Alto-Falante
(1) Alto-falante piezoelétrico
(2) Fios
Página - 201
Construindo o Circuito do Alto-Falante Piezoelétrico
O terminal negativo do alto-falante piezoelétrico deve ser ligado a Vss e o terminal
positivo deve ser ligado a um pino de I/O. O BASIC Stamp, então, será programado
para enviar sinais de alta/baixa para o terminal positivo do falante piezoelétrico.
 Se o seu alto-falante piezo tiver um adesivo sobre ele, basta removê-lo (não há
necessidade de lavar).
Vdd
Vin
Vss
X3
P9
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Figura 8-1
Esquema e Diagrama
de Fiação do Circuito
do Alto-Falante
Piezoelétrico
Como Funciona o Circuito do Alto-Falante Piezoelétrico
Quando uma corda de violão vibra, ela provoca mudanças na pressão do ar. Essas
mudanças na pressão do ar são o que seu ouvido detecta como um tom. Quanto mais
rápidas as alterações na pressão do ar, mais alto é o tom, e quanto mais lentas, mais
baixo. O elemento dentro de caixa de plástico do alto-falante piezo é chamado um
elemento piezoelétrico. Quando sinais de alta / baixa são aplicados ao terminal positivo
do alto-falante, o elemento piezoelétrico vibra provocando mudanças na pressão do ar,
da mesma maneira que uma corda de violão faz. Tal como acontece com a corda da
guitarra, seu ouvido detecta as alterações na pressão do ar causadas pelo alto-falante
piezoelétrico, que normalmente soa como um bip ou um tom.
Programando o Controle do Alto-Falante.
O comando FREQOUT é uma maneira conveniente de enviar sinais de alta/baixa a um
alto-falante para obter um som. O manual do BASIC Stamp mostra uma sintaxe do
comando como esta:
FREQOUT Pin, Duration, Freq1 {, Freq2}
Tal como acontece com a maioria dos outros comandos usados neste livro, Pin é um
valor que você pode usar para escolher qual pino de I/O usar no BASIC Stamp. O
argumento Duration é um valor que diz ao comando FREQOUT quanto tempo o tom deve
soar em milésimos de segundos. O argumento Freq1 é usado para definir a frequência
do tom, em hertz. Existe um argumento opcional Freq2 que pode ser utilizado para
reproduzir dois tons diferentes ao mesmo tempo.
Esta é a sintaxe para o envio de um tom do pino de I/O P9 que dura 1,5 segundos e tem
uma frequência de 2 kHz:
Página - 202
FREQOUT 9, 1500, 2000
Programa de Exemplo: TestPiezoWithFreqout.bs2
Este programa de exemplo envia o tom de 2 kHz para o alto-falante no pino de I/O P9
por 1,5 segundos. Você pode usar o DEBUG Terminal para ver quando o alto-falante
deveria estar bipando e quando deveria parar.
 Coloque e execute TestPiezoWithFreqout.bs2.
 Verifique se o alto-falante emite um tom claramente audível durante o tempo em
que o DEBUG Terminal exibe a mensagem "Enviando o tom...” (“Tone
sending...”).
' O que é um Microcontrolador - TestPiezoWithFreqout.bs2
' Envie um tom ao piezospeaker utilizando o comando FREQOUT.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
DEBUG "Enviando tom...", CR
FREQOUT 9, 1500, 2000
DEBUG "Tom enviado."
Sua Vez – Regular Frequência e Duração




Salve TestPiezoWithFreqout.bs2 com um nome diferente.
Tente alguns valores diferentes para os argumentos Duration e Freq1.
Após cada alteração, execute o programa e tome nota do efeito.
No momento em que o argumento Freq1 ficar maior, pode a intensidade do tom
ir para cima ou para baixo? Experimente valores de 1500, 2000, 2500 e 3000
para responder a esta pergunta.
ATIVIDADE #2: SONS DE AÇÃO
Muitos brinquedos contêm microcontroladores, que são usados para fazer “sons de
ação”. Sons de ação tendem a se envolver rapidamente mudando a frequência
desempenhada pelo alto-falante. Você também pode obter alguns efeitos interessantes
executando dois tons diferentes ao mesmo tempo, utilizando argumento opcional Freq2
do comando FREQOUT. Esta atividade apresenta ambas as técnicas.
Programando Sons de Ação
Os sons de ação de eletrodomésticos têm três componentes diferentes:
1. Pausa
2. Duração
3. Frequência
A pausa é o tempo entre os tons, e você pode usar o comando PAUSE para criá-la. A
duração é a quantidade de tempo que um tom dura e você pode configurá-la usando o
Página - 203
argumento Duration do comando FREQOUT. A frequência determina a intensidade do
tom. Quanto mais elevada for a frequência, mais elevado o tom, quanto menos elevada
for frequência, menos elevado é o tom. Isto é, naturalmente, determinado pelo
argumento Freq1 do comando FREQOUT.
Exemplo de Programa: ActionTones.bs2
ActionTones.bs2 demonstra algumas combinações diferentes de PAUSE, Duration e
Frequency. A primeira sequência de tons soa semelhante a um alarme eletrônico de
relógio. O segundo, pode-se dizer, soa algo semelhante a um robô em um filme de
ficção. O terceiro é mais o tipo de efeito sonoro que você pode ouvir em um velho jogo
de vídeo.
 Coloque e execute ActionTones.bs2.
' O que é um Microcontrolador - ActionTones.bs2
' Demonstra como diferentes combinações de pausa, duração e frequência
' podem ser utilizadas para criar diferntes efeitos sonoros.
'{$STAMP BS2}
'{$PBASIC 2.5}
duration
frequency
VAR
VAR
Word
Word
PAUSE 1000
DEBUG "Alarme...",
PAUSE 100
FREQOUT 9, 500,
PAUSE 500
FREQOUT 9, 500,
PAUSE 500
FREQOUT 9, 500,
PAUSE 500
FREQOUT 9, 500,
PAUSE 500
CR
DEBUG "Imitando um
PAUSE 100
FREQOUT 9, 100,
FREQOUT 9, 200,
FREQOUT 9, 140,
FREQOUT 9, 30,
PAUSE 500
robô...", CR
1500
1500
1500
1500
2800
2400
4200
2000
DEBUG "Hiperespaço...", CR
PAUSE 100
FOR duration = 15 TO 1 STEP 1
FOR frequency = 2000 TO 2500 STEP 20
FREQOUT 9, duration, frequency
NEXT
NEXT
DEBUG "Pronto!", CR
END
Página - 204
Como Funciona ActionTones.bs2
A rotina de “alarme” soa como um despertador. Esta rotina toca sons em uma
frequência fixa de 1,5 kHz, com duração de 0,5 s com atrasos fixos entre os tons de 0,5
s. A rotina de “imitando um robô" usa várias frequências por breves períodos.
A rotina de “hiperespaço” não atrasa, mas a frequência e a duração podem variar.
Usando o loop FOR...NEXT para mudar rapidamente as variáveis de frequência e
duração, você pode obter alguns efeitos sonoros interessantes. Quando um loop
FOR...NEXT é executado dentro de outro, é chamado de um loop assentado. Aqui está
como o loop assentado FOR...NEXT mostrado abaixo funciona. A variável de duração
começa a 15, então o loop FOR frequency ... assume e envia frequências de 2.000, em
seguida 2.020, depois 2040, e assim por diante, até 2500 através do alto-falante piezo.
Quando o loop FOR frequency ... estiver concluído, o loop FOR duration... apenas repetiu
um de seus 15 passos. Por isso, subtrai 1 do valor de duração e repete o loop FOR
frequency...novamente.
FOR duration = 15 TO 1
NEXT
NEXT
Programa de Exemplo: NestedLoops.bs2
Para entender melhor como os loops assentados FOR...NEXT trabalham, o
NestedLoops.bs2 usa o comando DEBUG para mostrar o valor de uma versão muito
menos complicada do loop assentado utilizado em ActionTones.bs2.
 Coloque e execute NestedLoops.bs2.
 Examine a saída do DEBUG Terminal e verifique como a duração e a frequência
das variáveis mudam a cada vez através do loop.
' O que é um Microcontrolador - NestedLoops.bs2
' Demonstra como o loop assentado em ActionTones.bs2 funciona.
'{$STAMP BS2}
'{$PBASIC 2.5}
duration
frequency
VAR
VAR
Word
Word
PAUSE 1000
DEBUG "Duration
"--------
Frequency", CR,
---------", CR
DEBUG "
" , DEC5 duration,
"
", DEC5 frequency, CR
NEXT
DEBUG CR
NEXT
END
Página - 205
Sua Vez – Mais Efeitos Sonoros
Existe uma infinidade de maneiras de modificar ActionTones.bs2 para obter diferentes
combinações de som. Aqui está uma das modificações da rotina “Hiperespaço”:
DEBUG "Salto de hiperespaço...", CR
NEXT
NEXT
NEXT
NEXT
 Salve
o seu programa de exemplo com o seguinte
ActionTonesYourTurn.bs2.
 Divirta-se com esta e outras modificações de sua própria criação.
nome
Duas Frequências de Uma Só Vez
Você pode tocar duas frequências ao mesmo tempo. Lembre-se da sintaxe do comando
FREQOUT de Atividade #1:
FREQOUT Pin, Duration, Freq1 {, Freq2}
Você pode usar o argumento opcional Freq2 para tocar duas frequências com um único
comando FREQOUT. Por exemplo, você pode tocar 2 kHz e 3 kHz assim:
FREQOUT 9, 1000, 2000, 3000
Cada tom do teclado de discagem é também um exemplo de duas
frequências combinadas. Nas telecomunicações, é chamada de DTMF (Dual
Tone Multi Frequency). Há também um comando chamado PBASIC DTMFOUT
que é projetado apenas para o envio de sons de telefone. Para exemplos, procure
este comando no Manual do BASIC Stamp ou na Ajuda.
Exemplo de Programa: PairsOfTones.bs2
Este programa de exemplo demonstra a diferença no tom que você recebe quando você
toca 2 e 3 kHz juntos. Ele também demonstra um fenômeno interessante que ocorre
quando você adiciona duas ondas sonoras que estão muito próximas na frequência.
Quando você toca 2000 Hz e 2001 Hz, ao mesmo tempo, o tom vai aumentar e diminuir
uma vez por segundo (a uma frequência de 1 Hz). Se você tocar 2000 Hz a 2002 Hz, ele
vai aumentar e diminuir duas vezes por segundo (2 Hz), e assim por diante.
Página - 206
Ritmo é quando dois tons de frequência muito próximas são tocados juntos
fazendo com que o som que se ouve aumente e diminua. A frequência do
aumento e da diminuição é a diferença entre as duas frequências. Se a diferença é
de 1 Hz, o tom aumenta e diminui em um 1 Hz. Se a diferença for de 2 Hz, o tom
vai aumentar e diminuir em 2 Hz.
As variações da pressão de ar feitas pelo alto-falante piezoelétrico são
chamadas de ondas sonoras. Quando o tom é mais alto, as variações na pressão
do ar causadas pelas frequências são adicionadas umas as outras (chamada de
sobreposição). Quando o tom está bastante silencioso, as variações na pressão do
ar vão sendo canceladas mutuamente (chamada de interferência).
 Coloque e execute PairsOfTones.bs2.
 Mantenha um olho no DEBUG Terminal enquanto os tons vão sendo
reproduzidos e observe os diferentes efeitos
diferentes tons.
provenientes da mixagem dos
' O que é um Microcontrolador - PairsOfTones.bs2
' Demonstra o que pode acontecer quando você mistyra dois tons.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
DEBUG "Frequency = 2000", CR
FREQOUT 9, 4000, 2000
DEBUG "Frequency = 3000", CR
FREQOUT 9, 4000, 3000
DEBUG "Frequency = 2000 + 3000", CR
FREQOUT 9, 4000, 2000, 3000
FREQOUT 9, 4000, 2000, 2001
FREQOUT 9, 4000, 2000, 2002
FREQOUT 9, 4000, 2000, 2003
FREQOUT 9, 4000, 2000, 2005
FREQOUT 9, 4000, 2000, 2010
DEBUG "Pronto!", CR
END
Sua Vez – Condensando o Código
PairsOfTones.bs2 foi escrito para demonstrar algumas coisas interessantes que podem
acontecer quando você toca duas frequências diferentes ao mesmo tempo usando o
Página - 207
argumento opcional Freq2 do comando FREQOUT. No entanto, isto é extremamente
ineficiente.
 Modifique PairsOfTones.bs2 para que ele percorra todos os argumentos Freq2
que vão de 2001 a 2005 usando uma variável de texto e um loop.
ATIVIDADE #3: NOTAS MUSICAIS E CANÇÕES SIMPLES
A Figura 8-3 mostra as 25 teclas da parte direita do teclado de um piano. Ela também
mostra as frequências em que cada corda dentro do piano vibra quando acionadas pela
tecla.
Figura 8-3: Parte direita de um piano, suas teclas e frequências.
As teclas e as suas notas correspondentes são rotuladas de C6 a C8. Estas teclas são
separadas em grupos de 12, compostos por sete teclas brancas e cinco teclas pretas. A
sequência de notas se repete a cada 12 teclas. As notas de uma mesma letra são
relacionadas pela frequência, dobrando a cada oitava acima. Por exemplo, C7 é o dobro
da frequência de C6, e C8 é o dobro da frequência de C7. Da mesma forma, se você for
uma oitava abaixo, a frequência será a metade do valor, por exemplo, A6 é a metade da
frequência de A7.
Se você já ouviu um cantor solfejar as notas "Dó Ré Mi Fá Sol Lá Si Dó", ele está
tentando combinar as notas recebidas ao “bater” as teclas brancas do teclado do piano.
Essas teclas brancas são chamadas de teclas naturais, e o nome "oitava" refere-se a
duplicação da frequência de cada oitava. A tecla preta em um piano pode ser chamada
de sustenido ou bemol. Por exemplo, a tecla preta entre as teclas C e D é chamada CSustenido (C#) ou D-Bemol (Db). Uma tecla é chamada de sustenido ou bemol
conforme a música que está sendo executada, mas as regras para isso é melhor deixar
para as aulas de música.
Página - 208
Pesquisa na Internet sobre "escala musical": Ao usar as palavras "escala
musical", você vai encontrar informações fascinantes sobre história, física e
psicologia do assunto. A 12 nota em uma oitava é a principal escala da música
ocidental. Outras culturas utilizam escalas que contêm 2 a 35 notas por oitava.
Método de Afinação: O teclado na Figura 8-3 utiliza um método de afinação
chamado temperamento igual. As frequências são determinadas usando uma nota
de referência, em seguida, multiplicando-a por 2 (n/12) para valores de n = 1, 2, 3
etc. Por exemplo, você pode ter a frequência de A6, e multiplicar por 2 (1/12)
para obter a frequência de A6 #. Multiplique por 2 (2/12) para obter a frequência
de B6, e assim por diante. Aqui está um exemplo de cálculo da frequência de B6
usando A6 como uma frequência de referência:
A frequência de A6 é 1760
2(2/12) = 1.1224
1760 X 1.224 = 1975.5
1975.5 é a frequência de B6
Programando as Notas Musicais
O comando FREQOUT também é útil para notas musicais. A programação do BASIC
Stamp para reproduzir músicas usando um piezospeaker envolve seguir uma série de
regras usadas na reprodução de músicas usando qualquer outro instrumento musical.
Estas regras se aplicam aos mesmos elementos que foram usados para fazer os efeitos
sonoros: frequência, duração e pausa. Este próximo programa de exemplo reproduz
algumas das frequências de notas musicais no piezospeaker, cada uma com uma
duração de meio segundo.
Exemplo de Programa: DoReMiFaSolLaTiDo.bs2
 Coloque e execute DoReMiFaSolLaTiDo.bs2
' O que é um Microcontrolador - DoReMiFaSolLaTiDo.bs2
' Envia uma oitava de meio segundo usando um alto-falante
' piezoelétrico.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
'Solfege
Tone
Note
DEBUG "Do...", CR:
FREQOUT 9,500,1047
' C6
DEBUG "Re...", CR:
FREQOUT 9,500,1175
' D6
DEBUG "Mi...", CR:
FREQOUT 9,500,1319
' E6
DEBUG "Fa...", CR:
FREQOUT 9,500,1396
' F6
DEBUG "Sol..", CR:
FREQOUT 9,500,1568
' G6
DEBUG "La...", CR:
FREQOUT 9,500,1760
' A6
DEBUG "Ti...", CR:
FREQOUT 9,500,1976
' B6
DEBUG "Do...", CR:
FREQOUT 9,500,2093
' C7
Página - 209
END
Sua Vez – Notas Sustenido/Bemol
 Use as frequências mostradas na Figura 8-3 para adicionar
cinco notas
sustenidas/bemois para DoReMiFaSolLaTiDo.bs2
 Modifique o programa para que ele reproduza a próxima oitava acima. Dica:
Salve você mesmo a digitação e use apenas o operador * 2 após cada
argumento Freq1. Por exemplo, FREQOUT 9, 500, 1175 * 2 vai multiplicar
D6 por 2 para lhe dar D7, que é a nota D na sétima oitava.
 Armazenando e recuperarando seqüências de notas musicais.
Uma boa maneira de salvar as notas musicais é armazená-las usando EEPROM do
módulo BASIC Stamp. Embora você possa usar muitos comandos WRITE para fazer
isso, a melhor maneira é usar a diretiva DATA. Esta é a sintaxe para a diretiva DATA:
{Symbol} DATA {Word} DataItem {, {Word} DataItem, … }
Aqui está um exemplo de como utilizar a diretiva DATA para armazenar os caracteres
que correspondam às notas musicais.
Notes DATA "C","C","G","G","A","A","G"
Você pode usar o comando READ para acessar esses caracteres. A letra "C" está
localizada no endereço Notes + 0, e uma segunda letra "C" está localizada em Notes
+ 1. Em seguida uma letra "G" em Notes + 2, e assim por diante. Por exemplo, se
você deseja carregar a última letra "G" em uma variável byte chamada noteLetter, use o
comando:
READ Notes + 6, noteLetter
Você também pode armazenar listas de números usando a diretiva DATA. Os valores de
frequência e duração, que o BASIC Stamp usa para as notas musicais, precisam ser
armazenados em variáveis de texto, porque eles são geralmente maiores do que 255.
Aqui está como fazer isso com uma diretiva DATA:
Frequencies DATA Word 2093, Word 2093, Word 3136, Word 3136,
Word 3520, Word 3520, Word 3136
Uma vez que cada um desses valores ocupa dois bytes, acessá-los com o comando
READ é diferente de acessar caracteres. O primeiro 2093 está em Frequencies + 0,
mas o segundo 2093 está localizado em Frequencies + 2. O primeiro 3136 está
localizado em Frequencies + 4, e o segundo 3136 está localizado em
Frequencies + 6.
Os valores em Frequencies da diretiva DATA correspondem com as notas
musicais em Notes da diretiva DATA.
Aqui está um loop FOR ... NEXT, que coloca notes DATA em uma variável chamada
noteLetter, e coloca Frequencies DATA em uma variável chamada noteFreq.
Página - 210
FOR index = 0 to 6
READ Notes + index, noteLetter
READ Frequencies + (index * 2), Word noteFreq
DEBUG noteLetter, " ", DEC noteFreq, CR
NEXT
O que o (índex * 2) faz?
Cada valor armazenado em Frequencies da diretiva DATA leva uma palavra (dois
bytes), enquanto cada caractere em Notes da diretiva DATA leva apenas um byte.
O valor do índice aumenta em um cada vez através do loop FOR...NEXT. Isso
é bom para acessar os caracteres de notas usando o comando READ Notes +
index, noteLetter. O problema é que, para cada byte em Notes, a
variável index precisa apontar duas vezes mais para baixo na lista
Frequencies. O comando READ Frequencies + (index *
2), Word noteFreq, cuida disso.
O próximo programa de exemplo armazena notas e durações usando DATA, e usa o
comando FREQOUT para reproduzir cada frequência da nota por uma duração específica.
O resultado é as primeiras notas da canção infantil “Brilha, Brilha Estrelinha” ("Twinkle
Twinkle Little Star").
A "Canção do alfabeto", usada por crianças para memorizar os "ABCs" usa as
mesmas notas de “Brilha, Brilha Estrelinha” ("Twinkle Twinkle Little Star").
Programa de Exemplo: TwinkleTwinkle.bs2
Este programa de exemplo demonstra como usar a diretiva DATA para armazenar as
listas e como usar o comando READ para acessar os valores nas listas.
 Coloque e execute TwinkleTwinkle.bs2
 Verifique se as notas soam como as da
música “Brilha, Brilha Estrelinha”
(“Twinkle Twinkle Little Star”).
 Use o DEBUG Terminal para verificar se funcionou como esperado.
' O que é um Microcontrolador - TwinkleTwinkle.bs2
' Toque as sete primeiras notas de “Brilha, Brilha Estrelinha”.
'{$STAMP BS2}
'{$PBASIC 2.5}
Notes
DATA
"C","C","G","G","A","A","G"
Frequencies
DATA
Word 2093, Word 2093, Word 3136, Word 3136,
Word 3520, Word 3520, Word 3136
Durations
DATA
Word 500, Word 500, Word 1000
index
noteLetter
VAR
VAR
Nib
Byte
Página - 211
noteFreq
noteDuration
VAR
VAR
Word
Word
PAUSE 1000
DEBUG
"Nota
"----
Duração
-------
Frequência", CR,
----------", CR
FOR index = 0 TO 6
DEBUG "
", noteLetter
READ Durations + (index * 2), Word noteDuration
DEBUG "
", DEC4 noteDuration
READ Frequencies + (index * 2), Word noteFreq
DEBUG "
", DEC4 noteFreq, CR
FREQOUT 9, noteDuration, noteFreq
NEXT
END
Sua Vez – Adicionando e Reproduzindo Mais Notas
Este programa reproduziu as sete primeiras notas de Brilha, Brilha Estrelinha. As
palavras são "Bri-lha bri-lha es-tre-linha." A próxima frase da canção "Como eu quero
saber o que você é" e suas notas são F, F, E, E, D, D, C . Tal como com a primeira frase,
a última nota é reproduzida duas vezes, tão longas quanto às outras. Para adicionar esta
frase para a música do TwinkleTwinkle.bs2, você vai precisar expandir cada diretiva
DATA adequadamente. Não se esqueça de mudar o loop FOR...NEXT para que ele vá
de 0-13 em vez de 0-6.
 Modifique TwinkleTwinkle.bs2 para que ele reproduza as duas primeiras frases
da canção, e não somente a primeira.
ATIVIDADE #4: MÚSICA COM MICROCONTROLADOR
As durações das notas não são registradas na partitura em termos de milésimos de
segundos. Em vez disso, são descritas como uma semibreve, mínima, semínima,
colcheia, semicolcheia e trigésima segunda nota. Tal como o nome sugere uma nota
dura metade do tempo de uma semibreve. A semínima dura um quarto do tempo de uma
nota inteira, e assim por diante. Quanto tempo é uma semibreve? Depende da peça de
música que está sendo executada. Uma peça pode ser tocada a um ritmo que faz com
que uma semibreve dure por quatro segundos, outra peça pode ter uma semibreve por
dois segundos, e ainda outra pode ter uma duração diferente.
Pausa é o tempo entre as notas quando nenhum som é reproduzido. Períodos de pausa
também são medidos com semibreve, mínima, semínima, colcheia, semicolcheia e
trigésima segunda.
Página - 212
Mais sobre música com microcontrolador: Após completar esta atividade,
você estará pronto para aprender a escrever um código musical em PBASIC a
partir da partitura. Consulte o tutorial reproduzindo a partitura com o
Piezospeaker ( Playing Sheet Music with the Piezospeaker) e o manual em vídeo
que acompanha em www.parallax.com/go/WAM.
Um Sistema Melhor para Armazenar e Recuperar Músicas
Você pode escrever programas que armazenam duas vezes mais músicas em seu BASIC
Stamp usando bytes em vez de palavras em suas diretivas DATA. Você também pode
modificar o seu programa para tornar mais fácil a leitura das notas musicais usando
algumas das convenções musicais mais comuns para as notas e durações. Esta atividade
começará com a introdução de como armazenar informações musicais de uma forma
que se relaciona com os conceitos de notas, durações e pausas. O ritmo também é
introduzido, e ele vai ser revisto na próxima atividade.
Aqui está uma das diretivas DATA que armazena as notas musicais e as durações para o
próximo programa de exemplo. Quando tocada, ela deve parecer com a canção "Frère
Jacques". Somente os caracteres de notas são armazenados na diretiva Notes DATA
porque os comandos LOOKUP e LOOKDOWN serão usados para combinar as letras para as
suas correspondentes frequências.
Notes
DATA
"C","D","E","C","C","D","E","C","E","F",
"G","E","F","G","Q"
Durations
WholeNote
DATA
CON
4,
4,
4,
4,
2,
4,
4,
4,
4,
4,
2
4,
4,
4,
2000
O primeiro número da diretiva Durations DATA diz ao programa por quanto tempo a
primeira nota na diretiva notes DATA deve durar. A segunda é para a duração da
segunda nota, e assim por diante. As durações não estão mais em termos de milésimos
de segundos. Em vez disso, eles são números muito menores que podem ser
armazenados em bytes, por isso não há prefixo Word na diretiva DATA. Comparando
com o armazenamento dos valores em termos de milésimos de segundos, esses
números estão mais próximos dos relacionados com as partituras.
Aqui está uma lista do que cada duração significa.
• 1 – semibreve
• 2 – mínima
• 4 – semínima
• 8 – colcheia
• 16 – semicolcheia
• 32 – trigésima segunda nota
Depois que cada valor for lido a partir de diretiva Durations DATA ele é dividido
pelo valor da semibreve para obter a diretiva Durations utilizada no comando
FREQOUT. A quantidade de tempo de cada nota dura depende do ritmo da música. Um
ritmo mais rápido significa que cada nota dura menos tempo, enquanto um ritmo mais
Página - 213
lento significa que cada nota dura mais tempo. Uma vez que todas as durações de nota
são frações de uma semibreve, você pode usar a duração de uma nota inteira para definir
o ritmo.
O que significa o "Q" em Notes DATA? O "Q" é para sair, e DO
UNTIL...LOOP verifica a existência de um "Q" de cada vez através do loop e
se repetirá até que ele seja encontrado.
Como faço para executar uma pausa? Você pode inserir uma pausa entre as
notas através da inserção de um "P". Na seção Sua Vez você tem as primeiras
notas da 5ª Sinfonia de Beethoven, com uma pausa.
Como faço para executar sustenidos/bemóis? NotesAndDurations.bs2 tem
valores nas suas tabelas de referência para sustenidos/bemóis. Para tocar um
bemol você usará a nota minúscula. Por exemplo, se você quiser tocar B-bemol,
use "b" em vez de "B". Lembre-se que esta é a mesma frequência para Asustenido.
Exemplo de Programa: NotesAndDurations.bs2
 Coloque e execute NotesAndDurations.bs2.
 Como é o som?
' O que é um Microcontrolador - NotesAndDurations.bs2
' Toque as primeiras notas de Frere Jacques.
'{$STAMP BS2}
'{$PBASIC 2.5}
Notes
DATA
"C","D","E","C","C","D","E","C","E","F",
"G","E","F","G","Q"
Durations
DATA
WholeNote
CON
2000
index
offset
VAR
VAR
Byte
Nib
noteLetter
noteFreq
noteDuration
VAR
VAR
VAR
Byte
Word
Word
4,
2,
4,
4,
4,
4,
4,
2
4,
4,
4,
4,
4,
DO UNTIL noteLetter = "Q"
LOOKDOWN noteLetter, [
LOOKUP offset,
"A",
"D",
"G",
"b",
"e",
"a",
"B",
"E",
"P",
"C",
"F",
"Q"
"d",
"g",
], offset
[ 1760, 1865, 1976, 2093, 2217,
2349, 2489, 2637, 2794, 2960,
3136, 3322,
0,
0
], noteFreq
READ Durations + index, noteDuration
4,
Página - 214
noteDuration = WholeNote / noteDuration
index = index + 1
LOOP
END
Como Funciona NotesAndDurations.bs2
Notes e as diretivas Durations DATA foram discutidas anteriomente no programa.
Estas diretivas combinadas com a constante WholeNote são usadas para armazenar
todos os dados musicais utilizados pelo programa.
As declarações para as cinco variáveis usadas no programa são mostradas abaixo.
Mesmo que um loop FOR...NEXT não seja mais usado para acessar os dados, ainda
deve haver uma variável (index) para manter o controle de qual DATA de entrada está
sendo lida em Notes e Durations. A variável de deslocamento é usada nos comandos
LOOKDOWN e LOOKUP para selecionar um determinado valor. A variável noteLetter
armazena um caractere acessado pelo comando READ. Os comandos LOOKUP e
LOOKDOWN são usados para converter este caractere em um valor de frequência. Este
valor é armazenado na variável noteFreq e é usado como o argumento Freq1 do
comando FREQOUT. A variável noteDuration é usada em um comando READ para
receber um valor a partir de Durations DATA. É também utilizada para calcular o
argumento Duration para o comando FREQOUT.
index
offset
VAR
VAR
Byte
Nib
noteLetter
noteFreq
noteDuration
VAR
VAR
VAR
Byte
Word
Word
O loop principal continua a execução até que a letra "Q" seja lida a partir das Notes
DATA.
Um comando READ recebe um caractere a partir de Notes DATA e o armazena na
variável noteLetter. A variável noteLetter é então utilizada em um comando
LOOKDOWN para definir o valor da variável de deslocamento. Lembre-se que o offset
armazena 1 se "b" for detectado, um 2 se "B" for detectado, um 3 se "C" for detectado, e
assim por diante. Este valor de deslocamento é então utilizado em um comando LOOKUP
para descobrir qual deveria ser o valor da variável noteFreq. Se o deslocamento é 1,
noteFreq será 1865, se o deslocamento é 2, noteFreq será 1976, se 3, noteFreq
será 2093, e assim por diante.
LOOKDOWN noteLetter, [
"A",
"b",
"B",
"C",
"d",
Página - 215
"D",
"G",
LOOKUP offset,
"e",
"a",
"E",
"P",
"F", "g",
"Q" ], offset
[ 1760, 1865, 1976, 2093, 2217,
2349, 2489, 2637, 2794, 2960,
3136, 3322,
0,
0 ], noteFreq
A frequência da nota foi determinada, mas a duração ainda tem que ser. O comando
READ usa o valor do índice para colocar um valor a partir de Durations DATA em
noteDuration.
Então, noteDuration é definido igual a constante WholeNote dividida por
noteDuration. Se noteDuration começar como 4 a partir de um comando READ,
será 2000 ÷ 4 = 500. Se noteDuration para 8, será 2000 ÷ 8 = 250.
Agora que noteDuration e noteFreq já estão determinados, o comando FREQOUT
reproduz a nota.
Cada vez através do loop principal, o valor index será aumentado em um. Quando o
loop principal retornar ao início, a primeira coisa que o programa fará é ler a nota
seguinte, usando a variável index.
index = index + 1
LOOP
Sua Vez – Experiências com Ritmo e uma Música Diferente
A duração de cada nota está relacionada ao ritmo. Você pode alterar o ritmo, ajustando
a constante WholeNote. Se você aumentar para 2250, o ritmo vai diminuir, e a música
será mais lenta. Se você diminuir a 1750, o ritmo vai aumentar e a música será mais
rápida.
 Salve NotesAndDurations.bs2 sob o nome NotesAndDurationsYourTurn.bs2.
 Modifique o ritmo de NotesAndDurationsYourTurn.bs2 ajustando o valor de
WholeNote. Experimente valores de 1500, 1750, 2000 e 2250.
 Execute novamente o programa depois de cada modificação, e decida qual deles
soa melhor.
A inserção de dados musicais é muito mais fácil quando tudo que você tem a fazer é
gravar notas e durações. Aqui estão as primeiras oito notas da Quinta Sinfonia de
Beethoven.
Notes
Durations
DATA
DATA
WholeNote CON
"G","G","G","e","P","F","F","F","D","Q"
8,
2000
8,
8,
2,
8,
8,
8,
8,
2
Página - 216
 Salve o programa modificado como Beethoven'sFifth.bs2.
 Substitua Notes as diretivas Durations DATA e a declaração constante
WholeNote pelo código acima.
 Execute o programa. Soa familiar?
Adicionando Recursos Musicais
O programa de exemplo que você finalizou introduziu notas, durações e pausas. Foi
também usada a duração de semibreves para determinar o ritmo. Aqui estão mais três
recursos que podem ser adicionados a um programa de reprodução de música.
•
•
•
Toque notas "pontilhadas"
Determine a duração de uma semibreve a partir do ritmo.
Toque as notas uma oitava acima.
O termo pontilhado refere-se a um ponto usado em partituras para indicar que o tempo
de duração de uma nota deverá ser uma vez e meia maior que sua duração normal. Por
exemplo, uma semínima pontilhada deve durar uma semínima e uma colcheia. A
mínima pontilhada dura uma mínima mais a duração de uma semínima. Você pode
adicionar uma tabela de dados que armazena notas pontilhadas ou não. Neste exemplo,
um zero significa que não há um ponto enquanto um significa que existe um ponto.
Dots
DATA
0,
0,
0, 0, 0, 0, 1,
0, 0, 0, 1, 0
0,
0,
0,
0,
Os programas de reprodução de música expressam o ritmo de uma canção em
batimentos por minuto. Isto é o mesmo que dizer semínimas por minuto.
BeatsPerMin
CON
200
A Figura 8-4 é uma repetição da Figura 8-3 da página 207. Ela mostra as sextas e
sétimas oitavas no teclado de piano. Estas são as duas oitavas em que o som fica mais
claro quando desempenhado pelo piezospeaker. Aqui está um exemplo de uma diretiva
DATA que você vai usar na sua seção Sua Vez para tocar as notas uma oitava acima
usando a diretiva Notes DATA.
Octaves
DATA
6,
7,
6,
6,
6,
6,
6,
6,
6
6,
6,
6,
7,
6,
Página - 217
Figura 8-4: Teclas de piano à direita e suas frequências
Exemplo de Programa: MusicWithMoreFeatures.bs2
Este programa exemplo reproduz as primeiras notas de "Ele é um bom companheiro".
Todas as notas vêm da mesma (sétima) oitava, mas algumas das notas são pontilhadas.
Na seção Sua Vez, você vai tentar um exemplo que usa notas de mais de uma oitava, e
notas pontilhadas.
 Coloque e execute MusicWithMoreFeatures.bs2.
 Conte as notas e veja se você pode ouvir as notas pontilhadas de 1 ½ de duração.
 Escute também as notas em sétima oitava. Tente alterar uma dessas notas para
sexta oitava. A mudança na forma como a música soa é muito drástica.
' O que é um Microcontrolador - MusicWithMoreFeatures.bs2
' Toca o início de “Ele é um bom companheiro”.
'{$STAMP BS2}
'{$PBASIC 2.5}
Notes
DATA
"C","E","E","E","D","E","F","E","E","D","D",
"D","C","D","E","C","Q"
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7
4, 2, 4, 4, 4, 4, 2, 2, 4, 2, 4,
4, 4, 4, 2, 2
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 0
Octaves
DATA
Durations
DATA
Dots
DATA
BeatsPerMin
CON
320
index
offset
VAR
VAR
Byte
Nib
Página - 218
noteLetter
noteFreq
noteDuration
noteOctave
noteDot
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
Nib
Bit
wholeNote
VAR
Word
wholeNote = 60000 / BeatsPerMin * 4
LOOKDOWN noteLetter,
LOOKUP offset,
[ "C",
"F",
"b",
"d",
"g",
"B",
"D",
"G",
"P",
"e",
"a",
"Q"
"E",
"A",
], offset
[ 4186, 4435, 4699, 4978, 5274,
5588, 5920, 6272, 6645, 7040,
7459, 7902,
0,
0
], noteFreq
READ Octaves + index, noteOctave
noteOctave = 8 - noteOctave
noteFreq = noteFreq / (DCD noteOctave)
READ Dots + index, noteDot
IF noteDot = 1 THEN noteDuration = noteDuration * 3 / 2
index = index + 1
LOOP
END
Como Funciona MusicWithMoreFeatures.bs2
Abaixo estão os dados musicais para a canção inteira. Para cada nota na diretiva Notes
DATA, há uma entrada correspondente nas diretivas Octaves, Notes, Durations e
Dots DATA. Por exemplo, a primeira nota é uma nota C na sétima oitava, é uma
semínima e não é pontilhada. Aqui está outro exemplo: a segunda a partir da última nota
(não incluindo o "Q") é uma nota E, na sétima oitava. É uma mínima, e é pontilhada. Há
também uma constante BeatsPerMin que define o ritmo para a música.
Notes
DATA
"C","E","E","E","D","E","F","E","E","D","D",
"D","C","D","E","C","Q"
Octaves
DATA
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7
Durations DATA
4, 2, 4, 4, 4, 4, 2, 2, 4, 2, 4,
4, 4, 4, 2, 2
Dots
DATA
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 0
BeatsPerMin
CON
320
Página - 219
No programa do exemplo anterior, a semíbreve foi uma constante. Desta vez, é uma
variável que vai manter a duração da semínima em ms. Depois que este valor for
calculado, a semibreve será usada para determinar todas as outras durações das notas,
assim como no programa anterior. As variáveis index, offset, noteLetter e
noteDuration também são usadas da mesma maneira que estavam no programa
anterior. A variável noteFreq é tratada um pouco diferente já que agora ela tem de ser
ajustada dependendo da oitava nota que está sendo executada. As variáveis
noteOctave e noteDot foram adicionadas para lidar com as características de uma
oitava e ponto.
wholeNote
VAR
Word
index
offset
VAR
VAR
Byte
Nib
noteLetter
noteFreq
noteDuration
noteOctave
noteDot
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
Nib
Bit
A variável wholeNote é calculada usando BeatsPerMin. O ritmo da música é
definido em batimentos por minuto, e o programa tem que dividir BeatsPerMin em
60000 ms, em seguida, multiplicar por 4. O resultado é o valor correto para uma
semibreve.
wholeNote = 60000 / BeatsPerMin * 4
O cálculo é feito da esquerda para a direita. No cálculo wholeNote =
60000 / beatsPerMin * 4, o BASIC Stamp primeiro calcula 60000
/ beatsPerMin. Em seguida, ele multiplica esse resultado por 4.
Para um grupo de operações podem ser usados parênteses. Se você quiser
dividir quatro em beatsPerMin, primeiro você tem que fazer isso:
wholeNote = 60000 / (beatsPerMin * 4)
É o mesmo que o do programa anterior:
LOOKDOWN noteLetter,
[ "C",
"F",
"b",
"d",
"g",
"B",
"D",
"G",
"P",
"e",
"a",
"Q"
"E",
"A",
], offset
Agora que as oitavas estão misturadas a parte do código que estabelece a frequência da
nota mudou. A tabela de valores do comando LOOKUP contém as frequências das notas a
partir das oitavas da oitava. Estes valores podem ser divididos por um, se você quiser
Página - 220
tocar notas oitavas na oitava, com 2 se você quiser tocar notas na sétima oitava, com 4
se você quiser tocar notas na sexta oitava e com 8 se você quiser tocar as notas na quinta
oitava. A divisão acontece em seguida. Tudo o que esse comando LOOKUP faz é colocar
uma nota a partir da oitava na oitava na variável noteFreq.
LOOKUP offset,
[ 4186, 4435, 4699, 4978, 5274,
5588, 5920, 6272, 6645, 7040,
7459, 7902,
0,
0 ], noteFreq
Aqui está como a variável noteFreq é ajustada para a oitava correta. Primeiro, o
comando READ pega o valor da oitava armazenada nas Octaves DATA. Este poderia
ser um valor entre 5 e 8.
READ Octaves + index, noteOctave
Dependendo da oitava, queremos dividir noteFreq por 1, 2, 4 ou 8. Isso significa que
o objetivo é realmente dividir por 20 = 1, 21 = 2, 22 = 4, ou 23 = 8. A declaração abaixo
pega o valor de noteOctave, que pode ser um valor entre 5 e 8, e subtrai esse valor a
partir de 8. Se noteOctave era 8 agora é 0. Se noteOctave era 7 agora é 1. Se
noteOctave era 6 agora é 2, e se noteOctave era 5 agora é 3.
noteOctave = 8 – noteOctave
Agora, noteOctave é um valor que pode ser usado como um expoente de 2, mas como
se elevar 2 a uma potência em PBASIC? Uma resposta é a utilização do operador. DCD
0 é 1, DCD 1 é 2, DCD 2 é 4 e DCD 3 é 8. Dividir noteFreq por DCD noteOctave
significa que você está dividindo por 1, 2, 4 ou 8, que divide noteFreq abaixo do valor
correto. O resultado final é que noteFreq está definido para a oitava correta. Você
usará o DEBUG Terminal na seção Sua Vez para dar uma olhada em como isso
funciona.
Como vou saber usar o operador DCD? Continue aprendendo e praticando.
Toda vez que você ver um novo comando, operador ou qualquer outra palavrachave usada em um exemplo, procure-o no manual do BASIC Stamp. Leia mais
sobre isso, e tente usá-lo em um programa do seu próprio projeto.
Adquira o hábito de ler periodicamente o manual do BASIC Stamp e tente os
programas de exemplo curtos. Essa é a melhor maneira de se familiarizar com os
vários comandos e operadores e como eles funcionam. Ao fazer essas coisas,
você vai desenvolver o hábito de sempre adicionar à lista de programação
ferramentas que você pode usar para resolver os problemas.
As duas primeiras linhas de código para determinar a duração da nota usa o mesmo
código do programa de exemplo anterior. Agora, no entanto, toda a nota pode ser
pontilhada, o que significa que a duração pode ter que ser multiplicada por 1,5. Um
comando READ é utilizado para acessar valores armazenados na EEPROM pela diretiva
Dots DATA. Uma IF...THEN é usada para multiplicar por 3 e dividir por dois sempre
que o valor da variável noteDot for 1.
Página - 221
Cálculo com números inteiros. O BASIC Stamp não processa automaticamente
um número como 1,5. Ao realizar o cálculo, ele só funciona com inteiros: ..., -5, 4, -3, -2, -1, 0, 1, 2, 3, ... A melhor solução para multiplicar por 1,5 é multiplicar
por 3/2 . Primeiro, multiplique por três e, em seguida, divida por 2.
Há muitas maneiras de programar o BASIC Stamp para lidar com valores
fracionários. Você pode programar o BASIC Stamp para usar números inteiros
para descobrir a parte fracionária de um número. Isto é introduzido no Guia
Básico Analógico e Digital do Etudante (Basic Analog and Digital Student
Guide). Há também dois operadores que fazem valores fracionários ficarem mais
fáceis de se usar, eles são: ** e */. Isto é explicado detalhadamente em
Sensores Aplicados do Guia do Estudante (Applied Sensors Student Guide) no
manual do BASIC Stamp.
O restante deste exemplo de programa funciona da mesma maneira que no programa de
exemplo anterior:
index = index + 1
LOOP
END
Sua Vez – Execução de uma Canção com Mais de uma Oitava
O MusicWithMoreFeatures.bs2 fez uso de pausas, mas pemaneceu em uma oitava. A
música “Leve-me ao jogo de bola” (“Take Me Out to the Ball Game”) abaixo tem a
maioria de suas notas na sexta oitava. Há duas notas na sétima oitava, e elas fazem uma
grande diferença na maneira como soam.
 Salve uma cópia do programa como MusicWithMoreFeaturesYourTurn.bs2.
 Modifique o programa, substituindo as quatro diretivas de dados e uma
declaração constante com estas:
Notes
DATA
"C","C","A","G","E","G","D","P","C","C","A",
"G","E","G","Q"
Octaves
DATA
6, 7, 6, 6, 6, 6, 6, 6, 6, 7, 6,
6, 6, 6
Durations
DATA
2, 4, 4, 4, 4, 2, 2, 4, 2, 4, 4,
4, 4, 2
Dots
DATA
0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0,
0, 0, 1
BeatsPerMin
CON
240
 Execute o programa e verifique se ele soa bem.
Página - 222
Essas duas notas na sétima oitava são essenciais para fazer uma boa melodia. É
interessante ouvir o que acontece se os 7 valores são alterados para 6.
 Tente alterar os dois valores em 7 na diretiva Octaves DATA para que fiquem
6. Lembre-se que isso fará com um som estranho seja emitido em “Leve-me
para o jogo de bola” ( “Take Me out to the Ball Game”).
 Execute o programa e ouça os efeitos errados das oitavas na música.
 Altere os dados das oitavas de volta para seu estado original.
 Execute o programa novamente e ouça para ver se soa correto.
ATIVIDADE #5: TOQUES COM RTTTL
Telefones celulares mais antigos usavam toques com um piezospeaker. Os toques eram
baixados da web em um computador, e em seguida, carregados a partir do computador
para o microcontrolador do telefone celular. Na época, uma das formas mais utilizadas
para compor, gravar e postar toques foi a que apresentou trechos de texto com
caracteres que descreviam cada nota da canção. Aqui está um exemplo de como as
primeiras notas da 5ª de Beethoven aparece em um desses textos:
Beethoven5:d=8,o=7,b=125:g,g,g,2d#,p,f,f,f,2d
Este formato de armazenamento de dados musicais é chamado RTTTL, que significa
“Linguagem de Tom de Toque para Transferência de Texto” (Ringing Tone Text
Transfer Language). A grande coisa sobre os ficheiros RTTTL é que na época eles
foram amplamente compartilhados através da Web. Muitos sites tinham arquivos
RTTTL disponíveis para download gratuito. Havia também programas gratuitos que
podiam ser usados para compor e emular esses arquivos, bem como enviá-los para seu
telefone celular. A especificação RTTTL ainda é publicada online. O Apêndice C
resume como um arquivo RTTTL armazena notas, durações, pausas, ritmo, e notas
pontilhadas.
Esta atividade introduz algumas técnicas de programação PBASIC que podem ser
utilizadas para reconhecer diferentes elementos de texto. A capacidade de reconhecer
diferentes caracteres ou grupos de caracteres e agir com base no que os caracteres
contêm são extremamente úteis. Na verdade, é a chave para a conversão de um toque
em formato RTTTL (como a 5ª de Beethoven acima) em música. Ao final desta
atividade, há um programa de aplicação que você pode usar para reproduzir toque em
formato RTTTL.
Defina o Bloco de Código a Ser Executado Caso a Caso.
A instrução SELECT...CASE é provavelmente a melhor ferramenta de programação
para reconhecer caracteres ou valores. Tenha em mente que esta é uma das ferramentas
mais usadas para converter um toque em formato RTTTL em notas musicais.
Em geral, SELECT...CASE é usado para:
•
•
Selecionar uma variável ou expressão.
Avaliar a variável ou expressão caso a caso.
Página - 223
•
Executar diferentes blocos de código, dependendo do caso, e do o valor em que
a variável se encaixa.
Aqui está a sintaxe SELECT...CASE:
SELECT expression
CASE condition(s)
statement(s)
{ CASE ELSE
Statement(s) }
ENDSELECT
Você pode tentar os próximos dois exemplos de programas para ver como
SELECT...CASE funciona. SelectCaseWithValues.bs2 leva valores numéricos
inseridos no DEBUG Terminal e diz-lhe o tamanho mínimo da variável que você vai
precisar para realizar esse valor. SelectCaseWithCharacters.bs2 informa se o caractere
que você entrou no DEBUG Terminal é maiúsculo ou minúsculo, um dígito, ou
pontuação.
Lembre-se de usar a janela de transmissão no DEBUG Terminal para enviar os
caracteres digitados para o BASIC Stamp. As janelas de transmissão e recepção são
mostradas na Figura 8-5.
Figura 8-5
Envio de
mensagens para
o BASIC Stamp
Janela de
Transmissão
Transmite →
Clique na janela
de transmissão
(superior) e digite
o valor ou os
caracteres que
você quer
transmitir para o
BASIC Stamp.
Recebe →
Exemplo de Programa: SelectCaseWithValues.bs2




Coloque e execute SelectCaseWithValues.bs2.
No DEBUG Terminal, certifique-se de que a caixa Echo off não esteja marcada.
Clique na janela de transmissão do DEBUG Terminal.
Insira um valor entre 0 e 65535, e pressione a tecla Enter.
O que acontece se você digitar um número maior do que 65535? Se você digitar o
número 65536, o BASIC Stamp irá armazenar o número 0. Se você digitar o número
65537, o BASIC Stamp irá armazenar o número 1 e assim por diante. Quando um
número é muito grande para a variável que se encaixa, ele é chamado de overflow.
Use a Tabela 8- 1 para verificar se o programa de exemplo tomou as decisões corretas
sobre o tamanho dos números que você entrou no DEBUG Terminal.
Tabela 8-1: Tipos de variáveis e valores que podem ser
armazenados
Tipo de variável
Faixa de valores
Bit
0 para 1
Página - 224
Nib
Byte
Word
0 para 15
0 para 255
0 para 65535
' O que é um Microcontrolador - SelectCaseWithValues.bs2
' Informe um valor e veja o tamanho mínimo da variável necessário para
' mantê-la.
'{$STAMP BS2}
'{$PBASIC 2.5}
value
PAUSE 1000
VAR
Word
DEBUG "Informe um valor de", CR,
"0 à 65535: "
DO
DEBUGIN DEC value
SELECT value
CASE 0, 1
DEBUG "Bit", CR
PAUSE 100
CASE 2 TO 15
DEBUG "Nib (Nibble)", CR
PAUSE 200
CASE 16 TO 255
DEBUG "Byte", CR
PAUSE 300
CASE 256 TO 65535
DEBUG "Word", CR
PAUSE 400
ENDSELECT
DEBUG CR, "Informe outro valor: "
LOOP
Como Funciona SelectCaseWithValues.bs2
A palavra variável é declarada para manter os valores inseridos no DEBUG Terminal.
value VAR Word
O comando DEBUGIN leva o número digitado e o coloca na variável value.
DEBUGIN DEC value
A instrução SELECT escolhe a variável value como a única para avaliar estes casos.
SELECT value
Página - 225
O primeiro caso é se a variável value for igual a 0 ou 1. Se o valor for igual a qualquer
um desses números, os comandos DEBUG e PAUSE que seguem serão executados.
CASE 0, 1
DEBUG "BIT", CR
PAUSE 100
O segundo caso é, se o valor for igual a qualquer número de 2 a 15. Se ele for igual a
qualquer um desses números, os comandos DEBUG e PAUSE abaixo serão executados.
CASE 2 to 15
DEBUG "NIB (Nibble)", CR
PAUSE 200
Quando todos os casos forem resolvidos, a palavra-chave ENDSELECT será usada para
completar a instrução SELECT...CASE.
ENDSELECT
Programa de Exemplo: SelectCaseWithCharacters.bs2
Este programa de exemplo avalia cada caractere que você digitou na janela de
transmissão do DEBUG Terminal. Ele pode reconhecer caracteres maiúsculos e
minúsculos, números e alguns sinais de pontuação. Se você digitar um caractere, que o
programa não reconhece, ele irá lhe dizer para tentar novamente (entrando com
caractere diferente).




Coloque e execute SelectCaseWithCharacters.bs2.
Verifique se a caixa de seleção Echo Off não está marcada.
Clique na janela de transmissão do DEBUG Terminal para colocar o cursor lá.
Digite os caracteres na janela de transmissão e observe os resultados.
' O que é um Microcontrolador - SelectCaseWithCharacters.bs2
' Programa é capaz de identificar alguns caracteres: caixa, dígito,
' pontuação.
'{$STAMP BS2}
'{$PBASIC 2.5}
character
PAUSE 1000
VAR
Byte
DEBUG "Informe um caractere: ", CR
DO
DEBUGIN character
SELECT character
CASE "A" TO "Z"
DEBUG CR, "Caixa alta", CR
CASE "a" TO "z"
DEBUG CR, "Caixa baixa", CR
Página - 226
CASE "0" TO "9"
DEBUG CR, "Dígito", CR
CASE "!", "?", ".", ","
DEBUG CR, "Pontuação", CR
CASE ELSE
DEBUG CR, "Caractere desconhecido.", CR,
"Tente um diferente."
ENDSELECT
DEBUG CR, "Informe outro caractere", CR
LOOP
Como Funciona SelectCaseWithCharacters.bs2
Quando comparado com SelectCaseWithValues.bs2, este programa de exemplo tem
algumas diferenças. Em primeiro lugar, o nome da variável de valor foi mudado para
caractere, e o seu tamanho foi alterado de word para byte. Isso ocorre porque todos os
caracteres em PBASIC são de tamanho byte. A instrução SELECT escolhe a variável de
caracteres para avaliação caso-a-caso.
SELECT character
As aspas são usadas para dizer ao BASIC Stamp Editor que você está se referindo aos
caracteres. Podemos tratar dos seguintes grupos de caracteres e sinais de pontuação da
mesma forma que uma série de números, uma vez que o BASIC Stamp reconhece-os
pelo seu ASCII numérico equivalente veja a tabela ASCII no BASIC Stamp Editor.
SELECT character
CASE "A" TO "Z"
DEBUG CR, "Caixa alta", CR
CASE "a" TO "z"
DEBUG CR, "Caixa baixa", CR
CASE "0" TO "9"
DEBUG CR, "Dígito", CR
CASE "!", "?", ".", ","
DEBUG CR, "Pontuação", CR
Há também uma declaração CASE diferente que não foi utilizada no exemplo anterior:
CASE ELSE
DEBUG CR, "Caractere desconhecido.", CR,
"Tente um diferente."
Esta declaração CASE diz ao bloco de código o que fazer se nenhum dos outros casos
for verdadeiro. Você pode obter este caso que funciona com a entrada de um caractere,
como % ou $.
Página - 227
Sua Vez – Selecionando Caracteres Especiais
 Modifique a instrução SELECT...CASE no SelectCaseWithCharacters.bs2 para
que ele exiba um “caractere especial” quando você entrar com um desses
caracteres: @, #, $, %, ’^’ , &, *, (, ), _, ou +.
Programa de Aplicação de Toques RTTTL
Abaixo está o arquivo RTTTL que contém a informação musical usada no próximo
programa de exemplo. Existe mais cinco diretivas RTTTL_File DATA que você pode
tentar na seção Sua Vez. Este programa toca uma música chamada Reveille, que é o
toque de clarim usado em acampamentos militares ao amanhecer . Você pode ter ouvido
isso em inúmeros filmes ou programas de televisão.
RTTTL_File
DATA
"Reveille:d=4,o=7,b=140:8g6,8c,16e,16c,8g6,8e,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8a6,8c,e,8c,8g6,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8g6,8e,8c,16e,",
"16c,8g6,8e,c,p,8e,8e,8e,8e,g,8e,8c,8e,8c,8e,8c,",
"e,8c,8e,8e,8e,8e,8e,g,8e,8c,8e,8c,8g6,8g6,c."
Exemplo de Programa: MicroMusicWithRtttl.bs2
Este aplicativo é muito longo, e é uma boa idéia fazer o download da versão mais
recente na www.parallax.com/gopage/WAM. Baixar o programa e abri-lo com o
BASIC Stamp Editor deve poupar uma quantidade significativa de tempo. A alternativa,
claro, é dar um enter manualmente e depurar quatro páginas de código.
 Com o BASIC Stamp Editor, abra o arquivo baixado MicroMusicWithRtttl.bs2,
ou manualmente insira o exemplo abaixo cuidadosamente.
 Execute o programa e verifique se o som é reconhecido como o clarim de
Reveille.
 Vá para a seção Sua Vez e tente mais alguns toques (diretivas RTTTL_File
DATA).
' O que é um Microcontrolador - MicroMusicWithRtttl.bs2
' Toque o ringtone da Nokia no format RTTTL usando DATA.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ I/O Definitions ]-------------------------------------------SpeakerPin
PIN
9
' Piezospeaker conectado à P9.
' -----[ Variables ]-------------------------------------------------counter
char
VAR
VAR
Word
Byte
' Contador de propósito geral.
' Variável armazena caracteres.
Página - 228
index
VAR
Word
' Índice para apontas dados.
noteLetter
noteFreq
noteOctave
VAR
VAR
VAR
Byte
Word
Word
' Armazena caracteres da nota.
' Armazena frequência da nota.
' Armazena oitava da nota.
duration
tempo
VAR
VAR
Word
Word
' Armazena duração da nota.
' Armazena ritmo.
default_d
default_o
default_b
VAR
VAR
VAR
Byte
Byte
Word
' Armazena duração padrão.
' Armazena oitava padrão.
' Armazena batidas/min padrão.
' -----[ EEPROM Data ]-----------------------------------------------RTTTL_File
DATA
"Reveille:d=4,o=7,b=140:8g6,8c,16e,16c,8g6,8e,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8a6,8c,e,8c,8g6,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8g6,8e,8c,16e,",
"16c,8g6,8e,c,p,8e,8e,8e,8e,g,8e,8c,8e,8c,8e,8c,",
"e,8c,8e,8e,8e,8e,8e,g,8e,8c,8e,8c,8g6,8g6,c."
Done
DATA
",q,"
Notes
DATA
Octave8
DATA
"p",
"a",
"#",
"b",
"c",
"#",
"d",
"#",
"e",
"f",
"#",
"g",
"#"
Word 0,
Word 3520, Word 3729, Word 3951,
Word 6645
' -----[ Initialization ]--------------------------------------------counter = 0
' Inicializa contador.
GOSUB
GOSUB
GOSUB
GOSUB
GOSUB
GOSUB
'
'
'
'
'
'
FindEquals
ProcessDuration
FindEquals
ProcessOctave
FindEquals
GetTempo
Encontra primeiro '=' no arq.
Obtém duração padrão.
Encontra próximo '='.
Obtém oitava padrão.
Encontra último '='.
Obtém ritmo padrão.
' -----[ Program Code ]----------------------------------------------DO UNTIL char = "q"
GOSUB ProcessDuration
GOSUB ProcessNote
GOSUB CheckForDot
GOSUB ProcessOctave
GOSUB PlayNote
LOOP
END
' Loop até 'q' em DATA.
' Obtém duração da nota.
' Obtém valor do índice da nota.
' Se dot, 3/2 duração.
' Obtém oitava.
' Obtém freq, toca nota, próx.
' Fim do loop principal.
' Fim do programa.
' -----[ Subroutine - Find Equals Character ]-------------------------
Página - 229
FindEquals:
DO
READ RTTTL_File + counter, char
counter = counter + 1
LOOP UNTIL char = "="
'
'
'
'
Busca por '=' através dos
caracteres no arq RTTTL.
Incrementa contador até
achar '=', então, retorna.
RETURN
'
'
'
'
'
'
'
-----[ Subroutine - Read Tempo from RTTTL Header ]-----------------Cada caractere do teclado tem um número único chamado valor ASCII.
Os caracteres 0, 1, 2,..., 9 possuem valores ASCII de 48, 49, 50,
..., 57.
Você pode sempre converter do caractere representando um dígito para
o seu valor subtraundo 48 da variável que armazena o dígito.
Você pode examinar isso comparando DEC 49 e DEBUG 49.
GetTempo:
' Analisa arq RTTTL para ritmo.
' Converte caracteres para
default_b = 0
' dígitos subtraindo 48
DO
' de cada valor ASCII do
READ RTTTL_File + counter, char ' caractere. Iterativamente
IF char = ":" THEN
' multiplica cada dígito por 10
default_b = default_b / 10
' se houver outro dígito, então
' adiciona o ultimo dígito à
EXIT
' uma coluna.
ENDIF
' Por exemplo, a sequência
default_b = default_b + char - 48
' "120" é (1 X 10 X 10)
' + (2 X 10) + 0. O '1'
default_b = default_b * 10
' é convertido primeiro, então
LOOP UNTIL char = ":"
' multiplicado por 10. O '2'
' é então convertido/adicionado.
RETURN
' 0 é convertido/adicionado, fim
' -----[ Subroutine - Look up Octave ]-------------------------------ProcessOctave:
SELECT char
CASE "5" TO "8"
noteOctave = char - "0"
CASE ELSE
noteOctave = default_o
ENDSELECT
IF default_o = 0 THEN
default_o = noteOctave
ENDIF
RETURN
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
Oitava pode ou não ser
incluída em dada nota
porque qualquer nota que é
tocada na oitava padrão
não especifica a oitava.
Se um caractere de '5'
a '8' então a usa, ELSE usa
default_o.
Caracteres são convertidos
para dígitos subtraindo
'0', que é o mesmo que
subtrair 48. A primeira vez
que essa sub-rotina é
chamada, default_o é 0.
Se 0, então define default_o.
' -----[ Subroutine - Find Index of Note ]---------------------------ProcessNote:
SELECT char
CASE "p"
index = 0
'
'
'
'
'
Define valor do índice para
busca da freq da nota baseada
no caractere da nota. Se 'p',
o índice é 0. Se 'a' à 'g',
lê os valores dos caracteres
' na tabela DATA e encontra com-
Página - 230
CASE "a" TO "g"
' binação. Grava valor do índi' ce quando a combinação é
' encontrada, caractere éum
FOR index = 1 TO 12
' sustenido (#), adiciona
READ Notes + index, noteLetter ' 1 ao valor do índice para
IF noteLetter = char THEN EXIT ' aumentar o índice (e
NEXT
' frequência) por 1 nível.
' Como em outras sub-rotinas,
READ RTTTL_File + counter, char ' o contador de increment para
SELECT char
' caracteres é o processado.
CASE "#"
index = index + 1
ENDSELECT
ENDSELECT
RETURN
' -----[ Subroutine - Determine Note Duration ]----------------------ProcessDuration:
' Verifica se a forma dos chars
' é 1, 2, 4, 8, 16 ou 32.
' Se sim, então converte do
' caractere ASCII para um valor
SELECT char
' subtraindo 48. Se for o caso
CASE "1", "2", "3", "4", "8"
' de 16 ou 32, multiplica
duration = char - 48
' por 10 e adiciona o próximo
' dígito à colunas de “uns”.
SELECT char
CASE "6", "2"
duration = duration * 10 + char - 48
ENDSELECT
CASE ELSE
' Se não houver duração, usa
duration = default_d
' a padrão.
ENDSELECT
IF default_d <> 0 THEN
' Se default_d não é definida
duration = 60000/default_b/duration*3 '(if default_d = 0), então
ELSE
' define default_d = para a
default_d = duration
' duração de d=#.
ENDIF
RETURN
' -----[ Subroutine - Check For '.' Indicating 1.5 Duration ]--------CheckForDot:
SELECT char
CASE "."
duration = duration * 3 / 2
ENDSELECT
' Verifica indicação de dots mul
' tiplicando a duração por 3/2.
' Se encontra dor, multiplica
' por 3/2 e incrementa contador,
' se não, não faz nada e
' retorna.
RETURN
' -----[ Subroutine - Find Comma and Play Note/Duration ]-------------
Página - 231
PlayNote:
'
'
'
'
'
Encontra últma vírgula na
entrada da nota atual. Então,
busca a frequência da nota
no data, e a toca, ou pausa,
se a frequência for = 0.
SELECT char
CASE ","
READ Octave8 + (index * 2), Word noteFreq
noteOctave = 8 - noteOctave
IF noteFreq = 0 THEN
PAUSE duration
ELSE
FREQOUT SpeakerPin, duration, noteFreq
ENDIF
ENDSELECT
RETURN
Como Funciona MicroMusicWithRtttl.bs2
Este programa de exemplo é divertido de usar, ele mostra o tipo de código que você será
capaz de escrever com um pouco de prática. No entanto, ele foi incluído neste texto
mais por diversão do que para os conceitos de codificação que emprega. Se você
examinar o código brevemente, você pode notar que você já usou todos os comandos e
operadores do programa, exceto um!
Aqui está uma lista dos elementos que esse programa usa, eles, agora, já devem ser bem
familiares:
• Comentários para ajudar a explicar o seu código;
• Declarações constantes e variáveis;
• Declarações DATA;
• Comandos READ;
• Blocos IF...ELSE...ENDIF;
• DO...LOOP com ou sem WHILE e UNTIL;
• Sub-rotinas com GOSUB, rótulos, e RETURN;
• Loops FOR...NEXT;
• Comandos LOOKUP e LOOKDOWN;
• Comandos FREQOUT e PAUSE;
• Comandos SELECT...CASE;
• EXIT é novo, mas simplesmente permite que o programa "saia" um loop antes
de terminar. É frequentemente usado em declaraçaões IF...THEN.
Sua Vez - Toques Diferentes
 Tente substituir a diretiva RTTTL_File DATA em MicroMusicWithRTTTL.bs2
com cada um dos cinco arquivos de música diferentes abaixo.
Apenas uma diretiva RTTTL_File DATA de cada vez! Certifique-se de
substituir, e não adicionar a sua nova directiva RTTTL_File DATA.
 Execute MicroMusicWithRTTTL.bs2 para testar cada arquivo RTTTL.
Página - 232
RTTTL_File DATA
"TwinkleTwinkle:d=4,o=7,b=120:c,c,g,g,a,a,2g,f,",
"f,e,e,d,d,2c,g,g,f,f,e,e,2d,g,g,f,f,e,e,2d,c,c,",
"g,g,a,a,2g,f,f,e,e,d,d,1c"
RTTTL_File DATA
"FrereJacques:d=4,o=7,b=125:c,d,e,c,c,d,e,c,e,f",
",2g,e,f,2g,8g,8a,8g,8f,e,c,8g,8a,8g,8f,e,c,c,g6",
",2c,c,g6,2c"
RTTTL_File DATA
"Beethoven5:d=8,o=7,b=125:g,g,g,2d#,p,f,f,f,2d"
RTTTL_File DATA
"ForHe'sAJollyGoodFellow:d=4,o=7,b=320:c,2e,e,e,",
"d,e,2f.,2e,e,2d,d,d,c,d,2e.,2c,d,2e,e,e,d,e,2f,",
"g,2a,a,g,g,g,2f,d,2c"
RTTTL_File DATA
"TakeMeOutToTheBallgame:d=4,o=7,b=225:2c6,c,a6,",
"g6,e6,2g.6,2d6,p,2c6,c,a6,g6,e6,2g.6,g6,p,p,a6",
",g#6,a6,e6,f6,g6,a6,p,f6,2d6,p,2a6,a6,a6,b6,c,",
"d,b6,a6,g6"
Baixando arquivos RTTTL: Há arquivos RTTTL disponíveis para download a
partir de diversos sites na internet. Esses arquivos são fornecidos pelos
entusiastas de toques de celular, muitos dos quais não são especialistas em
música. Alguns tons de telefone são muito bons, outros são quase
irreconhecíveis. Se você quiser baixar e executar alguns arquivos RTTTL,
certifique-se de remover os espaços entre caracteres, em seguida, insira o arquivo
de texto entre aspas.
SUMÁRIO
Este capítulo introduziu técnicas para fazer sons e tons musicais com o BASIC Stamp e
um alto-falante piezoelétrico. O comando FREQOUT pode ser usado para enviar para um
alto-falante piezoelétrico sinais de alta/baixa que provocam efeitos sonoros e/ou notas
musicais. O comando FREQOUT tem argumentos que controlam o sinal do pino de I/O
enviado para a duração do tom, e a frequência do som (Freq1). O argumento opcional
Freq2 pode ser usado para tocar duas notas de uma só vez.
Os efeitos sonoros podem ser feitos ajustando a frequência e duração dos tons e as
pausas entre eles. O valor da frequência também pode ser varrido através de uma gama
de valores para criar uma variedade de efeitos.
Fazer notas musicais depende também de frequência, duração e pausas. O valor do
argumento Duration do comando FREQOUT é determinado pelo ritmo da música e da
duração da nota (semibreve, mínima, semínima etc.) O valor Freq1 da nota é
Página - 233
determinado por letra da nota e oitava. As pausas entre as notas são usadas para definir
a duração do comando PAUSE.
A reprodução de músicas simples pode ser feita usando o comando FREQOUT, mas
existem maneiras melhores de armazenar e recuperar dados musicais. A diretiva DATA
em conjunto com rótulos opcionais Symbol foi usada para armazenar valores de bytes
sem prefixo e os valores de textos usando o prefixo Word. O comando READ foi usado
para recuperar valores armazenados pelas diretivas DATA. Nos exemplos deste capítulo,
o argumento Location do comando READ usou sempre a etiqueta opcional Symbol da
diretiva DATA para diferenciar os diferentes tipos de dados. Alguns dos rótulos Symbol
que foram usados eram notas, durações, pontos e oitavas.
Dados musicais podem ser armazenados em formatos que se prestam para a tradução a
partir de partituras. Os estilos de dados da partitura podem ser convertidos em
frequências usando os comandos LOOKUP e LOOKDOWN. Operações matemáticas
também podem ser realizadas sobre os valores de variáveis para alterar a oitava de uma
nota dividindo sua frequência a uma potência de dois. Operações matemáticas também
são úteis para as durações de notas dando o ritmo ou a duração de uma semibreve.
SELECT...CASE foi introduzido como uma forma de avaliar uma variável em uma
base caso a caso. SELECT...CASE é particularmente útil para examinar caracteres ou
números quando há muitas opções, como o que poderia ser uma variável, e muitos
diferentes conjuntos de ações que precisam ser tomadas com base no valor da variável.
Um programa que converte sequências de caracteres que descrevem tons musicais para
telefones celulares mais antigos (chamados de arquivos RTTTL) foi utilizado para
introduzir um programa maior, que faz uso de todas as técnicas de programação
apresentadas neste texto. SELECT...CASE desempenhou um papel de destaque neste
programa porque ele é usado para examinar os caracteres selecionados em um arquivo
RTTTL caso-a-caso.
Questões
1. O que causa um tom de som alto e agudo? O que causa um tom de som de baixa
frequência?
2. O que FREQOUT 15, 1000, 3000 não faz? Qual o efeito que cada um dos
números tem?
3. Como você pode modificar o comando FREQOUT da questão 2, de modo que ele
envie duas frequências de uma só vez?
4. Se você encontrar uma chave de piano B6, que frequência ela enviará?
5. Como modificar uma diretiva DATA ou comando READ se desejar armazenar e
recuperar valores de texto?
6. Você pode ter mais de uma diretiva DATA? Se sim, como você diria a um
comando READ para obter dados a partir de uma ou de outra diretiva DATA?
7. Se souber a frequência de uma nota em uma oitava, o que você tem que fazer
para que a frequência a reproduza uma oitava acima?
8. O que SELECT...CASE faz?
Exercícios
1. Modifique o tom de Alarme ... de ActionTones.bs2 para que a frequência do tom
que desempenha aumente em 500 cada vez que o tom se repetir.
Página - 234
2. Explique como modificar MusicWithMoreFeatures.bs2 para que ele exiba uma
mensagem de alerta no DEBUG Terminal cada vez que uma nota pontilhada é
tocada.
Projeto
1. Construa um gerador de tom, controlado por botão. Se um botão for
pressionado, o alto-falante deverá fazer um bip de 2 kHz para 0,5 segundo. Se
outro botão for pressionado, o alto-falante deverá fazer um sinal sonoro 3 kHz
para 1/10 de segundo.
Soluções
Q1.Nossos ouvidos detectam alterações na pressão do ar como tons. Um tom agudo
alto é proveniente de mudanças rápidas na pressão do ar, um tom baixo provém
de mudanças mais lentas na pressão do ar.
Q2.FREQOUT 15, 1000, 3000 envia um sinal de 3000 Hz a P15 por um segundo
(1000 ms). O efeito de cada número: 15 – para o pino de I/O P15, 1000 duração do tom equivalente a 1.000 ms ou um segundo; 3000 - a frequência do
tom, em hertz, de modo que este envia um tom de 3000 Hz.
Q3.Use o argumento opcional Freq2. Para reproduzir 3000 Hz e dizer 2000 Hz,
basta adicionar uma segunda frequência para o comando, depois de uma vírgula:
FREQOUT 15, 1000, 3000, 2000
Q4.1975,5 Hz, veja Figura 8-3 na página 207.
Q5.Use o modificador opcional Word antes de cada item de dados.
Q6.Sim. Cada diretiva DATA pode ter um parâmetro opcional Symbol diferente. Para
especificar quais diretivas DATA para obter os dados, inclua o parâmetro Symbol
após a palavra-chave READ. Por exemplo: READ Notes, noteLetter. Neste
exemplo, o Notes é o parâmetro Symbol.
Q7.Para ter uma determinada nota na próxima oitava acima, multiplique a
frequência por dois.
Q8. SELECT...CASE seleciona uma variável ou expressão, avalia-as caso a caso e
executa diferentes blocos de código, dependendo do caso em que o valor da
variável se encaixa.
E1. Este problema pode ser resolvido aumentando manualmente cada tom por 500,
ou através da utilização de um loop FOR ... NEXT, com um valor de 500
STEP.
Utilizando o loop FOR...NEXT:
Aumente manualmente o tom :
Página - 235
DEBUG "Aumentando alarme...", DEBUG "Aumentando
CR
alarme...",CR
PAUSE 100
PAUSE 100
FOR frequency = 1500 TO
FREQOUT 9, 500,
3000 STEP 500
PAUSE 500
FREQOUT 9, 500,
FREQOUT 9, 500,
frequency
PAUSE 500
PAUSE 500
FREQOUT 9, 500,
NEXT
PAUSE 500
FREQOUT 9, 500,
PAUSE 500
1500
2000
2500
3000
E2. Modifique as linhas que verificam a nota pontilhada:
Adicione um comando DEBUG ao IF ... THEN. Não se esqueça do ENDIF.
IF noteDot = 1 THEN
noteDuration = noteDuration * 3 / 2
DEBUG "Dotted Note!", CR
ENDIF
P1. Use o circuito do piezospeaker da Figura 8-2, na página 201, e circuitos de
botão de pressão da Figura 4 -26 na página 108.
' O que é um Microcontrolador ' Ch8Prj01_PushButtonToneGenerator.bs2
' P4 Pressionado: Bip de 2 kHz por 1/5 de segundo. 2 kHz = 2000
' Hz.
'
1/5 s = 1000 / 5 ms = 200 ms
' P3 Pressionado: Bip de 3 kHz por 1/10 de segundo. 3 kHz =
' 3000 Hz.
'
1/10 s = 1000 / 10 ms = 100 ms
'{$STAMP BS2}
'{$PBASIC 2.5}
DO
IF (IN4 = 1) THEN
FREQOUT 9, 200, 2000
FREQOUT 9, 100, 3000
ENDIF
LOOP
' 2000 Hz por 200 ms
' 3000 Hz por 100 ms
Página - 236
Capítulo 9: Construindo Blocos Eletrônicos
ESSES PEQUENOS CHIPS PRETOS
Você precisa apenas olhar para o seu BASIC Stamp (veja Figura 9-1) para encontrar
exemplos “desses pequenos chips pretos”. Cada um desses chips tem uma função
especial. O chip superior direito é o regulador de voltagem. Ele pega a voltagem da
bateria e a converte para quase exatamente 5,0 V, que é o que o resto dos componentes
do BASIC Stamp precisa para funcionar adequadamente. O chip superior esquerdo é a
EEPROM do módulo BASIC Stamp. Programas PBASIC são condensados em números
chamados tokens que são baixados para o BASIC Stamp. Esses tokens são armazenados
na EEPROM, e você pode vê-los clicando em Executar (Run) e, em seguida, Mapa de
Memória (Memory Map) no BASIC Stamp Editor. O chip maior é chamado de
Intérprete. É um microcontrolador pré-programado com o PBASIC interpretar que
busca os sinais da EEPROM e depois interpreta o comando PBASIC que o token
representa. Em seguida, ele executa o comando, busca o próximo token e assim por
diante. Este processo é chamado de busca e execução.
A EEPROM de 2K
armazena o código
PBASIC e os dados
registrados
→
Regulador de
5V converte a
voltagem de
entrada para
5 volt
regulados
←
Figura 9-1
Circuitos
integrados
no BASIC
Stamp 2
Chip Interpreter
PBASIC (um
microcontrolador préprogramado)
→
As pessoas usam o termo "circuito integrado" (CI) para falar sobre esses pequenos chips
pretos. O circuito integrado é na verdade um minúsculo chip de silício contido dentro do
plástico preto ou da caixa de cerâmica. Dependendo do chip, ele pode ter um lugar entre
centenas e milhares de transistores. Um transistor é um bloco básico de construção de
circuitos integrados, e você terá a oportunidade de experimentá-los com um transistor
neste capítulo. Outros componentes familiares que são projetados em chips de silício
incluem diodos, resistores e capacitores.
Tire um momento para pensar sobre as atividades que você realizou com este livro até
agora. A lista inclui a mudança dos LEDs em on e off, leitura de botões, controle dos
servos, leitura dos potenciômetros, medição de luz, displays controlados e reprodução
de sons. Mesmo que isso seja apenas o começo, ainda é bastante impressionante,
especialmente considerando que você pode combinar essas atividades para fazer
Página - 237
aparelhos mais complexos. O coração do sistema que fez todas estas atividades
possíveis é constituído apenas pelos três circuitos mostrados na Figura 9-1 e algumas
outras peças. Ele apenas mostra quão poderosos os circuitos integrados podem ser,
quando projetados para trabalhar em conjunto.
EXPANDA SEUS PROJETOS COM CIRCUITOS PERIFÉRICOS
INTEGRADOS
Existem milhares de circuitos integrados projetados para serem usados com
microcontroladores. Ocasionalmente, diferentes fabricantes de circuitos integrados
fazem chips que executam a mesma função. Às vezes, as características de cada chip
diferem um pouco, e, em outras, os chips são quase idênticos, mas um pode custar um
pouco menos do que o outro. Cada um dos milhares de diferentes circuitos integrados
pode ser usado como um bloco de construção para uma variedade de modelos. As
empresas publicam informações sobre a forma como cada um de seus circuitos
integrados age em documentos chamados folha de dados e as disponibiliza em seus
sites. Estes fabricantes também publicam notas de aplicação, que mostram como usar o
circuito integrado de forma única e útil tornando mais fácil o design dos produtos. Os
fabricantes de circuitos integrados dão esta informação na esperança de que os
engenheiros usem-nas para construir seus chips na mais recente versão que os
brinquedos ou equipamentos devem ter. Se milhares de brinquedos são vendidos, isso
significa que a empresa vende milhares de seus circuitos integrados.
Neste capítulo, você vai trabalhar com um transistor e um circuito integrado para fins
especiais chamado potenciômetro digital. Como mencionado anteriormente, o transistor
é um bloco básico para construção de circuitos integrados. É também um bloco básico
para construção dos lotes de outros circuitos. O potenciômetro digital também tem uma
variedade de utilizações. Tenha em mente que para cada atividade que você fizer,
provavelmente existirão centenas de maneiras diferentes que você poderá usar com cada
um desses circuitos integrados.
ATIVIDADE #1: CONTROLE DO FLUXO ATUAL COM UM TRANSISTOR
Nesta atividade, você vai usar um transistor como uma forma de controlar a passagem
de corrente através de um LED. Você pode usar o LED para monitorar a corrente, visto
que ele brilha mais intensamente quando mais corrente passa através dele e menos
intensamente quando menos corrente passa.
Apresentando o Transistor
A Figura 9-2 mostra o símbolo esquemático e peças do desenho do transistor 2N3904.
Existem muitos tipos diferentes de transistores. Este é chamado NPN, que se refere aos
tipos de material usado para fabricar o transistor e como esses materiais são
mergulhados no silício. A melhor maneira de começar a pensar em um transistor é
imaginá-lo como uma válvula que é usada para controlar a corrente. Diferentes
transistores controlam a quantidade de corrente que passa através deles por diferentes
meios. Este transistor controla a quantidade de corrente que passa em C (coletor) e sai
em E (emissor). Ele usa a quantidade de corrente permitida no terminal B (base) para
controlar a passagem de corrente através de C a E. Com uma pequena quantidade de
Página - 238
corrente permitida em B, a corrente passa 416 vezes mais que o fluxo de corrente do
transistor em C e E
C
C
B
E
Figura 9-2
Transistor 2N3904
B
2N3904
E
Ficha Técnica da Peça 2N3904: Como mencionado anteriormente, os
fabricantes de semicondutores publicam documentos chamados fichas técnicas
para as peças que fazem. Estas fichas contêm informações que os engenheiros
usam para projetar uma peça em um produto. Para ver um exemplo de ficha
técnica da peça 2N3904: vá para www.fairchildsemi.com. Digite "2N3904" no
campo de pesquisa (Search) na página inicial do Fairchild Semiconductor, e
clique em Ir (Go). Um dos resultados da pesquisa deverá ser um link para
informações sobre o produto 2N3904. Siga-o e procure o link Ficha Técnica. A
maioria dos navegadores abre a ficha técnica com o programa Adobe Acrobat
Reader.
Exemplo de Peças do Transistor
(1) Transistor – 2N3904
(2) Resistores – 100 kΩ (marrom-preto-amarelo)
(3) Fios
Construindo e Testando o Circuito do Transistor
A Figura 9-3 mostra um circuito que pode ser usado manualmente para controlar a
quantidade de corrente que o transistor permite passar através do LED. Ao torcer o
botão do potenciômetro, o circuito transmitirá diferentes quantidades de corrente para a
base do transistor. Isto vai causar uma alteração na quantidade de corrente que o
transistor permite passar de seu coletor para o seu emissor. O LED lhe dará dar uma
indicação clara da mudança, brilhando mais ou menos intensamente.
o Certifique-se de que o pino de ânodo do LED (o maior) está ligado a
VDD.
o Verifique o circuito de seu transistor. Note se a face plana do transistor
está virada para a direita no diagrama de fiação.
 Gire o botão do potenciômetro e verifique se o LED muda o brilho, em resposta
a uma mudança na posição do wiper terminal do potenciômetro.
Página - 239
Vdd
Vdd
LED
100 kΩ
POT
10 kΩ
100 kΩ
Vss
Vss
Figura 9-3
Potenciômetro Manual
– Circuito do
Transistor Controlado
Sua Vez – Mudar o Transistor On/Off
Se tudo que você quer fazer é ligar e desligar um transistor, você poderá usar o circuito
mostrado na Figura 9-4. Quando o BASIC Stamp enviar um sinal de alta para este
circuito, ele fará com que o transistor conduza mais corrente como se você tivesse
ajustado o potenciômetro para um brilho máximo. Quando o BASIC Stamp enviar um
sinal de baixa para este circuito, ele fará com que o transistor pare de conduzir de
corrente, e o LED deverá emitir luz.
Qual é a diferença entre conectar este circuito e um circuito de LED para
um pino de I/O? Os pinos de I/O do BASIC Stamp têm limitações quanto à
quantidade de corrente que podem transmitir. Os transistores têm limitações
também, mas são muito mais elevadas. No Sistema de Controle do Guia do
Estudante (Process Control Student Guide), um transistor é usado para acionar
um pequeno ventilador DC. É também utilizado para fornecer grandes
quantidades de corrente a um pequeno resistor que é utilizado como um elemento
de aquecimento. Qualquer uma destas duas aplicações atrairia tanta corrente que
danificaria, rapidamente, o BASIC Stamp, mas o transistor leva com facilidade.
 Construa o circuito mostrado na Figura 9- 4.
 Escreva um programa que envie sinais de alta e baixa para P8 duas vezes por
segundo. DICA: LedOnOff.bs2 do Capítulo 2 só precisa ser modificado para
enviar sinais de alta/baixa para P8 em vez de P14. Lembre-se de salvá-lo com
um novo nome antes de fazer as modificações.
 Execute o programa e verifique se ele liga/desliga o controle do LED.
Página - 240
Vdd
Vdd
Vin
Vss
X3
LED
P8
100 kΩ
100 kΩ
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 9-4
Circuito que dá ao
BASIC Stamp controle
de corrente on/off para
o LED com um
transistor
ATIVIDADE #2: INTRODUÇÃO AO POTENCIÔMETRO DIGITAL
Nesta atividade, você irá substituir o potenciômetro ajustado manualmente por um
potenciômetro de circuito integrado que é ajustado digitalmente. Então, você vai
programar o BASIC Stamp para ajustar o potenciômetro digital, que por sua vez irá
ajustar o brilho do LED da mesma forma que o potenciômetro manual fez na atividade
anterior.
Apresentando os Potenciômetros Digitais
A Figura 9-5 mostra um mapa do pino do potenciômetro digital que você vai usar nesta
atividade. Este chip tem 8 pinos, quatro de cada lado, espaçados para facilitar a ligação
na protoboard (1/10 de polegada de distância). O fabricante coloca uma marca de
referência na caixa de plástico de modo que você possa diferenciar os pinos 1 e 5. A
marca de referência é um semicírculo pequeno no caso do chip. Você pode usar essa
marca como uma referência para os números dos pinos no chip, que são contados de
baixo para cima, no sentido anti-horário a partir da marca de referência.
Substituições de peças: Às vezes é necessário que a Parallax faça substituição
de peças. A peça funcionará do mesmo modo, mas o rótulo poderá ser diferente.
Se você achar que o potenciômetro digital incluso no kit de peças do seu BASIC
Stamp - Kit de Atividades não está etiquetado AD5220, saiba que ele funcionará
da mesma maneira e executará corretamente essa atividade.
Reference
Notch
1 CLK
Vdd 8
2 U/D
CS 7
3 A1
B1 6
4 GND
W1 5
AD5220
Figura 9-5
Mapa do Pino AD5220
Use a marca de referência para
se certificar de que você tem o
AD5220 do lado direito para cima
quando construí-lo em seu
circuito no protoboard.
Página - 241
Aqui está um resumo de cada um dos pinos AD5220 e suas funções:
1. CLK: Pino que recebe pulsos de relógio (sinais baixo-alto-baixo) para mover o
wiper terminal.
2. U/D: Pino que recebe um sinal de alta para fazer o wiper terminal (W1) mudar
para A1, e um sinal de baixa para fazê-lo avançar para B1. Este pino só define a
direção, o wiper terminal na verdade não se move até que um pulso (sinal baixoalto-baixo) seja enviado para o pino CLK.
3. A1: Terminal A do potenciômetro.
4. GND: Fio terra. O fio terra no Board of Education e no BASIC Stamp
HomeWork Board é um terminal Vss.
5. W1: Wiper Terminal do potenciômetro (W).
6. B1: Terminal B do potenciômetro.
7. CS: O chip seleciona um pino. Aplique um sinal de alta para este pino, e o chip
ignorará todos os sinais de controle enviados para CLK e U/D. Aplique um sinal
de baixa para este pino, que agirá em todos os sinais de controle recebidos.
8. Vdd: Ligue +5 V, que é Vdd no Board of Education e no BASIC Stamp
HomeWork Board.
Dados Técnicos da Peça AD5220: Para ver os dados técnicos de AD5220: Vá
para www.analog.com. Digite "AD5220" no campo de busca na página principal
em Dispositivos Analógicos (Analog Devices), e clique no botão Busca (Search).
Clique no link Dados Técnicos (Data Sheets). Clique no link que diz "AD5220:
Aumento/Diminuição de Dados Técnicos do Potenciômetro Digital
(Increment/Decrement Digital Potentiometer Datasheet).
Peças do Potenciômetro Digital Controlado pelo Transistor
(1) Transistor – 2N3904
(2) Resistor – 100 kΩ (marrom-preto-amarelo)
(1) Digital potenciômetro – AD5220
(10) Fios
Construindo o Circuito de Potenciômetros Digitais
A Figura 9-6 mostra um diagrama esquemático do circuito com o potenciômetro digital
utilizado no lugar de um potenciômetro manual, e a Figura 9-7 mostra um diagrama de
ligações para o circuito. O BASIC Stamp pode controlar o potenciômetro digital através
da emissão de sinais de controle para P5 e P6.
Vdd
Vdd
Vdd
AD5220
P6
1
CLK
Vdd 8
P5
2
U/D
CS 7
B1 6
A1
3
4
GND
Figura 9-6
Circuito
Esquemático do
Potenciômetro
Digital Controlado
pelo Transistor
W1 5
100 kΩ
100 kΩ
Vss
Vss
Página - 242
Vdd
Vin
Vss
X3
Figura 9-7
Diagrama de
Fiação para a
Figura 9-6
AD5220
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Controle da Programação de Potenciômetros Digitais
Imagine que o botão do potenciômetro manual do exercício anterior tem 128 posições.
Imagine também que o potenciômetro está no meio da sua gama de movimentos. Isso
significa que você pode girar o botão em uma direção por 63 etapas e em outra por 64.
Vamos dizer que você gire o botão do potenciômetro uma vez em sentido horário. O
LED vai ficar apenas um pouco mais brilhante. Este seria o mesmo que enviar um sinal
de alta ao pino L/D do AD5220 e enviar um pulso (alto-baixo-alto) para o pino CLK.
HIGH 5
PULSOUT 6, 1
Imagine agora que você girou o seu potenciômetro manual em 3 etapas no anti-horário.
O LED vai ficar um pouco mais escuro. Este seria o mesmo que enviar um sinal de
baixa para o pino L/D do AD5220 e enviar três pulsos ao pino CLK.
LOW 5
PULSOUT 6, 1
PAUSE 1
NEXT
Agora imagine que você girou o potenciômetro totalmente no sentido horário. Isso é o
mesmo que enviar um sinal de alta para o pino do U/D AD5220 e enviar 65 pulsos ao
pino CLK. Agora, o LED deverá estar brilhando.
HIGH 5
PULSOUT 6, 1
PAUSE 1
NEXT
Finalmente, imagine que você girou o seu potenciômetro manual totalmente no sentido
anti-horário. O LED não deve emitir luz. Isso é o mesmo que enviar um sinal de baixa
para o pino U/D, e aplicar 128 pulsos ao pino CLK.
LOW 5
Página - 243
PULSOUT 6, 1
PAUSE 1
NEXT
Exemplo de Programa: DigitalPotUpDown.bs2
Este programa de exemplo ajusta o potenciômetro para cima e para baixo, a partir de
uma extremidade de seu alcance para outra, fazendo com que o LED fique
gradualmente mais brilhante e, em seguida, gradualmente, mais opaco.
 Coloque e execute DigitalPotUpDown.bs2.
' O que é um Microcontrolador - DigitalPotUpDown.bs2
' Varre o potenciômetro digital através de valores.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
DO
VAR
Byte
LOW 5
PULSOUT 6, 1
PAUSE 10
NEXT
HIGH 5
PULSOUT 6, 1
PAUSE 10
NEXT
LOOP
Sua Vez – Alterando a Taxa e Condensando o Código
Você pode aumentar ou diminuir a velocidade para que o LED brilhe e escureça
alterando o argumento Duration do comando PAUSE.
 Modifique e execute novamente o programa usando PAUSE 20 e note a
diferença na área em que o LED fica mais brilhante e escuro.
 Repita o procedimento para PAUSE 5.
Você também pode usar um comando chamado TOGGLE para tornar este programa mais
simples. O comando TOGGLE alterna o estado de um pino de I/O do BASIC Stamp. Se o
pino de I/O estava enviando um sinal alto, o comando TOGGLE faz com que ele envie
um sinal baixo. Se o pino de I/O enviou um sinal baixo TOGGLE torna a enviar um sinal
alto.
 Salve DigitalPotUpDown.bs2 como DigitalPotUpDownWithToggle.bs2.
 Modifique o programa para que ele se pareça com o nome indicado abaixo.
Página - 244
 Execute o programa e verifique se ele funciona da mesma forma que o
DigitalPotUpDown.bs2.
 Compare o número de linhas de código que ele usou para fazer o mesmo
trabalho.
A falta de memória do programa é um problema que algumas pessoas encontram
quando seus projetos com o BASIC Stamp ficam muito grandes e complicados.
Usar o comando TOGGLE em vez de dois loops FOR...NEXT é apenas um
exemplo das muitas técnicas que podem ser usadas para fazer o mesmo trabalho
com metade do código.
' O que é um Microcontrolador - DigitalPotUpDownWithToggle.bs2
' Varre o potenciômetro digital através de valores.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
LOW 5
VAR
Byte
DO
PULSOUT 6,5
PAUSE 10
NEXT
TOGGLE 5
LOOP
Olhando um Potenciômetro Digital por Dentro
A Figura 9-8 mostra um diagrama do potenciômetro dentro do AD5220. O AD5220 tem
128 elementos resistivos, cada um deles é de 78.125 Ω (valor nominal). Todos estes 128
somam 10.000 Ω ou 10 kΩ.
3
A1
78 Ω
Ad5220
pos. 127
1 CLK
2 U/D
5
7 CS
78 Ω
pos. 126
W1
40 Ω
78 Ω
pos. 125
…
Figura 9-8
Dentro do AD5220
…
78 Ω
pos. 1
78 Ω
B1
pos. 0
6
Um valor nominal significa um valor nomeado. Peças como resistores e
capacitores normalmente têm um valor nominal e tolerância. Cada um dos
elementos resistivos do AD5220 tem um valor nominal de 78.125 Ω, acima ou
abaixo do valor nominal com uma tolerância de 30% (23,438Ω), acima ou abaixo
do valor nominal.
Página - 245
Entre cada um desses elementos resistivos há um interruptor, chamado tomada. Cada
interruptor é na verdade um grupo de transistores que são ligados ou desligados para
permitir ou não a passagem de corrente. Apenas um destes interruptores pode ser
fechado de uma só vez. Se uma das chaves superiores estiver fechada (na pos. 125, 126,
ou 127), é como ter o botão do potenciômetro manual girado mais ou todo para o
sentido horário. Se pos. 0 ou 1 estiver fechada, é como ter um potenciômetro manual
girado todo para o sentido anti-horário.
Imagine que pos. 126 está fechada. Se você quiser definir a tomada para 125, (pos.
aberta 126 e pos. fechada 125), ajuste U/D baixo, em seguida, aplique um pulso para
CLK. Se você quiser definir a tomada para Pos 127, ajuste L/D em alta, e aplique 2
pulsos. Se você quiser trazer a tomada até 1, defina U/D baixo e aplique 126 pulsos.
Este próximo programa de exemplo usa o DEBUG Terminal para perguntar que
interruptor você deseja. Em seguida, ele decide se define o pino U/D para alto ou baixo,
e aplica o número correto de pulsos que deslocará o interruptor de sua configuração
antiga para a nova.
Com a exceção de EEPROM DATA, o próximo programa de exemplo também tem
todas as seções que você normalmente espera encontrar em um programa de aplicação:
•
•
•
•
•
•
•
•
Título - comentários que incluem o nome de um programa, sua descrição e as
diretivas Stamp e PBASIC.
EEPROM Data - declarações DATA que armazenam listas predefinidas de
valores em partes da memória EEPROM que não são necessárias no
armazenamento do programa.
Definições de I/O - Diretivas PIN que são chamadas de pinos de I/O.
Constantes - CON declarações que nomeiam os valores no programa.
Variáveis - VAR declarações que atribuem nomes as partes da memória RAM
do BASIC Stamp para armazenar valores.
Inicialização - uma rotina que faz o programa começar com o pé direito. Neste
próximo programa, o interruptor do potenciômetro precisa ser derrubado para
baixo de zero.
Principal – rotina que manipula as tarefas primárias do programa.
Sub-rotinas - segmentos de código que fazem trabalhos específicos, ou para um
ou para outro, neste caso, para a rotina principal.
Exemplo de Programa: TerminalControlledDigtialPot.bs2
Você pode usar este programa de exemplo e o DEBUG Terminal para definir o
interruptor do potenciômetro digital. Ao alterar a configuração do interruptor do
potenciômetro digital, você altera o brilho do LED ligado ao transistor que controla o
potenciômetro digital. A Figura 9- 9 mostra um exemplo de entrada do valor de 120 na
janela de transmissão do DEBUG Terminal enquanto o programa está sendo executado.
Uma vez que a configuração antiga do interruptor estava em 65, o LED tornou-se
aproximadamente duas vezes mais brilhante do que quando ajustado para 120.
Página - 246
Figura 9-9
Enviando mensagens
para o BASIC Stamp.
Janelas
Transmite →
Clique na janela de
transmissão (superior)
e digite os números
para nova
configuração do
interruptor.
Recebe →




'
'
'
'
Coloque e execute TerminalControlledDigtialPot.bs2.
Verifique se a caixa Echo Off não está marcada.
Clique na janela de transmissão do DEBUG Terminal para colocar o cursor lá.
Digite valores de 0 a 127 para o DEBUG Terminal. Certifique-se de pressionar a
tecla Enter depois de digitar os algarismos.
-----[ Título ]----------------------------------------------------O que é um Microcontrolador - TerminalControlledDigitalPot.bs2
Atualiza o botão do potenciômetro digital com base na entrada do
usuário no Debug Terminal.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ EEPROM Data ]-----------------------------------------------' -----[ Definições de I/O ]-----------------------------------------UdPin
ClkPin
PIN
PIN
5
6
' Configura valores dos pinos de
' I/O conectados à CLK e U/D
' -----[ Constantes ]------------------------------------------------DelayPulses
DelayReader
CON
CON
10
2000
' Atrasa para observar o LED
' apagar
' -----[ Variáveis ]-------------------------------------------------counter
oldTapSetting
newTapSetting
VAR
VAR
VAR
Byte
Byte
Byte
' Contador para FOR...NEXT
' Configuração do botão anterior
' Nova configuração de botão
' -----[ Inicialização ]---------------------------------------------oldTapSetting = 0
newTapSetting = 0
' Inicializa nova e velha old
' configuração do botão para 0
LOW UdPin
' Configura pino U/D para Down
' Configura botão para posição
' mais baixa
PULSOUT 6,5
PAUSE 1
NEXT
PAUSE 1000
' Aguarda 1s antes da 1a msg
' -----[ Rotina Principal ]-------------------------------------------
Página - 247
DO
GOSUB Get_New_Tap_Setting
GOSUB Set_Ud_Pin
GOSUB Pulse_Clk_pin
'
'
'
'
Display do usuário e obtém
entrada
Configura pino U/D para up/down
Entrega pulsos
LOOP
' -----[ Sub-rotinas ]-----------------------------------------------Get_New_Tap_Setting:
' Exibe instruções e obtém
' entrada do usuário para nova
DEBUG CLS, "Configuração do botão é: ", ' configuração do valor do
' botão
DEC newTapSetting, CR, CR
DEBUG "Informe novo botão", CR, "setting (0 TO 127): "
DEBUGIN DEC newTapSetting
RETURN
Set_Ud_Pin:
' Examina novo e velho valor
' para decidir valor do pino U/D
IF newTapSetting > oldTapSetting THEN ' Notifica usuário se valores
HIGH UdPin
' são iguais
oldTapSetting = oldTapSetting + 1 ' Incrementa para Pulse_Clk_pin
ELSEIF newTapSetting < oldTapSetting THEN
LOW UdPin
oldTapSetting = oldTapSetting - 1 ' Decrementa para Pulse_Clk_pin
ELSE
DEBUG CR, "Nova e velha configurações ", CR,
"são iguais, tente ", CR,
"de novo...", CR
PAUSE DelayReader
' Dá tempo para visualizar
ENDIF
' mensagem
RETURN
Pulse_Clk_pin:
' Entrega valores de velhos a novos valores. Lembre-se que
' Set_Ud_Pin
' ajustou o valor de oldTapSetting para newTapSetting por um.
' Isso mantém o loop FOR...NEXT executando de uma a várias vezes.
FOR counter = oldTapSetting TO newTapSetting
PULSOUT ClkPin, 1
PAUSE DelayPulses
NEXT
oldTapSetting = newTapSetting
RETURN
' Acompanha novos e velhos
' valores de tapSetting
SUMÁRIO
Este capítulo introduziu circuitos integrados e como eles podem ser usados com o
BASIC STAMP. Um transistor foi utilizado como uma válvula de corrente e um
potenciômetro digital foi usado para controlar a quantidade de corrente que passa
Página - 248
através do transistor. Ao examinar o potenciômetro digital foram introduzidos marca de
referência e mapa do pino como elementos importantes dos chips eletrônicos. Foi
discutida a função de cada um dos pinos do potenciômetro digital, assim como a
estrutura interna do dispositivo. O comando PBASIC TOGGLE foi introduzido como um
meio para salvar a memória do programa.
Questões
1. Quais são os nomes dos terminais do transistor que você usou neste capítulo?
2. Que terminal controla a corrente que passa através do transistor?
3. O que você pode fazer para aumentar ou diminuir a passagem de corrente
através do transistor?
Exercício
1. Escreva um programa que ajusta o interruptor no potenciômetro digital para a
posição 0, independente de sua configuração atual.
Projeto - Desafio Avançado
1. Adicionar um fototransistor ao seu projeto e fazer com que o brilho do LED seja
ajustado com o brilho visto pelo fototransistor. Nota: vale a pena ler a solução
dada, pois demonstra uma abordagem útil para o dimensionamento de uma
entrada para uma saída.
Soluções
Q1.Emissor, base e coletor.
Q2.A base controla a corrente que passa através do transistor.
Q3.Aumentar ou diminuir a corrente permitida na base do transistor.
E1. Para resolver este exercício, olhe para TerminalControlledDigitalPot.bs2. A
primeira coisa que ele faz, na seção de inicialização, é definir o botão para a
posição mais baixa. O código exato está na solução abaixo.
' O que é um Microcontrolador - Ch9Ex01_SetTapToZero.bs2
' Vire o botão no potenciômetro digital até o fim, zero.
' {$STAMP BS2}
' {$PBASIC 2.5}
UdPin
ClkPin
counter
PIN
PIN
VAR
LOW UdPin
PULSOUT ClkPin,5
PAUSE 1
NEXT
5
6
Byte
' Configura valores dos pinos
' I/O conectados à CLK e U/D
' Contador de FOR...NEXT
' Configura pino U/D p/ Down
' Configura botão para
' posição mais baixa
Página - 249
P1. Usar o circuito do potenciômetro digital a partir da Figura 9-6 na página 238 e o
circuito do fototransistor da Figura 7-4 na página 171.
Esta solução se baseia no TerminalControlledDigitalPot.bs2, e incorpora
elementos do PhototransistorAnalogToBinary.bs2 do Capítulo 7, Atividade #5.
Aplica-se também alguma álgebra para resolver um problema de escala que faz
com que o intervalo de valores que você poderia conseguir a partir da medida
que o fototransistor RCTIME se encaixe em um intervalo de 0 a 128 para o
potenciômetro digital. Tenha em mente que este é exemplo de solução, e, de
modo algum, a única solução ou abordagem.
O sub-rotina GOSUB Get_New_Tap_Setting chamada do programa
TerminalControlledDigitalPot.bs2 é substituída por duas outras chamadas de
GOSUB
Read_Phototransistor
e
GOSUB
sub-rotinas:
Scale_Phototransistor.
Da
mesma
forma,
a
sub-rotina
Get_New_Tap_Setting
é
substituída
pelas
sub-rotinas
Read_Phototransistor
e
Scale_Phototransistor.
Read_Phototransistor é uma versão da sub-rotina dos comandos que levam
a medição RCTIME do fototransistor e limitam a sua gama de entrada em
PhototransistorAnalogToBinary.bs2. Os nomes do pino, das constantes e das
variáveis foram ajustados, e o PAUSE 100 para uma exibição de 10 vezes por
segundo foi alterado para PAUSE 1, que é tudo que é necessário para carregar o
capacitor antes de tomar a medida RCTIME. Depois que esta sub-rotina
armazenar um valor na variável lightReading, ele será algo entre ValMin
(100) e ValMax (4000). Certifique-se de testar e ajustar esses valores para
suas próprias condições de iluminação.
O problema que temos agora é que existem apenas 128 interruptores
configurados e 3.900 possíveis medidas RCTIME para o fototransistor. Para
corrigir isso, precisamos dividir a medição RCTIME do fototransistor por algum
valor para torná-lo apto para a faixa de 0 a 127. Então, nós sabemos que
precisamos dividir a gama de valores de entrada por algum valor para fazê-lo
caber em 128 valores. Isto é parecido com uma equação:
Range of Possible Phototransistor Measurements
= 128 Possible Tap Settings
Scale Divisor
Para resolver isso, multiplique ambos os lados da equação pelo Scale Divisor, em
seguida, divida ambos os lados por 128 possíveis configurações do interruptor.
Scale Divisor =
Range of Possible Phototransistor Measurements
128 Possible Tap Settings
No código, o leque de possíveis medidas do fototransistor é ValMax ValMin, scaleDivisor é uma variável, e 128 é uma constante. Assim, este
código a partir seção Declarações e Inicialização (Declarations and
Initialization) estabelece o valor de scaleDivisor assim:
scaleDivisor = (valMax – valMin) / 128
Página - 250
medição RCTIME do fototransistor, a sub-rotina
Scale_Phototransistor subtrai valMin de lightReading e depois divide
a medição por scaleDivisor. O resultado mapeia a faixa de medição 100 a
4000 entradas para 0 a 127 saídas da faixa de ajuste do interruptor.
Depois
de
cada
Scale_Phototransistor:
lightReading = (lightReading – valMin) / scaleDivisor
RETURN
Assumindo que ValMin é 100 e ValMax é 4000, a variável lightReading
poderia armazenar 3.900 valores possíveis. E se a faixa de entrada foi ValMin
= 10.000 para ValMax = 13900? Ao subtrair ValMin = 10.000, ainda
existem 3900 valores possíveis, e dividir scaleDivisor corretamente é que
vai mapear a medida para o ajuste do interruptor do potenciômetro digital
correspondente. Se o seu código não subtrair primeiro ValMin, o valor
resultante em escala seria completamente fora do intervalo de 0 a 128 para o
potenciômetro digital
' O que é um Microcontrolador Ch9Prj01_PhotoControlledDigitalPot.bs2
' Atualiza botão do potenciômetro digital baseado na leitura do
' Fototransistor
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Declarações e Inicialização ]---------------------------UdPin
ClkPin
PhotoPin
DelayPulses
DelayReader
valMax
valMin
PIN
PIN
PIN
CON
CON
CON
CON
5
6
2
10
2000
4000
100
'
'
'
'
counter
oldTapSetting
newTapSetting
lightReading
scaleDivisor
VAR
VAR
VAR
VAR
VAR
Byte
Byte
Byte
Word
Word
'
'
'
'
'
Config. valores dos pinos I/O
conectados à CLK e U/D.
Fototransistor no pino P2
Atraso p/ observar LED apagar
' Valor máx. fototransistor
' Valor min. fototransistor
Contador para FOR...NEXT
Configuração anterior do botão
Nova configuração do botão
lida pelo fototransistor
Para valores de escala
' Estabelece um valor que pode ser dividido em uma medida do
' RCTIME do fototransistor para dimensionar sua escala em um
' intervalo de 0 à 128
scaleDivisor = (valMax - valMin) / 128
oldTapSetting = 0
newTapSetting = 0
' Inicializa nova e velha
' configuração do botão em zero
LOW UdPin
' Configura pino U/D para Down
' Configura botão para posição
' mais baixa
PULSOUT ClkPin,5
PAUSE 1
'
Página - 251
NEXT
PAUSE 1000
' 1 s antes da primeira mensagem
' -----[ Rotina principal ]--------------------------------------DO
GOSUB Read_Phototransistor
GOSUB Scale_Phototransistor
newTapSetting = lightReading MIN 1 MAX 127
DEBUG HOME, DEC5 lightReading
GOSUB Set_Ud_Pin
' Configura pino U/D p/ up/down
GOSUB Pulse_Clk_pin
' Entrega pulsos
LOOP
' -----[ Sub-rotinas ]-------------------------------------------Set_Ud_Pin:
' Examina velho e novo
IF newTapSetting > oldTapSetting THEN 'valor do botão p/ decidir
HIGH UdPin
ELSEIF newTapSetting < oldTapSetting THEN 'valor de UdPin. Avisa
LOW UdPin
' usuário se os valores
ENDIF
' forem iguais
RETURN
Pulse_Clk_pin:
' Entrega pulsos
FOR counter = oldTapSetting TO newTapSetting ' do velho a novo
PULSOUT ClkPin, 1
' valor
PAUSE DelayPulses
NEXT
oldTapSetting = newTapSetting
' Controla novo e velho valor
RETURN
' de tapSetting
Read_Phototransistor:
HIGH PhotoPin
PAUSE 1
RCTIME PhotoPin, 1, lightReading
lightReading = lightReading MAX valMax MIN valMin
RETURN
Scale_Phototransistor:
lightReading = (lightReading - valMin) / scaleDivisor
RETURN
Página - 252
Capítulo 10: Protótipos De Suas Próprias Invenções
Este texto introduziu conceitos básicos de um computador de bordo em projetos e
invenções. Você agora já tem alguma experiência com os componentes de um circuito
comum em produtos de uso diário que incluem: luzes indicadoras, botões, servos,
mostradores, displays digitais, sensores de luz, alto-falantes, transistores, e outros
circuitos integrados. Você agora também já sabe conectar esses circuitos para o
microcontrolador BASIC Stamp e escrever códigos para testar cada um deles, bem
como integrá-los em pequenas aplicações.
A esta altura, você pode estar interessado em usar suas novas habilidades para inventar
alguma coisa, ou para saber mais, ou talvez ambos. O que você aprendeu neste livro
pode introduzi-lo no caminho para fazer protótipos para uma ampla variedade de
invenções. Neste capítulo, vamos usar um sistema de micro alarme, por exemplo, um
protótipo de um dispositivo familiar. Ao longo do caminho, nós vamos cobrir algumas
técnicas e práticas importantes de prototipagem, incluindo:
•
•
•
•
•
•
•
Sugestões para iniciar o desenvolvimento de suas ideias de design e invenções;
Um exemplo de como construir e testar cada subsistema no protótipo;
Exemplos de como incorporar o código de teste para o código do projeto;
Boas práticas de comentários de código e versões de arquivos;
Exemplos de como usar peças conhecidas como dispositivos substitutos com
interfaces semelhantes;
Dicas e truques para superar os obstáculos dos últimos projetos;
Qual o próximo passo para encontrar mais projetos Stamps in Class e
dispositivos interessantes;
APLICANDO O QUE VOCÊ SABE COM OUTRAS PEÇAS E
COMPONENTES
O circuito do botão de pressão que vimos no Capítulo 3 é um exemplo de um
dispositivo de entrada muito simples, que converte uma condição física (mesmo que
alguém tenha ou não pressionado um botão), para um sinal de alta ou baixa, que o Basic
Stamp pode detectar e processar. Você também usou botões em aplicações para
controlar luzes piscando, posições do servo e tons do alto-falante. Existem muitos
sensores que detectam uma condição física diferente de "contato" que também enviam
sinais de alta ou baixa a um pino de I/O que o BASIC Stamp pode monitorar. Alguns
exemplos incluem gás, movimento e sensores de som e muitos outros mais. Agora que
você já tem experiência em fazer o BASIC Stamp monitorar um circuito de botão, o
monitoramento de um som ou sensor de movimento é muito semelhante, e, certamente,
um próximo passo razoável.
Outra técnica deste livro é a medição da queda de RC com o comando RCTIME para
sentir a posição do botão do potenciômetro e os níveis de luz, tanto com um
fototransistor ou com um LED. Estes exemplos são apenas a ponta do iceberg em
termos de sensores, que podem ser usados com um circuito de decaimento RC. Outros
exemplos incluem umidade, temperatura e pressão e, ainda, é só o começo. A luz
indicadora de LED proporciona ainda outro exemplo de circuito que representa uma
variedade de circuitos, com diferentes funções. O circuito de LED é controlado pela
saída do pino de I/O de alta/baixa do BASIC Stamp. Com circuitos de suporte
Página - 253
adicionais, você pode usar os sinais de alta/baixa para fazer motores elétricos irem para
frente e para trás, ligar/desligar as luzes, dispositivos de aquecimento e muito mais.
Agora, pense em todos os outros dispositivos que você experimentou neste livro. Cada
um deles é apenas um exemplo de uma lista de dispositivos com interfaces semelhantes
que você pode usar para criar protótipos para todo tipo de invenções.
PROTÓTIPO DE UM MICRO SISTEMA DE SEGURANÇA
Neste capítulo, vamos usar peças do BASIC Stamp - Kit de Atividades para fazer um
pequeno protótipo de sistema de segurança que você poderá usar em uma mesa,
aparador, caixa de ferramentas, ou armário. Pode servir para aqueles irmãos ou colegas
de trabalho que você suspeita que pegam suas coisas sem pedir. Com este protótipo, nós
também vamos investigar outras peças e componentes que você pode substituir em seu
sistema de segurança que operam sobre os mesmos princípios que as peças dos kits
familiares, mas poderia dar ao seu sistema uma funcionalidade muito maior. A partir
daí, veremos como encontrar, entender, testar e incorporar outras peças que você pode
nunca ter trabalhado antes.
Página - 254
ATIVIDADE #1: DA IDEIA A PROVA DE CONCEITO
Muitos produtos começam como uma ideia, em alguns casos, uma invenção que poderia
ser "muito legal", e em outros é algo que resolve um problema. Esta ideia pode ser
desenvolvida em um conceito com desenhos e especificações e em algum projeto inicial
de trabalho. O próximo passo é, tipicamente, desenvolver um protótipo de trabalho.
Pode não ser bonito, mas deve demonstrar de forma confiável que um dispositivo pode
ser feito para funcionar de acordo com o conceito e especificação. Em empresas que
desenvolvem produtos, esta prova de conceito é, normalmente, necessária para obter a
aprovação, gestão e financiamento para continuar o desenvolvimento do produto.
Ideia, Conceito e Descrição das Funções
Digamos que você tenha um armário com uma porta em uma dobradiça e uma gaveta, e
ele precisa de um sistema de alarme muito pequeno. Ou talvez você deseja criar um
gabinete especial embutido com segurança. A Figura 10-1 mostra um esboço da forma
como um potenciômetro e contato elétrico semelhante a um botão de pressão pode ser
utilizado para detectar quando uma porta ou gaveta estiver aberta. Este esboço é
semelhante a um diagrama de conceito, que se concentra apenas em transmitir o que o
produto ou a invenção faz.
Figura 10-1
Esboço da modelo de
um micro Sistema de
Segurança de um
Gabinete
A descrição funcional é importante. Quando você tem uma ideia melhor do que o seu
dispositivo está, a princípio, para fazer, evita problemas que poderão acontecer se você
tiver que redesenhar o dispositivo para acomodar algo que você não pensava. Designers
e empresas que criam dispositivos personalizados para os clientes têm que ter muito
cuidado ao interrogar os seus clientes para entender o que eles desejam. Especialmente,
para os dispositivos feitos sob medida, redesenhar pode ser extremamente caro e
demorado.
Aqui está um exemplo de uma breve descrição funcional que podemos usar para o nosso
sistema simples: Desenvolver um protótipo de circuito e programa para um micro
sistema de alarme que pode monitorar uma pequena porta que tem uma dobradiça e uma
gaveta. Se armado, o alarme deve soar se a porta ou gaveta estiver aberta. Um LED de
Página - 255
status deverá brilhar verde quando o alarme não estiver armado, e vermelho quando
estiver. Um protótipo pode ser armado e desarmado pelo controle do computador. Um
tempo de atraso deve ser incorporado depois que o dispositivo foi armado para permitir
que o usuário feche o gabinete.
Especificação
Além da descrição funcional, se possível, uma especificação normalmente é responsável
pelos muitos aspectos do dispositivo proposto, incluindo: custo, consumo de energia,
tensão, dimensões, peso, volume do alto-falante, entre outros detalhes.
Design Inicial
Muitas vezes, o projeto inicial envolve um brainstorming de abordagens que "pode"
resolver o problema de design, e muitas dessas ideias têm de ser testadas para saber se
elas realmente são viáveis. Outras partes do projeto podem envolver peças bastante
normais ou comuns e práticas de design. Nosso micro alarme se encaixa nesta categoria,
pelo menos, para o protótipo. Um botão de pressão pode ser montado no armário de
modo que quando a gaveta for fechada, ela pressionará o botão de pressão. Para a
dobradiça de uma porta, um potenciômetro poderá ser ligado de modo que torça com a
porta e possa detectar a posição da mesma. O LED bicolor é um indicador familiar, e o
piezospeaker é, certamente, um gerador de ruído já bem familiar.
Então, agora já conhecemos os circuitos necessários para o nosso micro protótipo de
segurança do gabinete: LED bicolor, botão, potenciômetro e piezospeaker. Aqui está
uma lista de capítulos e atividades, onde cada um desses circuitos foi introduzido:
•
•
•
•
LED Bicolor: Capítulo 2, Atividade #5
Botão: Capítulo 3, Atividade #2
Potenciômetro: Capítulo 5, Atividade #3
Piezospeaker: Capítulo 8, Atividade #1
Lista de Peças do Alarme do Gabinete
Retornando a todos os capítulos e colocando todas as peças juntas, você obterá essa lista
de peças:
(1) LED – bicolor
(1) Piezospeaker
(4) Fios
Esquema do Alarme do Gabinete
O esquema na Figura 10-2 é organizado para dar a todos os componentes muito espaço
para a protoboard, por isso nem todas as conexões dos pinos de I/O são as mesmas dos
capítulos anteriores. Você terá que ter isso em mente quando colher exemplos de código
a partir dos capítulos anteriores para testar cada um dos circuitos.
Página - 256
Figura 10-2: Esquema do Protótipo do Sistema de Alarme
ATIVIDADE #2: CONSTRUIR E TESTAR CADA CIRCUITO
INDIVIDUALMENTE
Sempre que possível, teste cada subsistema individualmente antes de tentar fazê-los
trabalhar juntos. Se você seguir esta regra, seus projetos serão mais tranquilos, e isto
economizará tempo para resolução dos problemas. Por exemplo, se todos os circuitos
são construídos, mas não testados, as pessoas têm uma tendência natural de gastar muito
tempo examinando o código e esquecer de verificar cada circuito. Assim, a economia de
tempo, mais importante, neste processo é garantir que não há erros de circuito do que
você tentar se enganar pensando que eles são erros de codificação.
Construindo e Testando Cada Circuito
Esta atividade se concentra nos subsistemas individuais, construção e teste de cada
circuito. Uma vez que o circuito de botão for construído e testado, vamos construir e
testar o circuito de alto-falante. Depois de repetir esse processo com o potenciômetro e
com o LED bicolor. Assim, os circuitos já serão todos "bem conhecidos" e estarão
prontos para aplicação de alguns códigos.
 Encontre o código de teste no Capítulo 3, Atividade #2 para que você possa
adaptar e testar o circuito de botão da Figura 10-2.
 Altere as referências dos pinos de I/O para que ele funcione com o circuito na
Figura 10-2.
Página - 257
 Teste o código e corrija eventuais defeitos (bugs) ou erros de fiação antes de
continuar.
 Repita este mesmo processo para:
o Circuito do Piezospeaker: Capítulo 8, Atividade #1
o Circuito do Potenciômetro: Capítulo 5, Atividade #3
o Circuito do LED bicolor: Capítulo 2, Atividade #5
 Certifique-se de salvar cada programa modificado sob um novo nome, de
preferência em uma pasta separada, talvez chamada "WAM Capítulo 10".
Sua Vez – Sistema de Teste
Agora que todos os circuitos estão testados, e todos os programas de teste salvos no seu
PC, é hora de construir um teste do sistema que exibe mensagens de debug, indicando
que o circuito está sendo testado e como ele executa o código de teste. Este é um
exercício útil, pois os sistemas de alarme têm auto teste e formas de diagnóstico que
utilizam todos os recursos em uma rotina.
 Combine os elementos em seus programas de teste em um único programa que:
o Comece por exibir a cor do LED bicolor no DEBUG Terminal conforme
ele atualiza a cor....
o Em seguida, exibe uma mensagem dizendo que o piezospeaker está
emitindo um som enquanto ele apita...
o Finalmente entre em um loop que relata repetidamente o sensor do botão
da gaveta e o status do sensor do potenciômetro na dobradiça da porta no
DEBUG Terminal.
 Teste e corrija todos os erros antes de continuar.
ATIVIDADE #3: ORGANIZAR A CODIFICAÇÃO DE TAREFAS EM
PEQUENOS PEDAÇOS
Assim como cada circuito deve ser construído e testado antes de fazê-los trabalhar
juntos, cada característica do código também deve ser desenvolvida e testada,
individualmente, antes de incorporá-la a uma aplicação maior. MicroAlarmProto(Dev009).bs2 é o exemplo de um programa que está em seu caminho para uma prova de
conceito. Sua interface do DEBUG Terminal está no lugar, e o sistema de alarme circula
corretamente através de suas várias formas ou estados, incluindo não armado, armando,
armado e disparado.
Neste ponto, a sub-rotina Alarm_Arming no final do programa ainda está em
construção. Ela tem um código no lugar que dispara o alarme se o botão de pressão for
liberado, o que indica que a gaveta foi aberta, mas que ainda não monitora a dobradiça
da porta. O código do potenciômetro tem de ser adicionado à sub-rotina
Check_Sensors que mede a sua posição. Se a sua posição estiver além de um certo
limite, 15, por exemplo, a variável state, deve ser alterada para triggered. Duas tarefas
adicionais, que permanecem, são ligar o LED bicolor verde quando o alarme não estiver
armado, e vermelho, quando ele estiver. Estas tarefas restantes são indicadas pelos
comentários no código que se parecem com estes:
' A Fazer: LED bicolor verde
...
Página - 258
' A Fazer: LED bicolor vermelho
...
' A Fazer: Verificar se o potenciômetro está acima do limite
de valor. Se sim, então, engatilhe o alarme.
 Coloque manualmente o Hand-enter MicroAlarmProto(Dev-009).bs2 no BASIC





Stamp
Editor
(recomendado),
ou
baixe-o
a
partir
de
www.parallax.com/go/WAM e abra-o com o BASIC Stamp Editor.
Analise o programa e observe como cada sub-rotina é modular e faz um trabalho
específico. Isso faz parte da organização de tarefas de codificação em pequenos
pedaços.
Se você não se lembra de como usar a janela de Transmissão e Recebimento no
DEBUG Terminal (Debug Terminal’s Transmit and Receive), reveja a Figura 99 na página 246.
Carregue o MicroAlarmProto(Dev-009).bs2 para o BASIC Stamp e use a janela
de transmissão do DEBUG Terminal para digitar o caractere A para armar o
alarme, e D para desarmar o alarme. O sistema faz uma breve contagem
regressiva antes de armar o alarme. Certifique-se de pressionar e segurar o botão
antes de armar o alarme.
Enquanto o alarme está armado, solte o botão. Você terá a chance de desarmar o
alarme após alguns segundos do alarme soar.
Arme o alarme novamente. Desta vez, digite "D" para desarmar o alarme antes
de soltar o botão.
' -----[ Título ]----------------------------------------------------' O que é um Microcontrolador - MicroAlarmProto(Dev-009).bs2
' Teste do sistema de alarme de armário.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Target = BASIC Stamp 2
' Linguagem = PBASIC 2.5
' -----[ Constants ]-------------------------------------------------NotArmed
Arming
Armed
Triggered
CON
CON
CON
CON
0
1
3
4
' Estados do sistema de alarme
' -----[ Variables ]-------------------------------------------------seconds
counter
char
state
VAR
VAR
VAR
VAR
Word
Byte
Byte
Nib
' Armazena contagem de segundos
' Para contagem
' Armazena caracteres
' Armazena estado do sistema de alarme
' -----[ Inicialização ]---------------------------------------------PAUSE 1000
DEBUG "Programa funcionando..."
state = NotArmed
' Aguarda 1 segundo
' Exibe mensagem de funcionamento
' Inicializa estado do alarme
' -----[ Rotina principal ]------------------------------------------DO
SELECT state
CASE NotArmed
' Loop principal
' Avalia estado caso a caso
' Se estado = não armado
Página - 259
GOSUB Prompt_to_Arm
CASE Arming
GOSUB Alarm_Arming
CASE Armed
LOOP
GOSUB Check_Sensors
GOSUB Prompt_to_Disarm
CASE Triggered
GOSUB Alarm_Triggered
ENDSELECT
'
'
'
'
'
'
'
'
'
'
'
'
Faz: LED bicolor verde
Chama Prompt_to_Arm
Se estado = Armando
Chama Alarm_Arming
Se estado = Armado
Faz: LED bicolor vermelho
Chama Check_Sensors
Chama Prompt_to_Disarm
Se estado = Acionado
Chama Alarm_Triggered
Termina de avaliar caractere
Repete loop principal
' =====[ Sub-rotinas ]================================================
' -----[ Sub-rotina - Prompt_To_Arm ]--------------------------------Prompt_to_Arm:
DEBUG CLS, "Pressione A para armar", CR, ">" ' Exibe mensagem
GOSUB Get_User_Input
' Chama Get_User_Input
RETURN
' Retorna de Prompt_to_Arm
' -----[ Sub-rotina - Prompt_to_Disarm ]-----------------------------Prompt_to_Disarm:
DEBUG CLS, "Pressione D para desarmar", CR, ">" ' Exibe mensagem
GOSUB Get_User_Input
' Chama Get_User_Input
RETURN
' Retorna de Prompt_to_Disarm
' -----[ Sub-rotina - Alarm_Arming ]---------------------------------Alarm_Arming:
DEBUG CLS, "Feche a porta.",
' Avisa usuário para fechar a porta
CR, "Você tem"
FOR seconds = 8 TO 0
' Contagem regressiva
DEBUG CRSRX, 9, DEC seconds, CLREOL,
' Exibe tempo restante
" segundos..."
PAUSE 1000
' Aguarda 1 segundo
NEXT
' Repete contagem regressiva
state = Armed
' Configura estado da variável para Armado
RETURN
' Retorna de Alarm_Arming
' -----[ Sub-rotina - Alarm_Armed ]----------------------------------Alarm_Armed:
DO
GOSUB Prompt_To_disarm
GOSUB Check_Sensors
LOOP UNTIL state <> Armed
RETURN
'
'
'
'
'
Loop Armado
Busca por entrada do usuário
Checa sensores
Repete até estado não armado
Retorna de Alarm_Armed
' -----[ Sub-rotina - Alarm_Triggered ]------------------------------Alarm_Triggered:
DO
DEBUG CLS, "Alarme acionado!!!"
FREQOUT 6, 100, 4500
PAUSE 100
NEXT
' Loop do Alarme Acionado
' Exibe aviso
' Toca 15 tons de alarme
' 3 s para usuário desarmar
Página - 260
IF state <> triggered THEN EXIT
NEXT
LOOP UNTIL state <> triggered
' Repete até desarme
' -----[ Sub-rotina - Get_User_Input ]-------------------------------Get_User_Input:
char = 0
' Limpa variável de caractere
SERIN 16, 84, 500, Timeout_Label, [char] ' Aguarda 0,5 s para
' pressionarem tecla
GOSUB Process_Char
' Com tecla, chama Process_Char
Timeout_Label:
' Sem tecla, pula chamada
RETURN
' Retorna de Get_User_Input
' -----[ Sub-rotina - Process_Char ]---------------------------------Process_Char:
SELECT char
' Avalia caractere caso a caso
CASE "A", "a"
' Se "A" ou "a"
state = Arming
' Muda estado da variável para Armando
CASE "D", "d"
' Se "D" ou "d"
state = NotArmed
' Muda estado da variável para Não Armado
CASE ELSE
' Se não for "A", "a", "D",
"d"
DEBUG "Wrong character, try again" ' Exibe mensagem de erro
PAUSE 2000
' Dá 2 s para usuário ler
ENDSELECT
' Termina de avaliar caractere
RETURN
' Retorna de Process_Char
' -----[ Sub-rotina - Check_Sensors ]--------------------------------Check_Sensors:
' Faz: Verifica se o potenciômetro está no valor limite.
' Se sim, então, aciona o alarme
IF IN0 = 0 THEN state = Triggered
' Botão liberado? Dispara alarme.
RETURN
' Retorna de Check_Sensors
Novas Técnicas de Codificação no Código de Exemplo
Dê uma olhada no segundo loop FOR...NEXT na subrotina Alarm_Triggered:
IF state <> triggered THEN EXIT
NEXT
Se uma chamada para a sub-rotina Prompt_to_Disarm resultar em uma mudança na
variável de estado, a instrução IF...THEN usa EXIT para sair do loop FOR...NEXT
antes que sejam feitas as 6 repetições.
Outro novo comando chamado SERIN aparece na sub-rotina Get_User_Input. DEBUG e
DEBUGIN são versões especiais dos comandos SEROUT e SERIN. Para ver como isso
funciona, tente substituir o comando DEBUG do “Programa funcionando...” por SEROUT
16, 84, ["Programa funcionando..."]. Ao contrário dos comandos DEBUG e DEBUGIN, os
comandos SEROUT e SERIN podem se comunicar com qualquer pino de I/O, ou pino 16
para comunicação com o DEBUG Terminal. Eles também têm códigos especiais que
Página - 261
você pode usar para selecionar a taxa de transmissão descrita nos comandos SERIN e
SEROUT tabelas de taxa de transmissão no manual do BASIC Stamp.
Get_User_Input:
char = 0
SERIN 16, 84, 500, Timeout_Label, [char]
GOSUB Process_Char
Timeout_Label:
RETURN
A sub-rotina Get_User_Input começa definindo a variável de char para 0 para
limpar os antigos valores que char pode estar armazenando. Em seguida, ela executa o
comando SERIN, com o seu valor opcional Timeout ajustado para 500 ms (metade de
um segundo), com a etiqueta de tempo limite opcional definida para Timeout_Label,
que está duas linhas abaixo. Se o comando SERIN receber um caractere dentro em 500
ms, ele armazenará o resultado na variável char e passará para a próxima linha, que
chamará a sub-rotina Process_Char. Se ele não conseguir um caractere em 500 ms,
ele saltará para Timeout_Label, o que faz com que ele pule sobre a sub-rotina
chamada.
Sua Vez – Próximos Passos para a Prova de Conceito
É hora de fazer este programa funcionar, como uma prova de conceito.
 Salve
uma
cópia
do
MicroAlarmProto(Dev-009).bs2
como
MicroAlarmProto(Dev-010).bs2.
 Use segmentos do seu código testado na Atividade #2 para completar os três
itens “Faz”.
 Teste seu código modificado, e quando ele estiver funcionando bem, salve uma
cópia do código como MicroAlarmProto(Dev-011).bs2.
ATIVIDADE #4: DOCUMENTAR O SEU CÓDIGO!
MicroAlarmProto (Dev-011).bs2 não está completamente terminado, porque ele ainda
precisa de alguma documentação e outras mudanças que tornam o programa mais fácil
de modificar e manter. Por exemplo, na sub-rotina Alarm_Triggered, o comando
FREQOUT 6, 100, 4500 tem o que alguns programadores chamam de "números
misteriosos”. Números misteriosos são valores que são usados de uma forma que o
observador casual possa não ser capaz de discernir com facilidade. Você poderia
reescrever este comando como FREQOUT SpeakerPin, BeepTime, AlarmTone. Depois,
você pode adicionar uma seção de diretivas Pin acima da seção Constants, e declarar
SpeakerPin PIN 6. Além disso, na seção Constants, declarar BeepTime CON 100, e
AlarmTone CON 4500.
Nem toda constante em um determinado programa tem que ser nomeada. Tenha em
mente que os números misteriosos são valores que são usados de uma forma que o
observador casual possa não ser capaz de discernir com facilidade. Outro exemplo a
partir da sub-rotina Alarm_Triggered é:
' 3 s para usuário desarmar
Página - 262
Os números 1 e 6 não são números misteriosos, porque é claro que eles fazem o loop
FOR...NEXT repetir seis vezes, e o comentário à sua direita indica que seis repetições
têm a duração de três segundos. Nem todos os supervisores podem concordar com essa
interpretação, e alguns podem enfaticamente proclamar que o 1 e o 6 são realmente
números misteriosos. Se você acabar de codificar o seu trabalho e seu chefe for um
defensor da nomeação de constantes, é uma boa ideia apenas aderir a qualquer estilo de
codificação.
 Vá para MicroAlarmProto(Dev-011).bs2 e documente os números misteriosos,
declarando as diretivas dos pinos e as constantes, e substituindo seus nomes por
números no programa.
 Uma exceção às diretivas PIN é o argumento Pin do comando SERIN, que deve
ser declarado como uma constante e não como um pino. Argumentos pinos são
para pinos de I/O e variam de P0 a P15. O argumento Pin 16 faz com que o
comando SERIN ouça o pino SIN do módulo BASIC Stamp, que está conectado
à porta de programação da sua placa.
Outra área onde a documentação MicroAlarmProto(Dev-011).bs2 ainda é fraca é nos
comentários que explicam cada rotina e sub-rotina. Cada sub-rotina deve ter
comentários que explicam o que ela faz, e qualquer variável depende dela para fazer seu
trabalho, e de todas as variáveis que a sub-rotina usa para armazenar os resultados antes
de seu RETORNO. Aqui está um exemplo de boa documentação adicionada ao início da
sub-rotina Process_Char.
' -----[ Sub-rotina - Process_Char ]--------------------------'Atualize a variável de estado com base no conteúdo da
'variável do tipo char. Se char contém "A" ou "a", a constante
'Armed fica armazenada no lugar. Se char contém "D" ou "d",
'a constante Not-Armed fica armazenada no lugar.
'
Process_Char:
'... code omitted here
RETURN
' Return from...
 Atualize as descrições entre os títulos das sub-rotinas e seus rótulos, e repita a
rotina principal também.
 Quando você terminar, salve uma cópia do seu código com o nome
MicroAlarmProofOfConcept(v1.0).bs2
Guardar Cópias e Números de Versão de Incremento Após Cada Pequena
Mudança
Não se esqueça de continuar salvando as cópias de seu código com os pequenos ajustes.
Isto facilita retroceder pequenos passos, para o código correto, se sua(s) mudança(s)
causar(em) erro(s). Por exemplo, antes de sua próxima modificação, salve o arquivo
como MicroAlarmProofOfConcept(v1.01).bs2, ou talvez mesmo v1.01a. Quando a sua
próximo função estiver totalmente implementada, escolha um passo de revisão razoável.
Se for uma revisão menor, tente v1.1, se grande, vá até a v2.0.
Página - 263
ATIVIDADE #5: DÊ AO SEU APP UMA SURPREENDENTE NOVA
FUNCIONALIDADE
Como mencionado anteriormente, cada circuito que você trabalhou neste texto é
realmente um exemplo de um grupo de componentes e módulos que interagem da
mesma maneira com o BASIC Stamp. A Figura 10-3 mostra algumas substituições de
peças que você poderia fazer para converter o atual sistema de segurança do gabinete
em um que vai proteger um objeto de estar a céu aberto. Esse sistema modificado pode,
em vez detectar movimentos na sala, também detectar se alguém levanta o objeto que
você deseja proteger:
•
•
Botão de pressão: saída alta-baixa → substitua pelo Sensor de movimento PIR
Potenciômetro: resistor variável → substitua pelo Sensor FLEXIFORCE
O sensor PIR detecta mudanças nos padrões de luz infravermelha passiva na área
circundante, e envia um sinal de alta para indicar que o movimento foi detectado, ou
envia um sinal de baixa para indicar que não houve nenhum movimento. A resistência
do sensor FLEXIFORCE varia com a força aplicada no ponto redondo da extremidade
(por exemplo, um objeto posicionado sobre ela), de modo que possa ser medida em um
circuito RC com o comando RCTIME.
Figura 10-3: Sensores para atualizar o sistema de alarme
Sensor
PIR
Sensor FLEXIFORCE
 Vá para www.parallax.com






e digite “motion detection” (detecção de
movimento) no campo “Search” (pesquisa) e clique no botão “Go” (ir).
Encontre o Sensor PIR nos resultados da pesquisa e vá para a página do produto.
Baixe a documentação do Sensor PIR (.pdf) e, opcionalmente, assista ao vídeo
do Sensor PIR. O arquivo PDF estará na seção Downloads da página.
Leia as explicações da documentação, esquemas e exemplos de código
PIR_Simple.bs2. Você pode substituir este sensor para um botão de pressão?
Volte para os seus resultados de busca (ou para a página inicial da Parallax) e
digite “pressure” (pressão) no campo de pesquisa. Então, siga o link do sensor
FLEXIFORCE.
Encontre-o e descompacte a Documentação de FLEXIFORCE e do códigofonte.
Na pasta descompactada, abra e leia a documentação, o diagrama esquemático, e
o código fonte do FLEXIFORCE Simple.bs2. Você pode substituir este sensor
por um potenciômetro?
Um exemplo passo-a-passo demonstra como as melhorias, tanto nesta como na
próxima atividade em um aplicativo de sistema de seu micro alarme pode ser
incorporado, siga o link Stamp in Class "Mini Projetos" em:
www.parallax.com/Education.
Página - 264
ATIVIDADE #6: SUPERANDO OBSTÁCULOS DO PROJETO
Agora que você está prestes a terminar as atividades com o BASIC Stamp - Kit de
Atividades, um dos passos mais importantes que você pode tomar é encontrar respostas
para as tarefas que você ainda não sabe como resolver com o seu microcontrolador.
Aqui estão as etapas gerais:
Passo 1:
Procure os componentes ou circuitos que poderiam resolver o seu
problema.
Passo 2:
Leia sobre o componente/circuito e descubra como ele funciona. Preste
especial atenção à forma como o BASIC Stamp seria necessário para interagir com o
componente/circuito.
Passo 3:
Descubra se o exemplo de código está disponível para o circuito ou
componente. Isso vai torná-lo muito mais fácil de ser incorporado à sua aplicação.
Vamos dizer que o próximo passo em seu projeto é exibir o status do sistema, sem a
conexão com o computador. Aqui está um exemplo de como você pode encontrar e
avaliar um componente para sua aplicação.
 (Etapa 1) Vá para www.parallax.com e tente o termo "display" no campo de
pesquisa. Na página inicial, você pode precisar clicar no botão Go em vez de
apenas pressionar Enter. Vá para as páginas do produto dos vários itens
resultantes da pesquisa e veja se você pode encontrar um que é relativamente
barato e capaz de exibir algumas linhas de texto.
Se você decidiu que o Parallax Serial 2x16 LCD na Figura 10-4 é um bom candidato,
você está no caminho certo. No entanto, qualquer display funcionará.
Figura 10-4
Parallax 2x16 Serial
LCD
 (Passo 2) Vá para a página do produto Parallax Serial 2x16 LCD. Se você não
tiver feito isso, leia a descrição do produto. Em seguida, localize o link da
Documentação em PDF do Parallax Serial 2x16 de LCD. Vai estar na página
“Downloads and Resources”, da seção, provavelmente, chamada "Parallax
Serial 2x16 LCD Documentation v2.0 (.pdf)”. A versão 2.0 pode ser mais
recente.
 (Passo 3) Verifique se há um exemplo de código na documentação em PDF do
Parallax Serial 2x16 LCD, bem como links para download do código na página
da web, seção Downloads and Resources. Procure um bom exemplo de
programa que seja curto, simples e que exiba uma mensagem de teste, pois
geralmente fornece um bom ponto de partida.
Página - 265
Após a breve introdução ao SERIN e SEROUT no exemplo de programa deste capítulo, o
exemplo de código para o Parallax Serial LCD, que se baseia em SEROUT, pode parecer
bastante familiar.
Se você seguir o link “Smart Sensors and Applications” (Sensores Inteligentes e
Aplicativos), você pode baixar os sensores inteligentes e aplicativos dos livros
didáticos, que têm um capítulo inteiro sobre como controlar esta exposição com o
BASIC Stamp 2.
Três Exemplos de Quantos Outros?
Os sensores PIR e FLEXIFORCE e o LCD Serial Parallax são três exemplos de
módulos e componentes que você pode usar para aumentar significativamente a
funcionalidade do seu protótipo. Estes três são apenas uma gota no oceano em
comparação com o que está disponível.
A Figura 10-5 mostra mais alguns módulos e componentes, que são apenas uma
pequena amostra. Os exemplos apresentados na figura são: (a) o módulo RF para
comunicação de rádio, (b) giroscópio para detectar a velocidade de rotação, (c) bússola
para encontrar direção, (d) sensor de vibração, (e) acelerômetro para detectar mudanças
de inclinação e de velocidade, (f) sensor de ultrassom para detectar a distância, (g)
sensor de intensidade de luz, (h) servo controlador, (i) controlador do motor DC, (j)
matriz Darlington para conduzir as bobinas do motor de passo e (k) motor de passo.
Você pode encontrar qualquer um destes dispositivos em www.parallax.com com uma
pesquisa por palavra chave. Por exemplo, para saber mais sobre o (f) digite "sensor de
ultrassom" no campo de busca da página principal da Parallax e, em seguida, clique no
botão Ir (Go).
Figura 10-5: Mais Módulos e Exemplos de Acessórios
Controles de Motor
Sensores
Comunicação
b
e
h
j
a
c
f
k
i
d
g
Sua Vez - Investigando Mais Recursos
Se você tem um projeto em mente e precisa encontrar um circuito e um código para
suportar uma das características do seu projeto, o processo de pesquisa que acabamos de
discutir fornece um bom ponto de partida, mas as páginas de produtos são encontradas
Página - 266
somente em www.parallax.com, e há uma série de questões de projetos que as páginas
de produtos não terão a solução. Felizmente, existem muitos mais recursos, incluindo:
•
•
•
•
Stamps in Class em livros didáticos em PDF;
Documentação do produto Parallax em PDF;
Respostas às perguntas e artigos nos fóruns parallax.com;
Artigos do BASIC Stamp publicados na Internet.
Quando você estiver à procura de componentes e informações sobre como usá-los com
o BASIC Stamp, eles se enquadrarão na categoria de “informações do aplicativo”. Ao
procurar informações sobre o aplicativo, é melhor começar com o site do fabricante, em
seguida, expandir a pesquisa para incluir os fóruns, e se você ainda não encontrou uma
boa solução, tente expandi-la ainda mais incluindo a internet. A Figura 10-6 mostra um
exemplo de pesquisa de palavras chaves no Google que vai procurar os termos
"infravermelho" e "remoto" em documentos em PDF e em páginas de produtos no
www.parallax.com. O importante aqui é que o Google procura documentos PDF em vez
de apenas páginas de produtos. Certifique-se de que não há espaços ao digitar o site:
www.parallax.com.
Figura 10-5
Pesquisa no Google
no site
www.parallax.com
Você pode modificar a pesquisa para incluir perguntas e respostas nos fóruns de suporte
da Parallax, alterando o "www" para "foruns" como este:
infrared remote site:forums.parallax.com
Este fórum procura por todas as perguntas, respostas e artigos curtos que contenham as
palavras "infravermelho" e "remoto" em foruns.parallax.com. Para encontrar um
aplicativo específico para o BASIC Stamp, mude a sua pesquisa para os termos abaixo.
Certifique-se que as palavras BASIC Stamp estejam entre aspas para filtrar a coleta de
resultados.
Aqui está um resumo das sequências de pesquisa do Google para "BASIC Stamp”
infravermelho remoto.
 site infravermelho remoto: www.parallax.com
o Pesquise os termos "infravermelho" e "remoto" em PDF e páginas de
produto em www.parallax.com
 site infravermelho remoto: foruns.parallax.com
o Pesquise os termos "infravermelho" e "remoto" em discussões nos fóruns
parallax.com
 “BASIC Stamp” infravermelho remote
o Busque na rede mundial de computadores as palavras “infravermelho”
(“infrared”) e “remoto” (“remote”) na mesma página em PDF com a
frase "BASIC Stamp".
Página - 267
Vamos dizer que o próximo passo, para o seu projeto de Alarme, seja um teclado. Mas a
documentação e exemplos que você encontrou com uma simples pesquisa na página do
produto em parallax.com acabou por ser escassa e desprovida de exemplos de circuitos
e código. Supondo que algumas pesquisas estariam em ordem, vamos tentar uma
pesquisa no Google no site da Parallax para todas as referências de teclado. Lembre-se,
a busca no Google inclui documentos em PDF.
 Vá para www.google.com.
 Digite “keypad site:www.parallax.com” dentro do campo Search e pressione
Enter.
Para filtrar os resultados é necessário um pouco de paciência e persistência, pois pode
haver muitas páginas de resultados. Normalmente há trechos suficientes de cada
resultado de busca para obter algum contexto para cada link. Isto lhe dará uma ideia de
quais ignorar e quais devem ser levados em conta. Depois de algumas páginas, você
pode encontrar e seguir o link do kit de Peças do Controle Remoto IR, mostrado na
Figura 10-7. Isto pode não ser a solução que você estava esperando, mas depois de
examinar o preço, documentação e código de exemplo, ele pode ter um grande potencial
para o seu sistema de segurança com teclado.
Figura 10-6: Kit de Peças do Controle Remoto IR
Se depois de tudo isso, você ainda não encontrou a informação que você precisa, é hora
de ir aos fóruns da parallax.com. Quando você postar uma pergunta lá, ela será vista por
especialistas em uma variedade de campos, bem como por professores, amadores e
estudantes. A experiência coletiva dos Fóruns Parallax deve ser capaz de ajudá-lo em
praticamente qualquer obstáculo do projeto!
Processador de Memória e Obstáculos de Velocidade do Projeto
Em alguns casos, programas para projetos maiores podem crescer o suficiente e
ultrapassar a memória de programa do BASIC Stamp 2. Este obstáculo do projeto pode,
às vezes, ser saltado reescrevendo o código, para trabalhar mais com menos comandos.
Outra opção é fazer a atualização para um modelo BASIC Stamp com uma memória de
programa maior. Em outros casos, o projeto pode envolver uma maior armazenagem de
valores do que o BASIC Stamp 2 pode acomodar. Há também modelos do BASIC
Stamp 2 que apresentam memória de rascunho RAM para os valores das variáveis.
Outros projetos podem precisar fazer mais tarefas em menos tempo do que o BASIC
Stamp 2 foi projetado para fazer, por isso alguns modelos do BASIC Stamp 2 são
projetados com velocidades de processamento mais rápidas.
A Figura 10-8 mostra todos os diferentes modelos BASIC Stamp. Para obter detalhes
sobre um, siga o link "Comparar módulos BASIC Stamp" no
www.parallax.com/BasicStamp.
Página - 268
Figura 10-7: Linha completa de modelos BASIC Stamp
A partir da esquerda: BS1, BS2, BS2E, BS2SX, BS2P24, BS2P40, BS2pe, BS2px
BS1: Econômico, mas capaz, perfeito para pequenos projetos ou espaços apertados.
BS2: Ideal para iniciantes, com uma vasta base de recursos de código de amostra; o
coração
dos
programas
Stamps
Class.
BS2E: Perfeito para usuários do BS2 que precisam de mais espaço no programa e
variável.
BS2SX: Suporta o conjunto de comandos BS2 com mais variáveis e espaço no
programa
em
mais
de
duas
vezes
a
velocidade
de
execução.
BS2P24: Além de mais velocidade e espaço variável, comandos especiais apoiam o
polling
I/O,
caracteres
LCDs
e
protocolos
I2C
e
1-fio.
BS2P40: Todos os recursos do BS2P24 com um banco de 16 pinos de I/O adicionais.
BS2pe: Suporta o comando BS2P24 emparelhado com menor consumo de energia e
mais memória para aplicações de registro de dados movidos a bateria.
BS2px: O mais rápido modelo BASIC Stamp BS2P24, suporta todos os comandos,
além de recursos especiais de configuração de I/O.
Uma coisa a ter em mente é que se você atualizar para um modelo mais rápido do
BASIC Stamp existirão diferenças de unidades de comandos sensíveis ao tempo como
RCTIME e FREQOUT. Uma vez que os processadores de diferentes modelos decorrem em
velocidades diferentes, as unidades de duração e frequência e outros argumentos podem
ser diferentes. Por exemplo, quando BS2 executa FREQOUT 6, 100, 4500, ele envia
um sinal de alarme estridente de P6 para 100 ms (1/10 de um segundo) a uma
frequência de 4500 Hz. O mesmo comando executado pelo BS2px envia um tom que
dura apenas 16,6 ms com uma frequência de 27.135 Hz, tão agudo que não é audível
aos ouvidos humanos! Para uma descrição completa de como cada comando funciona
em cada modelo, e para obter dicas sobre a conversão de programas BS2 para executar
corretamente em outros modelos, consulte a ajuda do BASIC Stamp Editor.
Processamento Paralelo de Alto Desempenho
Alguns aplicativos complexos exigem agilidade de processamento e memória que está
bem além das linhas de capacidade do BASIC Stamp 2. Estes são os tipos de projetos
que o microcontrolador Propeller é projetado para fazer. Este microcontrolador único,
capaz, tem oito processadores muito mais velozes em um único chip, juntamente com
32 pinos de I/O e amplo programa de memória, e memória RAM. Os processadores
podem operar ao mesmo tempo, tanto de forma independente e cooperativamente,
partilhando a memória de acesso mundial e um relógio do sistema. Cada processador
tem a sua própria memória e hardware adicional para executar tarefas complexas, como
monitorar o estado de alta velocidade do pino de I/O, ou gerar sinais para uma tela de
televisão ou computador.
Página - 269
O Propeller Education - Kit Educacional mostrado na Figura 10-9 é uma boa maneira
de começar a trabalhar com o microcontrolador Propeller. Este kit não é
necessariamente o melhor próximo passo depois do BASIC Stamp - Kit de
Atividades. A próxima atividade tem algumas boas recomendações para as próximas
etapas do livro/kit. No entanto, quando você perceber que seus projetos estão ficando
mais ambiciosos e exigentes, lembre-se do microcontrolador Propeller e do Propeller
Education - Kit Educacional.
Figura 10-8
Propeller Education
- Kit Educacional (à
esquerda) e
Plataforma PE (à
direita)
ATIVIDADE #7: QUAL SERÁ A PRÓXIMA?
Agora que você está prestes a terminar BASIC Stamp - Kit de Atividade é hora de
pensar sobre o que aprender em seguida. Antes de continuar, tire um tempo para
considerar em que mais você está interessado. Algumas categorias gerais que você
futuramente pode se aprofundar ainda mais, incluem:
•
•
•
•
•
•
Robótica;
Eletrônica;
Sensores;
Automação;
Projetos de Diversão;
Ciências da Terra e medições climáticas.
Esta atividade levantou recursos que você pode usar para avançar com cada uma dessas
categorias.
Os recursos, kits e componentes discutidos nesta atividade foram atualizados
quando este capítulo foi escrito (2009). As melhores e mais recentes versões
dos recursos, kits e componentes podem se tornar disponíveis e substituir as
informações aqui apresentadas. Certifique-se de verificar www.parallax.com para
últimas informações.
O que é um Microcontrolador? - Sequência
A Figura 10-10 mostra os 10 livros e kits que fazem as melhores sequências para este
livro. Robótica com o Boe-Bot é muito divertido e um grande aprendizado, porque você
começa a aplicar muitas das técnicas deste livro para aplicações robóticas com o robô
Boe-Bot. Sensores inteligentes e Aplicações foram escritos para ser "O que é um
microcontrolador, parte 2". Foi rebatizado porque todos os elegantes sensores e visor de
Página - 270
cristal líquido mostrado no centro da Figura 10-10 têm coprocessadores que se
comunicam com o BASIC Stamp. Os coprocessadores fazem-no sensores "inteligentes".
Sinais de entendimento são ótimos porque permitem "ver" as interações entre o BASIC
Stamp e os circuitos com um osciloscópio da Parallax que você pode conectar na porta
USB do seu computador.
Figura 10-9: Grandes próximos passos após “O que é um microcontrolador?”
Kit do Robô Boe-Bot
Sensores
Inteligentes e
Aplicação de
Peças de Teste
Entendendo
sinais, peças e
texto
Stamps in Class e Mais Livros Didáticos
A Figura 10-11 mostra um fluxograma que descreve todos os kits de Stamps in Class e
livros didáticos disponíveis no momento da redação desse texto. Estão acessíveis
através da Visão Global do Programa Stamps in Class (Stamps in Class Program
Overviews) e do link Fluxograma (Flowchart) no www.parallax.com/Education, e você
pode clicar em cada foto para visitar a página do produto no livro e o kit que
acompanha. O que é um Microcontrolador? está no canto superior esquerdo da figura. A
partir daí, o fluxograma indica que você pode saltar para Robótica com o Boe-Bot ou
qualquer texto/kit nos sensores ou série de sinais.
Download completo de livros didáticos em PDF: Você pode fazer o download
de todo o PDF totalmente colorido de cada Stamp in Class em
www.parallax.com. Clique em qualquer uma das fotos do gráfico para navegar
até a página do texto + Kit, e você vai encontrar o link em PDF na seção de
Downloads da página.
Página - 271
Figura 10-10
Fluxograma do
Stamps in Class
Se a categoria que você está interessado é:
• Robótica, então, o próximo passo é definitivamente Robótica com o Boe-Bot.
• Sensores, inventos ou projetos de diversão, então o próximo passo seria
Sensores inteligentes e aplicações.
• Eletrônicos (sinais), então o próximo passo seria Entendendo Sinais.
• Automação, então o próximo passo seria Controle de Processos.
• Ciências da Terra e medições climáticas, então o próximo passo seria Sensores
Aplicados.
Recurso Adicionais dos Stamps In Class
Além do que está nos livros didáticos Stamps in Class, existem “Mini Projetos” Stamps
in Class linkados no www.parallax.com/Education. Alguns projetos utilizam apenas as
peças em estoque de um determinado kit, mas demonstram novas maneiras de usá-las,
juntamente com novos conceitos. Muitos desses projetos são como capítulos completos
dos livros didáticos Stamps in Class com atividades, esquemas, diagramas de fiação, e
listagens de código completas que podem ser baixadas. Alguns até têm tutoriais em
vídeo que acompanham. A Figura 10-12 é retirada do vídeo do projeto “Construa seu
próprio mini temporizador ("Build Your Own Mini timer"), que pode ser feito apenas
com as peças que você tem usado neste livro. Se você está procurando mais
informações ou uma inspiração criativa, você pode encontrá-la aqui.
Página - 272
Figura 10-11: Exemplo do “Mini Projeto” Stamps in Class
SUMÁRIO
Este livro introduziu uma variedade de circuitos e técnicas de todos os que são blocos
de construção em produtos comuns, bem como nas invenções. Este livro também
apresentou técnicas para orquestrar os vários blocos de construção com o
microcontrolador BASIC Stamp. Este capítulo demonstrou como incorporar essas
técnicas e blocos de construção em um protótipo, e também recomendou alguns
próximos passos para aprender mais na sua área de interesse.
A abordagem para fazer o BASIC Stamp interagir com um determinado circuito pode
ser aplicada a uma variedade de outros circuitos e módulos para realizar uma gama
ainda mais vasta de tarefas. Foram aplicados dois exemplos ao protótipo de alarme: (1)
com um sensor de movimento de uma interface semelhante a um botão de pressão e (2)
um sensor de pressão com uma interface semelhante ao potenciômetro.
Ao desenvolver o código para sua aplicação, certifique-se de salvar seu trabalho com
frequência sob os nomes de revisão incrementados. Além disso, certifique-se de usar
nomes significativos para os pinos de I/O e números com as diretivas PIN e CON. Por
último, acrescente muitos comentários ao seu código, explicando o que ele faz e como
ele faz isso. Sub-rotinas devem incluir comentários que explicam o que a rotina faz com
todas as variáveis com valores que ele usa para fazer seu trabalho, bem como as
variáveis em que os resultados são armazenados quando a sub-rotina está pronta.
Este capítulo também introduziu uma variedade de técnicas de pesquisa para programar
recursos em seu protótipo. Mesmo se você começar sem nenhuma pista sobre como
fazer um trabalho com uma característica peculiar, você pode usar termos de pesquisa
para encontrar exemplos úteis de componente, circuito e código. Livros didáticos e kits
do Stamps in Class também apresentam uma grande variedade de circuitos e técnicas
úteis de design, e eles são um ótimo lugar para aprender mais nas áreas de robótica,
Página - 273
sensores, eletrônica, automação, ciências da terra, e muito mais. Todos os livros que
vêm com kits Stamps in Class têm downloads gratuitos.
Agora que você chegou ao final deste livro, tire um momento para pensar em quatro
coisas: (1) nas técnicas que você aprendeu, (2) na sua próxima invenção, projeto ou
protótipo, (3) como pode ser aplicado o que você aprendeu e (4) o que você quer
aprender a seguir.
 Agora, é hora de começar a fazer o seu próximo projeto ou protótipo.
 Certifique-se de continuar estudando e aprendendo novas técnicas conforme
você for fazendo.
 Divirta-se e boa sorte!
Página - 274
Apêndice A: Lista de Peças e Opções de Kit
Kit de Peças e Livro #28152, Apenas Peças #28122 de “O que é um
Microcontrolador?”
Peças e quantidades estão sujeitas a alterações sem aviso prévio
Peças
Descrição
Quantidade
Parallax #
150-01020
Resistor, 5%, 1/4W, 1 kΩ
10
150-01030
4
150-01040
2
150-02020
2
150-02210
Resistor, 5%, 1/4W, 220 Ω
6
150-04710
Resistor, 5%, 1/4W, 470 Ω
6
152-01031
Potenciômetro - 10 kΩ
1
200-01031
Capacitor, 0.01 µF
2
200-01040
Capacitor, 0.1 µF
2
201-01080
Capacitor, 1000 µF
1
201-03080
1
350-00001
Capacitor 3300 µF
Livro “O que é Microcontrolador?” (apenas
no #28152)
LED - Verde - T1 3/4
350-00005
350-00006
350-00007
350-00027
350-00029
400-00002
LED - Bicolor - T1 3/4
LED - Vermelho - T1 3/4
LED - Amarelo - T1 3/4
Display de LED de 7 segmentos
Fototransistor, 850 nm, T1 3/4
Botão – Normalmente aberto
1
2
2
1
1
2
451-00303
500-00001
3 cabeçalho de Pino – Macho/Macho
Transistor – 2N3904
1
1
604-00010
Potenciômetro digital de 10 kΩ
Fios de 3” – Saco com 10
Alto-falante
1
800-00016
900-00001
900-00005
Servo Padrão Parallax
1
28123
1
2
2
1
Página - 275
OPÇÕES DE KIT COMPLETO
Existem várias opções de kits disponíveis que incluem a placa de desenvolvimento do
microcontrolador Basic Stamp 2 e todos os componentes eletrônicos para concluir as
atividades neste texto:
•
Kit de atividades do BASIC Stamp (#90005) inclusos:
o BASIC Stamp HomeWork Board com a superfície de montagem BS2
o USB para Adaptador Serial com cabo USB A para Mini-B (#28031)
o “O que é Microcontrolador?” Peças e Livro (#28152)
• Kit Descobrindo o BASIC Stamp (Serial #27207 ou USB #27807) inclusos:
o Board of Education (Serial #28150 ou USB #28850)
o Módulo do microcontrolador BASIC Stamp 2 (#BS2-IC)
o Cabo de Programação (Serial #800-00003 ou USB A para Mini-B
#805-00006)
o “O que é Microcontrolador?” Peças e Livro (#28152)
o Manual do BASIC Stamp (#27218)
• “O que é Microcontrolador?” Peças e Livro (#28152). PLUS
• Kit completo do Board of Education (Serial #28103 ou USB #28803)
inclusos:
o Board of Education (Serial #28150 ou USB #28850)
o Módulo do microcontrolador do BASIC Stamp 2 (#BS2-IC)
o Cabo de Programação (Serial #800-00003 ou USB A para Mini-B
#805-00006)
o Fios (1 pacote com 10
Nota para os Educadores: descontos nas compras em quantidade estão disponíveis
para todos os kits listados acima. Consulte a página de produtos de cada kit em
www.bseducacional.com.br para mais informações. Além disso, o BASIC Stamp
HomeWork Board está disponível separadamente em embalagens de 10, como uma
solução econômica para o uso em sala de aula, com um custo significativamente menor
do que o Board of Education + BASIC Stamp 2 módulo (#28158). Para preços em
compras maior quantidade, por favor, entre em contato com a Equipe de Vendas da BS
Educacional
através
do
telefone
+55
(11)
2533
9.
Página - 278
Apêndice B: Mais Informações Sobre Eletricidade
O que é um elétron? Um elétron é uma das três partes fundamentais de um átomo, os
outros dois são os prótons e neutrons. Um ou mais prótons e neutrons se unem no centro
da molécula numa área chamada núcleo. Os elétrons são muito pequenos em
comparação com os prótons e neutrons, e orbitam ao redor do núcleo. Os eletrons
repelem-se mutuamente, mas eletrons e protons atraem uns aos outros.
O que é uma carga? A tendência de um elétron se repelir a partir de um outro elétron
e atrair um próton próximo é chamada de carga negativa. A tendência de um próton
repelir outro próton e atrair um elétron é chamada de carga positiva. Quando uma
molécula possui mais elétrons do que prótons, ela será carregada negativamente. Se
uma molécula tem menos elétrons do que prótons, ela será carregada positivamente. Se
uma molécula tem o mesmo número de prótons e elétrons, é chamada de carga neutra.
O que é uma voltagem? A voltagem é como a pressão elétrica. Quando uma molécula
carregada negativamente está perto de uma molécula carregada positivamente, o eletron
extra na molécula carregada negativamente tenta obter a partir da molécula carregada
negativamente para a molécula carregada positivamente. As baterias mantém uma
composição com as moléculas carregadas negativamente, separadas a partir de uma
composição com as moléculas carregadas positivamente. Cada uma destas composições
encontra-se ligada a um dos terminais da bateria; a composição carregada positivamente
está ligada ao terminal positivo (+), e a composição negativa está ligado ao terminal
negativo (-) do terminal.
O volt é uma medida de pressão elétrica, e é abreviado com uma letra maiúscula V.
Você já deve estar familiarizado com a bateria de nove volts (9 V) usada para fornecer
energia para o Board of Education ou HomeWork Board. Outras baterias comuns
incluem as baterias de 12 V encontradas em carros e nas pilhas de 1,5 V AA usadas
em calculadoras, jogos portáteis e outros dispositivos.
O que é uma corrente? Corrente é a medida do número de elétrons por segundo que
passa através de um circuito. Algumas vezes, a ligação de moléculas de uma reação
química cria uma composição (que tem carga neutra). Outras vezes, o elétron deixa a
molécula carregada negativamente e se junta à molécula carregada positivamente,
passando pelo circuito como o que você acabou de construir e testar. A letra mais
comumente usada para se referir a corrente nos esquemas e livros é a letra maiúscula
"I."
O que é um amp? Um amp (abreviação de ampere) é a unidade básica da corrente, e a
abreviação para amp é a letra maiúscula "A." Em comparação com os circuitos que
você está usando com o BASIC Stamp, um amp é uma quantidade muito grande de
corrente. É um valor conveniente para descrever a quantidade de corrente que a bateria
de um carro fornece para os faróis, para o ventilador que resfria o motor de um carro , e
outros dispositivos de alta potência. Medições de miliampéres (mA) e microampéres
(uA) são mais convenientes para discutir a corrente de alimentação do módulo BASIC
Stamp, bem como as correntes entre os pinos e circuitos de I/O. 1 mA = 1/1, 000 A, e 1
mA = 1/1, 000,000 A.
O que é uma resistência? A resistência é a tendência de um elemento de um circuito
Página - 279
para resistir ao fluxo de elétrons ( corrente) de um terminal negativo da bateria para o
terminal
positivo.
O ohm é a medida básica da resistência .Ele já foi introduzido e é abreviado com a letra
grega ômega ( Ω ).
O que é um condutor? É o fio de cobre que tem quase nenhuma resistência, e é.
ATIVIDADE BÕNUS: LEI DE OHM, VOLTAGEM E CORRENTE
Aplica-se a esta atividade algumas das definições que acabamos de discutir.
Peças - Lei de Ohm
(1) Resistor – 1 kΩ (marrom-preto-vermelho)
Circuito de Teste
O valor da resistência Ri na Figura B-1 pode ser alterado. Uma menor resistência
permite mais corrente através do LED, e ele vai brilhar com mais intensidade. Os
valores mais elevados de resistência farão com que o LED pareça escuro porque eles
não permitem a passagem de muita corrente através do circuito.
 Desligue a energia do seu Board of Education ou HomeWork Board sempre que
você modificar o circuito.
 Construa o circuito mostrado na figura B-1 começando com um resistor de 220
Ω.
 Modifique o circuito, substituindo o resistor de 220 Ω por um resistor de 470 Ω.
O LED ficou menos brilhante?
 Repita usando o resistor de 1 Ω., em seguida use um resitor de 2 Ω., verifique a
variação de brilho cada vez.
Vdd
X3
Vdd
R1 R 2 R 3 R 4
Ri
LED
Vss
R1 = 220 Ω
R2 = 470 Ω
R3 = 1 k Ω
R4 = 2 k Ω
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura B-1
LED Monitor de
Corrente
Se você estiver usando uma bateria de 9 V, você também pode comparar o brilho de
uma fonte de voltagem diferente, Vin. Vin está conectado diretamente ao terminal + da
bateria de 9 V, e Vss está conectado diretamente ao terminal negativo da bateria. Em
Página - 280
nosso sistema, Vdd está regulado a 5 V. Isso é cerca de metade da voltagem da bateria
de 9 V.
 Se você não estiver usando uma bateria de 9 V, pare por aqui e pule para o
cálculo de corrente da seção abaixo. Caso contrário, continue.
Comece com o circuito mostrado na figura B-1, mas use um resistor de 1 kΩ.
Anote quão brilhante o LED está
Desconecte a energia.
Modifique o circuito, desligando o resistor principal de Vdd e coloque-o em
Vin..
 Quando você reconecta a energia o LED está mais brilhante? Quanto mais
brilhante?




Não tente fazer a experiência Vin com um resistor de 220 ou 470 Ω, pois ele irá
alimentar o LED como mais corrente do que ele está classificado.
Calculando a Corrente
O manual do BASIC Stamp tem algumas regras sobre a quantidade de corrente que os
pinos de I/O podem fornecer aos circuitos. Se você não seguir estas regras, você pode
acabar prejudicando o seu BASIC Stamp. As regras têm a ver com a quantidade de
corrente que um pino ou um grupo de pinos de I/O pode entregar.
Regras atuais para pinos de I/O do BASIC Stamp
•
Um pino de I/O pode ter uma "fonte" de até 20 mA. Em outras
palavras, se você enviar um sinal de alta para um pino de I/O, ele não
deve alimentar o circuito de LED, com mais de 20 mA.
•
Se você religar o circuito de LED para que o BASIC Stamp faça o LED
acender, quando você enviar o comando LOW, o pino de I/O pode
"afundar" até 25 mA.
•
P0 até P7 só pode utilizar até 40 mA. Da mesma forma com P8 até P15.
40 mA também é a corrente fornecida ao pino de I/O estimada para o
regulador do módulo 25 V do BASIC Stamp , de modo que o consumo
total de corrente de todos os pinos de I/O não devem nunca exceder 40
mA. Se você tem muitos circuitos de LED, você precisará de resistores
maiores para que os circuitos não puxem muita corrente.
•
Para mais informações, consulte a tabela de descrição dos pinos do
BASIC Stamp 2 no no Manual BASIC Stamp.
Se você sabe como calcular a quantidade de corrente que o seu circuito vai usar, então
você consegue decidir se tudo bem seu LED brilhar com essa intensidade específica.
Cada componente tem suas próprias regras no que diz respeito à voltagem, resistência e
corrente. Para o diodo emissor de luz, a regra é um valor chamado de voltagem direta do
diodo. Para o resistor, a regra é chamada Lei de Ohm. Há também regras para adicionar
voltagem e corrente nos circuitos. Estas são chamadas de Leis de Voltagem e Corrente
de Kirchhoff.
Página - 281
Vdd - Vss = 5 V A voltagem (tensão elétrica) de Vdd para Vss é de 5 V. Isto é
chamado de voltagem regulada, e ela funciona mais ou menos como uma bateria que
fornece exatamente 5 V. (As baterias não são tipicamente de 5 V, embora quatro baterias
de 1,2 V de níquel-cádmio recarregáveis em série podem adicionar até 4,8 V.) O Board of
Education e o BASIC Stamp HomeWork Board ambos têm reguladores de 5 V que
convertem a bateria de 6 a-9 V para fornecer voltagem ao regulador de 5 V para as
tomadas de Vdd acima da breadboard. O BASIC Stamp, também tem um regulador de
voltagem embutido que converte a entrada de 6 a 9 V para 5 V, para os seus
componentes.
Vin - Vss = 9 V Se você estiver usando bateria de 9 V, a voltagem de Vin para Vss é
de 9 V. Tenha cuidado. Se você estiver usando um regulador de voltagem que se conecta
à parede, mesmo que ele diga 9 V, poderia ir tão alto como 18 V.
Terra e / ou referência referem-se ao terminal negativo de um circuito. Quando se
trata do BASIC Stamp e do Board of Education, Vss é considerado a referência de terra. É
zero volts, e se você estiver usando uma bateria de 9 V, é o terminal negativo dessa
bateria. O terminal positivo da bateria é de 9 V. VDD é de 5 V (acima da referência Vss
de 0 V), e é uma voltagem especial feita por um chip regulador de voltagem que fornece
energia ao BASIC Stamp.
Lei de Ohm: V = I x R A voltagem medida entre os terminais de um resistor (V) é igual a
passagem de corrente através do resistor (I) multiplicada pela resistência (R).
Diode envia voltagem: A voltagem entre o ânodo de um diodo e o cátodo como corrente
passa através dele do ânodo para o cátodo. Para o circuito do LED verde na Figura 2- 6
na página 33, você pode assumir que a voltagem enviada através do LED é de
aproximadamente 2,1 V para o caso de fazer os cálculos do circuito. Se o LED estiver
amarelo assume 2,0 V, e se ele estiver vermelho, assume 1,7 V. Estas voltagens irão
variar um pouco com a quantidade de corrente que passa através do circuito. Menor
resistência em série e / ou maior voltagem aplicada ao circuito resulta num fluxo de
corrente mais elevado. Maior resistência em série e / ou menor voltagem aplicada resulta
em menores fluxos de corrente.
Lei de voltagem de Kirchhoff simplificada: voltagem utilizada é igual a voltagem
fornecida. Se você alimentar um circuito com 5 V, o número de volts para todas as peças
ficará melhor se adicionar até 5 V.
Lei de corrente de Kirchhoff simplificada: A corrente que entra é igual à corrente que
sai. A corrente que entra a partir de um circuito de LED Vdd é a mesma quantidade de
corrente que sai através Vss. Além disso, se você conectar três LEDs para o BASIC
Stamp, e cada circuito de LED atrair 5 mA, significa que o BASIC Stamp tem que
fornecer todos os circuitos com um total de 15 mA.
Exemplo de Cálculo: um Circuito, dois Circuitos.
Dois passos para calcular a quantidade de corrente que um circuito de LED vermelho
atrai:
1. Descobra a voltagem sobre o resistor
2. Use a Lei de Ohm para descobrir a corrente através do resistor.
A Figura B-2 mostra como calcular a voltagem através do resistor. A voltagem
fornecida que está do lado esquerdo é de 5V. As voltagens usadas por cada componente
estão à direita do circuito. A voltagem, nós não sabemos no início se é VR, a voltagem
Página - 282
através da resistência. Mas, sabemos que a voltagem sobre o LED vai ser de cerca de
1,7 V (voltagem direta do LED vermelho). Sabemos também que a voltagem entre as
partes tem que adicionar até 5 V por causa da lei de voltagem de Kirchhoff. A diferença
entre 5 V e 1,7 V é de 3,3 V, esta é a voltagem através da resistência de VR.
VR + 1.7 V = 5 V
VR = 5 V − 1.7 V
VR = 3.3 V
Figura B-2
Voltagem
através do
circuito, do
resistor e do
LED
Quilo é métrica para 1000. A forma métrica de dizer 1000 é quilo, e é abreviada
com a minúscula k. Em vez de escrever 1000Ω, você pode escrever 1kΩ.De
qualquer maneira, é1kΩ. é pronunciado um kilo-ohm. . Da mesma forma, 2000Ω
é escrito 2kΩ.
Mili é métrica para 1/1000, e é abreviado com um m minúsculo. Se o BASIC
Stamp alimenta o circuito de LED com 3,3 milésimos de um ampere, são 3,3
miliamperes, ou 3,3 mA.
O que é um mA? Pronuncia-se miliamper, é a abreviatura de um-milésimo-de
um amper. O "m" 'em mA é a abreviação métrica para mili, que representa
1/1000. O "A" em mA significa amperes. Coloque os dois juntos, e você tem
miliamperes, e é muito útil para descrever a quantidade de corrente consumida
pelo BASIC Stamp e para os circuitos ligados a ele.
Agora que já calculamos a voltagem através do resistor, a Figura B-3 mostra um
exemplo de como utilizar esse valor para calcular a passagem de corrente através do
resistor. Comece com a Lei de Ohm: V = I × R. Você sabe as respostas para V (3,3 V) e
R (470 Ω). Agora, tudo que você tem a fazer é resolver para I (a corrente).
V = I×R
3.3 V = I × 470 Ω
3.3 V
I=
470 Ω
I ≈ 0.00702 V
Ω
I = 0.00702 A
7.02
A
1000
I = 7.02 mA
I=
Figura B-3
Calculando
corrente
através do
resistor
Página - 283
Sim, é verdade! 1 A = 1 V /Ω (Um amp é um volt por ohm).
Quanta corrente tem 7,02 mA? É a quanitdade de corrente que o circuito de LED
na Figura B-2 conduz. Você pode substituir o resistor de 470Ω
por um de 220
Ω e o circuito vai conduzir cerca de 15,0 mA, e o LED acenderá mais
intensamente. Se você usar um resistor de 1000 Ω , o circuito vai conduzir 3,3
mA, e o LED acenderá menos intensamente. Se você usar um resistor de 2000Ω
fará com que o LED brilhe menos intensamente ainda, e a corrente será 1,65 mA.
Vamos dizer que você quer fazer que um pino de I / O ligue dois LEDs ao mesmo
tempo. Isso significa que, no interior do BASIC Stamp, ele alimentaria os circuitos,
conforme mostrado na Figura B-4. Poderia o circuito de corrente estimado exceder o
limite de 20 mA do pino de I/O? Vamos descobrir. Lembre-se que a versão simplificada
da lei de corrente de Kirchhoff diz que a corrente total consumida da fonte é igual a
corrente fornecida a todos os circuitos. Isso significa que I na figura B-4 tem de ser
igual ao total das duas correntes estimadas. Basta somar as duas correntes estimadas, e
você vai ter uma resposta de 14,04 mA, que você pode arredondar para 14,0 mA. Uma
vez que este consumo de corrente ainda está abaixo do limite de 20mA do pino de I / O,
pode seguramente ser conectado a um pino de I / O e ligado / desligado com o BASIC
Stamp.
I = I 1 + I 2 + ... I i
I = 7.02 mA + 7.02 mA
I = 14.04 mA ≈ 14.0 mA
Figura
B-4
Corrente
total
fornecida
a dois
circuitos
de LED
Sua Vez – Modificando o Circuito
 Repita o exercício na Figura B-2, mas use Vin - Vss = 9 V em vez de Vdd - Vss
= 5 V.
Assumindo que a voltagem enviada não se altera, a resposta é VR = 7,3 V. A medida da
voltagem do resistor será provavelmente um pouco menos pois quanto maior voltagem
do LED mais passagem de corrente através do circuito..
 Repita o exercício na Figura B-3, mas use um resistor de 1 kΩ.
Resposta: I = 3.3 mA.
 Use VR = 7,3 V para fazer o exercício na Figura B-3 com um resistor de 1 kΩ.
Resposta: I = 7.3 mA.
Página - 284
 Repita o exercício mostrado na Figura B-4 com um resistor de 470 Ω e o outro
de1 kΩ.
Resposta: I = 7.02 mA + 3.3 mA = 10.32 mA.
Página - 285
Apêndice C: Sumário do Formato RTTTL
Este é um resumo destinado a ajudar a entender o formato RTTTL. A especificação
RTTTL completa pode ser encontrada em vários sites. Com qualquer mecanismo de
busca, use a palavra-chave "especificação RTTTL" para rever as páginas da web que
incluem a especificação.
Aqui está um exemplo de um formato de toque em RTTTL:
Leve-me ao jogo de bola : :d=4,o=7,b=225:2c6,c,a6,g6,e6,
2g.6,2d6,p,2c6,c,a6,g6,e6,2g.6,g6,p,p,a6,g#6,a6,e6,f6,g6,a6,
p,f6,2d6,p,2a6,a6,a6,b6,c, d,b6,a6,g6
O texto antes do primeiro dos dois pontos é que o telefone celular mostra, como nome
da canção. Neste caso, o toque é chamado:
Leve-me ao jogo de bola:
Entre o primeiro e o segundo dois pontos, as configurações padrão para a música são
inseridas usando d, o, e b. Aqui está o que elas querem dizer:
d – duração
o – oitava
b – batimentos por minuto ou ritmo.
Em Leve-me ao jogo de bola, as configurações padrão são:
d=4,o=7,b=225:
As notas da melodia são inseridas após o segundo dois pontos, e elas são separadas por
vírgulas. Se for utilizada apenas a letra nota, essa nota será tocada para a duração padrão
na oitava padrão. Por exemplo, a segunda nota em Leve-me ao jogo de bola é:
,c,
Se não houver outras informações, ela será tocada com a duração padrão de uma
semínima (d = 4), na sétima oitava (o = 7).
A nota poderia ter até cinco caracteres entre as vírgulas, aqui está o que cada caractere
especifica:
,duração
nota
sustenido
ponto
oitava,
Por exemplo:
,2g#.6,
… Significa tocar a meia nota sustenido G- para a duração de 1 ½ de meia nota, e tocála na sexta oitava.
Aqui estão alguns exemplos de Leve-me ao jogo de bola:
Página - 286
,2g.6, – meia nota, G, pontilhado, sexta oitava
,a6, – duração padrão da semínima. Nota tocada na sexta oitava
,g#6, – duração de um quarto, nota g, sustenido (indicado por #), sexta oitava
O caractere:
,p,
… significa pausa, é usada para descanso. Com nenhuma informação extra, o p toca por
padrão a duração de uma semínima. Você também pode tocar o valor de uma meia nota
de descanso usando:
,2p,
Aqui está um exemplo de um descanso pontilhada::
,2p.,
Neste caso, o resto iria durar meia nota mais a duração de uma semínima.
Página - 287
Peças e quantidades estão sujeitas a alterações sem aviso prévio. As peças podem diferir
do que é mostrado na foto. Se você tem alguma dúvida sobre o seu kit, por favor, envie
um e-mail para [email protected].

O que é um Microcontrolador?

Transcription

Similar documents

Arduino Básico

Luminária Industrial LED WLS27

LEDlume

Dispositivos de Sinalização Óptica Optical Signal

universidade tecnológica federal do paraná departamento

eu quero, posso e escolho preços baixos

O essencial Harmony - Schneider Electric

Apostila 1 - Mini curso de C# (CSHARP)

Linha Verde Linha Verde Linha Verde