Robótica com Boe-Bot

Transcrição

Robótica com Boe-Bot
Guia do Estudante
VERSÃO 3.0
TRADUÇÃO POR BS EDUCACIONAL
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].
ÍNDICE ANALÍTICO
Prefácio ....................................................................................................................... página 9
Sobre a Versão 3.0 ................................................................................................................. página 10
Público ................................................................................................................................... página 11
Fóruns de Suporte .................................................................................................................. página 11
Recursos para Educadores...................................................................................................... página 13
Traduções em Línguas Estrangeiras ....................................................................................... página 14
Sobre o Autor ......................................................................................................................... página 14
Colaboradores Especiais ........................................................................................................ página 14
Capítulo 1: O Cérebro do seu Boe-Bot .................................................................. página 17
Hardware e Software .............................................................................................................. página 18
Atividade #1: Obtendo o Software ......................................................................................... página 19
Atividade #2: Utilizando o Arquivo de Ajuda para Configuração do Hardware .................... página 26
Sumário .................................................................................................................................. página 29
Capítulo 2: Servo Motores do seu Boe-Bot ............................................................ página 33
Apresentando o Servo de Rotação Contínua.. ........................................................................ página 33
Atividade #1: Construindo e Testando o Circuito de LED .................................... ................ página 35
Atividade #2: Monitorando o Tempo e Repetindo Ações com um Circuito .......................... página 39
Atividade #3: Ligando os Servo Motores .............................................................. ................ página 55
Atividade #4: Centralizando os Servos ................................................................. ................. página 67
Atividade #5: Como Armazenar Valores e Contar ................................................ ................ página 72
Atividade #6: Testando os Servos ........................................................................ .................. página 79
Sumário ................................................................................................................ .................. página 90
Capítulo 3: Montagem e Teste do seu Boe-Bot .......................................................página 97
Atividade #1: Montando o Robô Boe-Bot ............................................................. ................ página 97
Atividade #2: Testando Novamente os Servos ................................................... ................. página 109
Atividade #3: Circuito do Indicador "Start/Reset" e seu Programa ..................... ................ página 113
Atividade #4: Testando o Controle de Velocidade com o Debug Terminal......... ................ página 122
Sumário ............................................................................................................................... página 130
Capítulo 4: Navegação do Boe-Bot ..................................................................... ...página 135
Atividade #1: Manobras Básicas do Boe-Bot..................................................... .................. página 136
Atividade #2: Ajustando as Manobras Básicas .................................................. .................. página 142
Atividade #3: Calculando Distâncias ................................................................. .................. página 147
Atividade #4: Manobras de Rampa ................................................................... ................... página 153
Atividade #5: Simplificando a Navegação com Sub-Rotinas............................... ................ página 157
Atividade #6: Tópico Avançado - Construindo Manobras Complexas no EEPROM
............................................................................................................................ .................. página 163
Sumário ............................................................................................................. .................. página 176
Capítulo 5: Navegação Tátil com Bigodes ............................................................página 185
Navegação Tátil .................................................................................................................. página 185
Atividade #1: Construindo e Testando os Bigodes.......................................... ..................... página 186
Atividade #2: Testando os Bigodes em Campo ................................................. .................. página 195
Atividade #3: Navegando com Bigodes ............................................................. .................. página 199
Atividade #4: Inteligência Artificial e Decidindo Quando Você Está Preso ........ ............... página 205
Sumário ............................................................................................................................... página 211
Capítulo 6: Navegação Sensível à Luz com Fototransistores ............................. página 217
Apresentando o Fototransistor ......................................................................... .................... página 218
Atividade #1: Um sensor de Luz Binário Simples .............................................. ................. página 220
Atividade #2: Medindo os Níveis de Luz com Fototransistores ......................... ................. página 229
Atividade #3: Ajustando a Sensibilidade à Luz .................................................. ................. página 241
Atividade #4: Medindo a Luz para Andar ........................................................... ................. página 248
Atividade #5: Rotina para Andar em Direção à Luz ........................................... ................. página 259
Atividade #6: Rotina de Teste de Navegação com o Boe-Bot ........................... .................. página 271
Sumário ............................................................................................................................... página 276
Capítulo 7: Navegação com Faróis Infravermelhos ............................................ página 283
Luz Infravermelha .............................................................................................. .................. página 283
Atividade #1: Construindo e Testando o Detector de Objetos IV ........................................ página 287
Atividade #2: Testando o Detector de Objetos IV em Campo e Interferência Infravermelha
........................................................................................................................... .................... página 295
Atividade #3: Ajustando o Alcance da Detecção de Infravermelho ................... ................. página 300
Atividade #4: Detectando e Evitando Objetos ................................................... .................. página 303
Atividade #5: Navegação Infravermelha de Alta Performance .......................... ................. página 306
Atividade #6: Detector de Degrau ...................................................................... .................. página 309
Sumário ............................................................................................................................... página 317
Capítulo 8: Controle do Robô de Detecção de Distância..................................... página 325
Determinando a Distância com o Mesmo Circuito Detector/LED IV .................. ............... página 325
Atividade #1: Testando a Varredura de Frequência.......................................... .................... página 326
Atividade #2: Veículo Sombra Boe-Bot............................................................... ................ página 334
Atividade #3: Seguindo uma Linha ................................................................... ................... página 344
Atividade #4: Mais Projetos e Atividades do Boe-Bot Online ............................ ................ página 353
Sumário ............................................................................................................. ................... página 356
Anexo A: Lista de Peças e Opções de Kit.......................................................... ............... página 365
Anexo B: Códigos de Cor dos Resistores e Regras do Breadboarding ......... ............... página 369
Anexo C: Competições de Navegação do Boe-Bot .......................................................... página 378
Prefácio · Página 9
Prefácio
Robôs são utilizados na indústria mecânica, médica e de fabricação, em
todos os tipos de veículos, e, claro, em muitos filmes de ficção científica. A
palavra "robô" apareceu, pela primeira vez, em um jogo satírico
tchecoslovaco, Robôs Universais de Rossum, de Karel Capek em 1920. Os
robôs, neste jogo, tendem a ser semelhantes à raça humana. Deste ponto em
diante, parecia que muitas histórias de ficção científica envolviam estes
robôs que tentavam se encaixar na sociedade e compreender as emoções
humanas. Isso mudou quando a General Motors instalou os primeiros robôs
em sua fábrica, em 1961. Estas máquinas automatizadas apresentaram uma
imagem totalmente diferente da forma humana dos robôs da ficção
científica.
Construir e programar um robô é uma combinação de mecânica, eletrônica e
de resolução de problemas. O que você está prestes a aprender, ao fazer as
atividades e projetos deste texto, será relevante para aplicações no mundo
real que usa controle robótico, cujas únicas diferenças serão tamanho e
sofisticação. Os princípios mecânicos, listagens de programas e circuitos,
que você usará são muito semelhantes, e algumas vezes os mesmos,
desenvolvidos por engenheiros e usados nas indústrias.
O objetivo deste texto é fazer com que os alunos interessados e
entusiasmados com as áreas de engenharia, mecatrônica, e desenvolvimento
de software, saibam como projetar, construir e programar um robô
autônomo. Esta série de atividades práticas e projetos apresentam aos alunos
conceitos básicos de robótica usando o robô Parallax Boe-Bot ®, chamado
de "Boe-Bot". Seu nome vem do Board of Education ® móvel que é
montado em seu chassis com rodas. Na figura P-1 é mostrado um exemplo
de Boe-Bot com um circuito infravermelho de detecção de obstáculos
construído em uma breadboard.
Figura P-1
Robô Boe-Bot® da
Parallax Inc.
As atividades e projetos neste texto começam com a introdução no cérebro
do seu Boe-Bot, do microcontrolador Parallax BASIC Stamp ® 2, e em
seguida com a construção, teste e calibração do Boe-Bot. Depois disso, você
irá programar o Boe-Bot para manobras básicas, e então proceder a adição
de sensores e escrever programas que o façam reagir ao seu ambiente e
executar tarefas autônomas.
SOBRE A VERSÃO 3.0
Esta é a primeira revisão deste título desde 2004. As principais mudanças
incluem:
• Substituição do fotoresistor sulfeto de cádmio com um sensor de luz
compatível com RoHS de um tipo que vai ser mais comum no design do
produto daqui em diante. Isso exigiu uma reescrita do Capítulo 6.
• 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 a manutenção dinâmica do Hardware e resolução de
problemas.
• A remoção de referências para o CD Parallax, excluída de nossos kits, foi
no intuito de redução e desperdício, e para garantir que os clientes possam
baixar o mais recente software BASIC Stamp Editor e os drivers USB
disponíveis para seus sistemas operacionais através do site em inglês
(www.parallax.com/go/Boe-Bot)
ou
em
português
(www.bseducacional.com.br).
Além disso, pequenos artigos de errata notado na versão anterior (2.2) foram
corrigidos. 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, 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 as
mesmas, para facilidade de utilização.
Nota para a versão 3.0.1: Programa de exemplo - AvoidTableEdge.bs2 na
página 314, e a discussão do código que segue, foram atualizados.
PÚBLICO
Este texto foi elaborado para ser a porta de entrada para o aprendizado da
tecnologia e uma curva de fácil aprendizagem para a implantação de
programas e introdução a robótica. O texto é organizado de modo que ele
possa ser usado pela ampla variedade possível de estudantes, bem como de
aprendizes independentes. Nessa tradução mantivemos comandos, nome de
fóruns e alguns outros termos em inglês para facilitar a consulta ao site e a
programação em si. Os alunos 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 testados com 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 do fórum “Stamps in Class”, citado abaixo, ou
mesmo através do portal BS Educacional, em Central de Aprendizado.
FÓRUNS DE SUPORTE
A Parallax mantém fóruns gratuitos moderados para os nossos clientes,
abrangendo uma variedade de temas, conforme tópicos abaixo. Os nomes
foram
mantidos
em
inglês
para
ajudar
na
procura:
•
•
•
•
•
•
•
•
•
Propeller Chip: para todas as discussões relacionadas com o
microcontrolador Propeller multicore e linha de desenvolvimento de
produtos ferramentas.
Basic Stamp: ideias de projetos, suporte e tópicos relacionados para
todos os modelos de Basic Stamp da Parallax.
Sensors: discussão sobre a ampla gama de sensores da Parallax, e
interface entre os sensores com microcontroladores de Parallax.
Stamps in Class: estudantes, professores, clientes discutem material
educativo e projetos escolares da Parallax.
Robotics: para todos os robôs Parallax e robôs personalizados
construídos com processadores Parallax e sensores.
Wireless: os tópicos incluem XBee, GSM / GPRS, telemetria e
comunicação de dados através de rádio amador.
Propscope: discussão e assistência técnica para este osciloscópio
USB que contém um chip da hélice.
The Sandbox: tópicos relacionados com o uso de produtos da
Parallax, mas não específicos para outros fóruns.
Projects: coloque aqui seu processo e projetos concluídos, feitos a
partir de produtos Parallax.
RECURSOS PARA EDUCADORES
Temos uma grande variedade de recursos neste texto concebidos para apoiar
os educadores.
Basic Stamp em aula "Mini Projects"
Para complementar nossos textos, nós fornecemos um banco de projetos
para a sala de aula. Projetado para envolver os alunos, cada "Mini Project”
contém um código completo de fontes, "How it Works", são esquemas e
diagramas de fiação ou fotos de um dispositivo que os estudantes possam
gostar de usar. Muitos projetos apresentam um vídeo introdutório,
promovendo o auto estudo nos alunos mais interessados em eletrônica e
programação. Basta seguir os Stamps in Class "Mini Projects" no link
www.parallax.com/Education.
Materiais Educacionais Complementares
Selecione textos educacionais da Parallax, lá você encontrará materiais
suplementares, disponíveis, tais como apresentações em PowerPoint ou
vídeos do YouTube. Confira nossa página ou entre em contato pelo e-mail
[email protected] (inglês) ou educaçã[email protected]
(português).
Permissões de Direitos Autorais para Uso Educacional.
Não é necessária licença de instalação para download, duplicação e
instalação de software Parallax para uso Educacional com produtos Parallax,
como é necessária 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 duplicados, desde que
seja para uso educacional, exclusivamente com produtos de
microcontroladores Parallax e o estudante é cobrado não mais do que o custo
de duplicação. Os arquivos PDF não são fechados, possibilitando a seleção
de texto e imagens para preparar apostilas, transparências ou apresentações
em PowerPoint.
TRADUÇÕES EM LÍNGUAS ESTRANGEIRA
Muitos de nossos textos Stamp in Class foram traduzidos para outras
línguas; estes textos estão disponíveis para downloads gratuitamente e
sujeitos a mesma permissão de direitos 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 tornou-se
autor de 11 livros e inúmeros artigos e documentos de produtos para a
empresa. As revisões de robótica com o Boe-Bot foram projetadas e
atualizadas com base em observações e comentários educacionais que Andy
coletou durante viagens nacionais e internacionais, 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 Allred Rich e Lindsay Andy; sutilezas, edição e layout por
Stephanie Lindsay. Agradecimentos especiais a Ken Gracey, fundador do
Basic Stamp no programa Class, e Tracy Allen e Pilgrim Phil pela consulta
na seleção do sensor de luz utilizado nesta versão que substitui o sulfureto
de cádmio fotoresistor. Stephanie é particularmente grato a John Kauffman
pela revisão de última hora do Capítulo 6.
O Cérebro do seu Boe-Bot · Página 17
Capítulo 1: O Cérebro do seu Boe-Bot
O robô Parallax, Inc. Boe-Bot® é o foco das atividades, projetos e concursos
neste livro. O Boe-Bot e o seu microcontrolador BASIC Stamp ® 2 são
mostrados na Figura 1-1. O módulo BASIC Stamp 2 é poderoso e fácil de
usar, especialmente com um robô.
Figura 0-1
Módulo
BASIC
Stamp no
robô Boe-Bot
As atividades deste texto irão guiá-lo através da escrita de programas
simples que fazem o BASIC Stamp e seu Boe-Bot fazer quatro tarefas
robóticas essenciais:
1. Monitorar os sensores para detectar o mundo ao seu redor
2. Tomar decisões com base no que capta
3. Controlar seu movimento (operando os motores que fazem as rodas
girar)
4. Trocar informações com o “robôcista” (que é você!)
A linguagem de programação que você vai usar para realizar essas tarefas é
chamada PBASIC, que compreende:
• Parallax - Empresa que inventou e fabrica microcontroladores BASIC
Stamp
• Iniciantes - Feito para iniciantes para aprender a programar computadores
• Todos os fins - Poderoso e útil para a resolução de diferentes tipos de
problemas
• Simbólicos - O uso de símbolos (termos que se assemelham a
palavra/frase em Inglês)
• Instrução - Para dizer a um computador o que fazer
• Código - Em termos de que o computador (e você) possam entender
O que é um microcontrolador? É um dispositivo programável que é
projetado para seu relógio digital de pulso, telefone celular, calculadora, rádio
relógio etc. Nestes dispositivos, o microcontrolador foi programado para
perceber quando você aperta um botão, produz ruídos eletrônicos, e controla o
display digital do dispositivo. Eles também são utilizados em maquinários de
fábricas, carros, submarinos e naves espaciais, porque eles podem ser
programados para ler sensores, tomar decisões, e harmonizar os dispositivos
que
controlam
as
partes
móveis.
O que é um microcontrolador? O Guia do Estudante é o primeiro texto
recomendado para iniciantes. Está repleto de exemplos de como usar
microcontroladores, e como fazer o BASIC Stamp, cérebro de suas próprias
invenções microcontroladas, funcionar. Está disponível para download gratuito
a partir www.parallax.com/go/WAM, e está também incluso no BASIC Stamp
Editor Help como um arquivo PDF. Ele está incluso no kit de atividades
BASIC Stamp e no kit BASIC Stamp Discovery, que são transportados por
muitos varejistas eletrônicos. Estes kits também podem ser comprados
diretamente da Parallax, ou on-line em www.bseducacional.com.br ou pelo
telefone +55 (11) 2533-9478.
HARDWARE E SOFTWARE
Começando com módulos microcontroladores BASIC Stamp é semelhante a
começar com um PC novo ou laptop. As primeiras coisas que a maioria das
pessoas têm a fazer é tirá-lo da caixa, ligá-lo, instalar e testar algum
software, e talvez até mesmo escrever algum software próprio usando uma
linguagem de programação. Se esta é a sua primeira vez usando um módulo
BASIC Stamp, você vai fazer todas essas atividades. Se você está em aula, o
hardware pode já estar pronto para você. Se este for 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 microcontrolador BASIC Stamp novo seja ligado 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 será
executado. Você também pode usar este software para visualizar mensagens
enviadas pelo BASIC Stamp que ajudam a entender o que ele capta.
Requisitos do Computador:
Você vai precisar de um computador pessoal para executar o software do
BASIC Stamp Editor. Seu computador precisa ter as seguintes
características:
•
•
•
Microsoft Windows 2K/XP/Vista/7 ou sistema operacional mais
Porta Serial disponível ou porta USB
Acesso à Internet e um navegador de Internet
Baixando o Software da Internet
É importante usar sempre a versão mais recente do software do BASIC
Stamp Editor, se possível. O primeiro passo é ir até o site internacional da
Parallax e baixar o software.
Usando um navegador da Web, vá para
www.parallax.com/ basicstampsoftware ou através do portal
www.bseducacional.com.br.
Figura 1-2: Página de download do BASIC Stamp Editor no
www.parallax.com/basicstampsoftware.
Use o "Click Here to Download" para obter a versão mais recente do
software.
 Clique no botão “Click Here to Download” para baixar a versão mais
recente
do
software
BASIC
Stamp
Editor
Windows.
 A janela de download de arquivo será aberta, perguntando se você
deseja executar ou salvar este arquivo (Figura 1-3). Clique em Salvar.
Figura 1-3
Arquivo janela de
download
Clique Salvar
(Save), e salve o
arquivo no seu
computador.
 Siga as instruções que aparecem. Quando o download terminar, clique
em Executar. Ao aparecer mensagens do sistema operacional pedindo
para verificar se você deseja continuar com a instalação, concorde.
Figura 1-4
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-
5). Clique em Avançar e siga as instruções, aceitando todos os
padrões.
Figura 1-5
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 (Figura 1-6), assinale a opção para
instalar automaticamente e, em seguida, clicar em Avançar.
Figura 1-6
Mensagem de
Instalação do Driver
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, clique no botão Instalar. Uma barra de
progresso pode aparecer, e isso pode levar alguns minutos.
Neste ponto, uma janela adicional pode aparecer atrás da janela atual,
enquanto os drivers USB estão sendo atualizados. Esta janela irá 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 que instalam 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 por 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 mais
informações, visite www.parallax.com/USBdrivers.
 Quando a janela disser que a instalação foi concluída com êxito,
clique em Concluir (Figura 1 7).
Figura 1-7
Instalação do
BASIC Stamp
Editor concluída
Clique em
Concluído
(Finish)
ATIVIDADE #2: UTILIZANDO O ARQUIVO DE AJUDA PARA
CONFIGURAÇÃO DO HARDWARE
Nesta seção você vai executar o arquivo 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 Stamps em programa de
aula, 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 desktop de seu
computador, clique duas vezes nele (Figura 1-8).

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-8
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)
(Figura 1-9) e, em seguida, selecione Help BASIC Stamp.
Figura 1-9
Abrindo o menu Ajuda
(Help).
Clique Ajuda,(Help) e
escolha “HELP BASIC
Stamp” a partir do
menu drop-down.
Figura 1- 10: Editor Help BASIC Stamp
 Clique no link “Getting Started with Stamps in Class”, na parte
inferior da página “Welcome”, como mostrado no canto inferior
direito da Figura 1-10.
Seguindo as Instruções no Arquivo de Ajuda (HELP).
A partir daqui, você vai seguir as instruções do arquivo de Ajuda (Help) para
completar estas tarefas:
•
•
•
•
•
•
Identificar as placas de desenvolvimento BASIC Stamp que você
está usando.
Ligar sua placa de desenvolvimento ao seu computador.
Testar sua conexão de programação.
Solucionar problemas de sua conexão com a programação, se
necessário.
Escrever o seu primeiro programa PBASIC para o seu BASIC
Stamp.
Desligar o seu hardware quando terminar.
Quando 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.
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 de 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 moderado Stamps in Class no forums.parallax.com ou na
Central de Aprendizado do portal www.bseducacional.com.br.
• E-mail: envie um e-mail para [email protected] ou
[email protected].
• Telefone: Brasil – ligue para (11) 2533-9478 ou Estados Unidos - +1
888-99-STAMP (888 997-8267). Ou outros (916) 624-8333.
Mais recursos: Visite www.bseducacional.com.br ou
www.parallax.com/support.
SUMÁRIO
Este capítulo guiou você através do seguinte:
• Introdução ao módulo 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 a Ajuda do Editor do BASIC Stamp e do manual de
BASIC Stamp
• Introdução ao 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
• Utilizar os comandos de depuração (DEBUG) e fim (END), 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. Qual dispositivo será o cérebro do Boe-Bot?
2. Quando o BASIC Stamp envia um caractere para o seu PC / laptop,
que tipo de números são utilizados para enviar a mensagem através
do cabo de programação?
3. Qual é o nome da janela que exibe mensagens enviadas a partir do
BASIC Stamp para o seu PC / laptop?
4. Que comandos PBASIC você aprendeu neste capítulo?
Exercícios
1. Explique o que o asterisco faz neste comando: DEBUG DEC 7 *
11.
2. Adivinhe o que o DEBUG Terminal iria mostrar se você
executasse este comando: DEBUG DEC 7 + 11.
3. Há 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. Devese 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 estabelecer o comando DEBUG mostrado abaixo na linha
antes do comando END do programa que outras linhas você
poderia deletar e ainda 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 BASIC Stamp 2 módulo controlador.
Q2. Números binários, que são 0’ s e 1’ s
Q3. DEBUG Terminal
Q4. DEBUG e END
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
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
As últimas três linhas de DEBUG podem ser excluídas. Um CR
adicional é necessário depois da mensagem “Hello”.
' O que é um Microcontrolador - Ch01Prj02_ FirstProgramYourTurn.bs2
' BASIC Stamp envia mensagens para o DEBUG Terminal.
'{$ STAMP BS2}
'{$ PBASIC 2,5}
DEBUG "Olá, sou eu, o 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 utilizada com o código anterior. Este é um exemplo do
uso de vírgulas para a saída de muitas informações, usando apenas um
comando DEBUG com vários elementos nele.
Servos Motores do Seu Boe-Bot · Página 33
Capítulo 2: Servo Motores Do Seu Boe-Bot
Este capítulo vai guiá-lo para a conexão e como ajustar e testar os motores
do Boe-Bot. Para fazer isso, você precisa entender alguns comandos
PBASIC e técnicas de programação que irão controlar a direção, velocidade
e duração de movimentos do servo. Portanto, Atividades # 1, # 2 e # 5 irão
apresentá-lo a essas ferramentas de programação, e depois Atividades # 3, #
4, # 6 irão mostrar como aplicá-las para os servos. Com o controle preciso
do servo, você terá a chave para o desempenho do Boe-Bot. Portanto, é
necessário e importante completar essas atividades antes de montar os servos
no chassi Boe-Bot.
APRESENTANDO O SERVO DE ROTAÇÃO CONTÍNUA
Os servos de rotação contínua Parallax mostrados na Figura 2-1 são os
motores que vão fazer o Boe-Bot rodar. Esta figura mostra as partes externa
dos servos. Muitas dessas peças serão mencionadas quando você passar
pelas instruções deste e do próximo capítulo.
Figura 2-1: Servo de Rotação Contínua Parallax
Flange de
montagem
Horn de
controle
Plugue
conector para
o servo RC
Chave
phillips
A etiqueta
deve ser lida
“Rotação
Contínua”
Flange de
montagem
Cabo de
alimentação
e controle de
sinal
Furo de acesso ao
potenciometro para
ajuste de retorno de
centro
Dentro da caixa há um
motor elétrico, circuitos
e engrenagens
Nota: Essa página pode ser útil. Marque-a para que possa usar como referência mais
tarde.
Servos padrão (Standard) vs. Servos de Rotação Contínua: Servos
padrão são projetados para receber sinais eletrônicos que diz-lhes a
posição a ser mantida. Estes servos controlam as posições de flaps
controlados por rádio de avião, de barco, lemes e direção de carro.
Servos de rotação contínua recebem os mesmos sinais eletrônicos,
mas em vez de manter certas posições, eles se deslocam em
determinadas velocidades e direções. Servos de rotação contínua são
ideais para controlar rodas e roldanas.
Servo de Controle Horn - 4 pontos - Estrela vs. Disco: Não faz
diferença. É o servo para o seu Boe-Bot, desde que seja rotulado de
"rotação contínua". Você substituirá o Horn de controle por uma roda.
ATIVIDADE #1: CONSTRUINDO E TESTANDO O CIRCUITO DE
LED
Controlar a velocidade e direção de um servo motor envolve um programa
que faz o BASIC Stamp enviar a mesma mensagem, uma vez ou outra. A
mensagem terá que ser repetida em torno de 50 vezes por segundo para o
servo manter a sua velocidade e direção. Esta atividade tem alguns exemplos
de programas PBASIC que demonstram como repetir a mesma mensagem,
repetidas vezes, e controlar o tempo da mensagem.
Exibindo Mensagens a Velocidades Humanas
Você pode usar o comando PAUSE para dizer ao BASIC Stamp que é
necessário esperar um pouco antes de executar o próximo comando.
PAUSE Duration
O número que você colocou à direita do comando PAUSE é chamado de
argumento Duration, e é o valor que informa ao BASIC Stamp quanto
tempo deve esperar antes de passar para o próximo comando. As unidades
para o argumento Duration são milésimos de segundo (ms). Então, se você
quiser esperar por um segundo, use um valor de 1000. Aqui está como o
comando deve ser:
PAUSE 1000
Se você quiser esperar o dobro do tempo, tente:
PAUSE 2000
O segundo abreviado é "s". Neste texto, quando você ver um 1 s, significa um
segundo.
Um milésimo de segundo é um segundo dividido por mil, e é abreviado "ms".
O comando PAUSE 1000 gera atrasos do programa em 1000 ms, que é de
1000/1000 de um segundo, o que é um segundo, ou 1s. Entendeu?
Programa de exemplo: TimedMessages.bs2
Há muitas maneiras diferentes de usar o comando PAUSE. Este programa de
exemplo usa PAUSE para gerar um atraso entre as mensagens de impressão
que indicam quanto tempo já foi decorrido. O programa deve esperar um
segundo antes de enviar a mensagem "Um segundo decorrido...” e mais dois
segundos antes de exibir a mensagem "Três segundos decorridos.”
 Se você tem um Board of Education, mova a chave de três posição da
posição-0 para a posição-1.
 Se você tem um Home Work Board, reconecte a bateria de 9V no
clipe da bateria.
 Digite o programa abaixo no BASIC Stamp Editor.
 Salve o programa com o nome TimedMessages.bs2.
 Execute o programa, e depois veja o atraso entre as mensagens.
' Robótica com o Boe-Bot - TimedMessages.bs2
' Mostra como o comando PAUSE pode ser usado para exibir mensagens em
' velocidade humana.
' {$ Stamp BS2}
' {$ PBASIC 2,5}
DEBUG "Iniciar temporizador..."
PAUSE 1000
DEBUG CR, "Um segundo decorrido ..."
PAUSE 2000
DEBUG CR, "Três segundos decorridos ..."
DEBUG CR, "Pronto."
END
Daqui em diante, as três instruções que vieram antes deste programa serão
formuladas assim:

Abra, salve e execute o programa TimedMessages.bs2.
Sua Vez – Diferentes Durações de Pausa
Você pode alterar o intervalo entre mensagens alterando os argumentos dos
comandos de duração de pausa.
 Tente alterar os argumentos duração de pausa entre 1000 e 2000 a
5000 e 10000, por exemplo
"DEBUG "Iniciar temporizador..."
PAUSE 5000
DEBUG CR, "Cinco segundos decorridos..."
PAUSE 10000
DEBUG CR, "Quinze segundos decorridos..."
 Execute o programa modificado.
 Também tente novamente com números como 40 e 100 para os
argumentos Duração; eles vão muito rápido.
 O argumento Duração mais longo possível é 65535. Se você tem um
minuto a perder, tente PAUSE 60000.
Repetidamente
Uma das melhores coisas sobre os computadores e microcontroladores é que
eles nunca se queixam de fazer as mesmas coisas chatas várias vezes. Você
pode colocar seus comandos entre as palavras DO e LOOP, se quiser os
executar mais vezes. Por exemplo, digamos que você deseja exibir uma
mensagem repetida uma vez a cada segundo. Basta colocar os comandos
DEBUG e PAUSE entre as palavras DO e LOOP como este:
DO
DEBUG "Olá!", CR
PAUSE 1000
LOOP
Programa de exemplo: HelloOnceEverySecond.bs2
 Coloque, salve e execute o programa HelloOnceEverySecond.bs2.
 Verifique se a mensagem "Olá!" é exibida uma vez a cada segundo.
' Robótica com o Boe-Bot - HelloOnceEverySecond.bs2
' Exibe uma mensagem uma vez a cada segundo.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG "Olá!", CR
PAUSE 1000
LOOP
Sua Vez - uma mensagem diferente
Você pode modificar o seu programa para o modo executar uma vez, e
outra para executar mais de uma vez.
 Modifique o programa para os comandos parecidos com este:
DEBUG "Olá!"
DO
DEBUG "!"
PAUSE 1000
LOOP

Execute e veja o que acontece! Será que você pode antecipar o
resultado?
ATIVIDADE #2: MONITORANDO O TEMPO E REPETINDO
AÇÕES COM UM CIRCUITO
Nesta atividade, você vai construir circuitos que emitem luz que lhe
permitirão "ver" o tipo de sinais usados para controlar os motores do servo
Boe-Bot.
O que é um microcontrolador? Esta atividade contém trechos selecionados
sobre o que é um microcontrolador. Guia do Estudante.

Mesmo se você estiver familiarizado com este material sobre o que é
um microcontrolador, não pule esta atividade.
Na segunda metade da atividade, você vai examinar os sinais que controlam os
seus servos e diagramas de tempo de uma forma diferente do que eles foram
apresentados em “O que é um microcontrolador?”.
Bônus! Os componentes do kit Boe-Bot podem ser usados para completar
muitas das atividades no microcontrolador. Vá para
www.paralllax.com/go/WAM, para uma lista completa e para baixe o texto.
Apresentando o LED e Resistor
A “resistência” é 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: Ω. O
resistor que você estará trabalhando nesta atividade é a resistência de 470 Ω
mostrado na Figura 2-2. A resistência tem dois fios (chamados de "leads" e
pronunciado "liids"), cada um saindo de uma extremidade. Há uma caixa de
cerâmica entre os dois terminais, e é a parte que resiste à passagem da
corrente. A maioria dos diagramas de circuitos que mostram resistências
usam o símbolo do lado esquerdo com as linhas onduladas para informar a
pessoa que na montagem do circuito ela deverá usar um resistor de 470 Ω.
Isso é 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
470 Ω desenho da peça
Resistor
Esquemática símbolo (à
esquerda) e parte de
desenho (à direita)
As listras coloridas indicam valores de resistência. Veja o Apêndice B:
Códigos de cor de resistores e regras breadboarding na página 370 para obter
informações sobre como determinar o valor de um resistor das listras coloridas
na sua caixa de cerâmica.
O ‘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, normalmente, 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 atual, você tem que ter certeza de
conectá-lo da maneira correta, ou não vai funcionar como previsto.
Figura 2 -3 mostra símbolo esquemático de um LED e 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ê tem que prestar atenção e certificar-se que as ligações de ânodo e
cátodo estão conectadas para o 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 marcado com um sinal-de menos (-), e sobre o símbolo esquemático, o
cátodo é a linha sobre o ponto do triângulo.
Figura 2-3
Desenho Parte LED e símbolo
esquemático
Desenho da peça (acima) e
esquemática símbolo (abaixo)
Os desenhos de peças de LED em
imagens mais tarde terão um + ao
lado da perna ânodo.
_
+
LED
Quando você começar a construir seu circuito, certifique-se de verificar se
ele está em sentido oposto ao símbolo esquemático e o desenho da peça. Se
você olhar atentamente para o recipiente de plástico do LED no desenho da
peça, verá que é mais redondo, mas há um ponto pequeno bem perto de uma
das pistas que lhe diz que ele é o cátodo. Observe também que o que leva o
LED são as diferentes extensões. Neste texto, o ânodo será mostrado com
um sinal (+) e o cátodo será mostrado com um sinal de (-).
Sempre verifique a caixa de plástico LED. Geralmente, o condutor longo é
ligado ao ânodo do diodo emissor de luz, e o mais curto é ligado ao seu cátodo.
Ás vezes os fios podem ter sido cortados com o mesmo comprimento, ou um
fabricante não seguiu essa convenção, portanto, o melhor é sempre procurar a
parte plana da caixa. Se você conectar um LED para trás, isso não vai estragálo, mas não vai acender.
Teste de Peças do Circuito de LED
(2) LEDs – Vermelho
(2) Resistores, 470 Ω (amarelo, violeta, marrom)
Sempre desconecte a alimentação antes de construir ou modificar
circuitos! Para o Board of Education coloque a chave da posição 3 para a
posição 0. Para o BASIC Stamp HomeWork Board, desligue a bateria de 9 V
do clipe da bateria. Sempre verifique se o circuito está livre de erros antes de
ligá-lo novamente.
Circuito de Teste do LED
Se você concluiu o teste do que é um microcontrolador, está, sem dúvida,
familiarizado com o circuito mostrado na Figura 2-4. O lado esquerdo desta
figura mostra o esquema do circuito, e o lado direito mostra um exemplo de
diagrama de fiação do circuito construído na área de sua placa de
prototipagem.
 Construir o circuito mostrado na Figura 2-4.
 Certifique-se de que os pinos mais curtos em cada LED (os
cátodos) estão ligados nos soquetes pretos rotulados Vss.
 Verifique se os pinos mais longos (os ânodos, marcados com um
⊕ no esquema de ligações) estão ligados aos soquetes brancos do
breadboard exatamente como mostrado.
Vdd
X3
P13
470 Ω
P12
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-4
Dois LEDs
Conectados
ao BASIC
Stamp I / O
pins P13 e
P12
Esquemátic
o(esquerda)
e esquema
de ligações
(à direita)
O que é um I/O pin? I/O está para entrada / saída. O BASIC Stamp 2 tem 24
pinos, 16 dos quais são I / O pins. Neste texto, você irá programar o BASIC
Stamp usando pinos de I/O como saídas para fazer as luzes do LED ligar /
desligar, controlar a velocidade e direção que servos contínuos Parallax virarão,
para fazer com que toquem com um alto-falante, e preparar sensores para
detectar luz e objetos. Você também vai programar o BASIC Stamp usar pinos
de I/O como entradas para monitorar sensores que indicam um contato
mecânico, nível de luz, objetos no caminho do Boe-Bot, e até mesmo a
distância.
Construindo novos circuitos? Veja o Apêndice B: Códigos de cor de
resistores e regras breadboarding na página 369.
A figura 2-5 mostra como você vai programar o BASIC Stamp para o
circuito de LED. Imagine que você tem uma bateria de 5 volts (5 V).
Embora a bateria de 5 V não seja comum, o Board of Education tem um
dispositivo chamado regulador de tensão que alimenta o BASIC Stamp com
o equivalente de uma bateria 5 V. Quando você conecta um circuito para
Vss, é como ligar o circuito para o terminal negativo da bateria 5 V. Ao ligar
a outra extremidade do circuito de Vdd, é como ligar ao terminal positivo de
uma bateria 5 V.
Vdd +
-
N
5V
Vss _
+++
+++
+++
--- - -N
-N - N
-
+
+
=
N
Vdd +
-
-
N N
N N N
-
-
-
-
-
-
-
-
5V
Vss _
+++
+++
+++
--- - -N
--N
N
-
Figura 2-5
O fluxo de
corrente e
Eletrônica
-
Volts é abreviado V. Isso significa que 5 volts é abreviado 5 V. Quando você
aplicar voltagem a um circuito, é como a aplicação de pressão elétrica.
Corrente refere-se à taxa à qual os elétrons passam através de um
circuito. Você vai ver muitas vezes medidas de corrente expressas em
Ampères, cuja abreviação é A. O montante de corrente em um moto elétrico é
frequentemente expresso em amperes, por exemplo, 2 A, 5 A, etc., no entanto,
as correntes que você irá usar no Board of Education são medidas em
milésimos de amperes, ou miliamperes. Por exemplo, 10,3 mA passa através
do circuito na Figura 2-5.
Quando essas ligações são feitas, 5 V de tensão elétrica é aplicada ao
circuito, provocando uma circulação de elétrons e o LED emite luz. Assim
que você desligar o fio de resistência do terminal positivo da bateria, a
corrente para de fluir, e o LED para de emitir luz. Você pode dar um passo
adiante, conectar o cabo resistor para Vss, que tem o mesmo resultado. Esta
é a ação que irá programar o BASIC Stamp fazendo com que o LED ligue
(emitindo luz) e desligue (não emitindo luz).
Programas que Controlam os Circuitos de Teste de LED
Os comandos HIGH e LOW podem ser usados para fazer o BASIC Stamp
ligar um LED alternadamente para Vdd e Vss. O argumento Pin é um
número entre 0 e 15 que diz ao BASIC Stamp qual I / O pino para ligar a
Vdd ou Vss.
HIGH Pin
LOW Pin
Por exemplo, se você usar o comando:
HIGH 13
... Diz ao BASIC Stamp para conectar I / O pino P13 para Vdd, que acende
o LED.
Da mesma forma, se você usar o comando:
LOW 13
... Diz ao BASIC Stamp para conectar I / O pino P13 para Vss, que acende o
LED. Vamos tentar fazer isso.
Programa Exemplo: HighLowLed.bs2
 Volte a ligar o seu quadro.
 Coloque, salve e execute o programa HighLowLed.bs2
 Verifique se o circuito de LED conectado a P13 está ligado ou
desligado a cada segundo.
' Robótica com o Boe-Bot - HighLowLed.bs2
' Acende o LED conectado a P13 on/off uma vez a cada segundo.
' {$STAMP BS2}
' {$PBASIC 2,5}
DEBUG "O LED conectado ao pino 13 está piscando!"
DO
HIGH 13
PAUSE 500
LOW 13
PAUSE 500
LOOP
Como Funciona HighLowLed.bs2
Figura 2- 6 mostra como o BASIC Stamp pode conectar um circuito de LED
alternadamente para Vdd e Vss. Quando está ligado a VDD, o LED emite
luz. Quando está conectado ao Vss, o LED não emite luz. O comando HIGH
13 instrui o BASIC Stamp a conectar P13 para Vdd. O comando PAUSE 500
instrui o BASIC Stamp para deixar o circuito nesse estado por 500 ms. A 13
comando LOW instrui o BASIC Stamp para ligar o LED para Vss.
Novamente, o comando PAUSE 500 instrui o BASIC Stamp para deixá-lo
naquele estado para outro 500 ms. Uma vez que esses comandos são
colocados entre DO e LOOP, eles são executados repetidamente.
SOUT
1
SIN
2
BS2
24
VIN
23
VSS
SIN
2
22
SOUT
1
BS2
24
VIN
23
VSS
22
RES
ATN
3
RES
ATN
3
VSS
4
21
VDD (+5V)
VSS
4
21
VDD (+5V)
P0
5
20
P15
P0
5
20
P15
P1
6
19
P14
P1
6
19
P14
18
18
P13
Vdd
Vdd
P2
7
P13
P2
P3
8
17
P12
P3
8
17
P12
P4
9
16
P11
P4
9
16
P11
P5 10
15
P10
P5 10
15
P10
P6
14
P9
P6
14
P9
13
P8
P7 12
13
P8
Vss
11
P7 12
BS2-IC
7
Vss
11
BS2-IC
Figura 2-6
BASIC Stamp
Switching
O BASIC Stamp
pode ser
programado
para ligar
internamente a
entrada do
circuito de LED
para Vdd ou
Vss.
Um Teste de Diagnóstico para o Seu Computador
Poucos computadores, como alguns laptops, vão interromper o programa
PBASIC após o primeiro tempo através de uma instrução DO...LOOP. Estes
computadores não têm um design da porta serial padrão. Ao colocar um
comando DEBUG o programa LedOnOff.bs2, a abertura do DEBUG Terminal
impede que isso possivelmente aconteça. Você irá reexecutar esse programa
sem o comando DEBUG para ver se o seu computador tem este problema nãopadrão de porta serial. Não é comum, mas é importante que você saiba.
 Abrir HighLowLed.bs2.
 Eliminar a instrução DEBUG inteiro.
 Executar o programa modificado enquanto você observar o seu LED.
Se o LED piscar de forma contínua, tal como aconteceu quando você
executou o programa original com o comando DEBUG, o computador não terá
esse problema.
Se o LED piscar apenas uma vez e depois parar, você tem um computador
com um design não-padrão de porta serial. Se você desconectar o cabo de
programação de sua placa e pressionar o botão Reset, o BASIC Stamp vai
executar o programa corretamente, sem congelamento. Nos programas que
você escrever, você deve adicionar um único comando:
DEBUG "Programa funcionando!"
Logo após as diretivas de compilador. Isto irá abrir o DEBUG Terminal e
manterá a porta COM aberta. Isso impedirá seus programas de
congelamento após uma passagem pelo LOOP ..., ou qualquer um dos
outros comandos looping, isto você aprenderá em capítulos posteriores.
Você vai ver este comando em alguns dos programas de exemplo que de
outra forma não precisam de uma instrução DEBUG. Então, você deve ser
capaz de executar todos os programas restantes deste livro, mesmo se o seu
computador não passou no teste de diagnóstico.
Apresentando o Diagrama de Tempo
Um diagrama de temporização é um gráfico que relaciona HIGH (Vdd) e LOW
(Vss) para sinais de tempo. Na Figura 2-7, tempo aumenta da esquerda para
a direita, e os sinais de altos e baixos alinham com qualquer Vdd (5 V) ou
Vss (0 V). Este diagrama de tempo mostra-lhe uma fatia 1.000 ms do sinal
de alta / baixa que você testou. A linha de pontos (...) para a direita do sinal
é
uma
maneira
de
indicar
que
o
sinal
se
repete.
Figura 2-7
Diagrama de tempo
para
HighLowLed.bs2
500 ms
…
Vdd (5 V)
Vss (0 V)
O LED on / off
estados são
mostrados acima no
diagrama de
temporização.
500 ms
1000 ms
Sua Vez - Pisque o Outro LED
Se piscar o outro LED (ligado ao P12) é uma simples questão de mudar o
argumento Pin nos comandos HIGH e LOW e reexecutar o programa.

Modifique o programa para que os comandos pareçam com este:
DO
HIGH 12
PAUSE 500
LOW 12
PAUSE 500
LOOP
 Execute o programa modificado e verifique se ele faz piscar outro
LED on / off.
Você também pode fazer que vários LEDs pisquem ao mesmo tempo.
DO
HIGH 12
HIGH 13
PAUSE 500
LOW 12
LOW 13
PAUSE 500
LOOP
 Execute o programa modificado e verifique se ele faz com que os dois
LEDs pisquem aproximadamente ao mesmo tempo.
Você pode modificar o programa novamente para fazer piscarem
alternadamente on / off, e você também pode alterar as taxas que os LEDs
piscam, ajustando o argumento do comando PAUSE de duração High ou
Low.
 Experimente!
Visualizando um Sinal de Controle do Servo com um LED
Com sinais High e Low você vai programar o BASIC Stamp para enviar
para os servo-motores a duração muito precisas de tempo. Isso porque os
servo-motores medem a quantidade de tempo em que o sinal permanece alto,
e usá-lo como uma instrução para onde se virar. Para um controle preciso do
servo motor, o tempo que estes sinais permanecem alto deve ser muito mais
preciso do que você pode obter com o comando HIGH ou PAUSE. Você só
pode alterar o argumento do comando PAUSE de duração de 1 ms (lembre-se,
que é 1/1000 de um segundo) de cada vez. Há um comando diferente
chamado PULSOUT que pode emitir sinais de alta para quantidades precisas
de tempo. Estes valores de tempo são valores que você usa no argumento
Duration, e eles são medidos em unidades que são dois milionésimos de
segundo!
Duração PULSOUT Pin
O “microssegundo” é um milionésimo de segundo. É abreviado μs. Tenha
cuidado ao escrever este valor, não é 'u' a letra do nosso alfabeto, é 'μ' o mu
da letra grega.
Por exemplo, 8 microssegundos é abreviado 8 μs.
Você pode enviar um sinal HIGH que acende o P13 LED para 2 μ que é dois
milionésimos de segundo) usando o comando:
PULSOUT 13, 1
Este comando iria acender o LED para 4 µs:
PULSOUT 13, 2
Este comando envia um sinal de que você pode realmente ver:
PULSOUT 13, 65000
Quanto tempo o circuito de LED conectado a P13 permanece quando você
enviar este pulso? Vamos descobrir isso. O tempo que permanece é 65000
vezes 2 µs. Isso é:
Duration = 65000 × 2 µs
= 65000 × 0.000002 s
= 0.13 s
Que ainda é muito rápido, 13 centésimos de segundo.
O maior valor que você pode usar em um argumento Duração PULSOUT
é 65535.
Programa de Exemplo: PulseP13Led.bs2
Este diagrama de tempo na Figura 2-8 mostra a sequência de pulso que você
está prestes a enviar ao LED com este novo programa. Desta vez, o sinal de
alta dura 0,13 segundo, e o sinal de baixa tem a duração de 2 segundos. Esta
é 100 vezes mais lenta do que o sinal de que o servo irá precisar para
controlar o seu movimento.
0.13 s
0.13 s
Figura 2-8
Diagrama de tempo
para
PulseP13Led.bs2
Vdd (5 V)
Vss (0 V)
2.0 s


Coloque, salve e execute o programa PulseP13Led.bs2.
Verificar se o circuito de LED está ligado a pulsos P13 durante cerca
de 13 centésimos de segundo, uma vez a cada dois segundos.
' Robótica com o Boe-Bot - PulseP13Led.bs2
' Envia pulso de 0,13 segundo para o circuito de LED ligado a P13 cada 2 s.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 13, 65000
PAUSE 2000
LOOP
Programa de Exemplo: PulseBothLeds.bs2
Este programa de exemplo envia um impulso ao diodo emissor de luz ligado
a P13, e, em seguida, envia um impulso ao diodo emissor de luz ligado a
P12, como mostrado na Figura 2-9. Depois disso, faz uma pausa de dois
segundos.
Figura 2-9
Diagrama de
tempo para
PulseBothLeds.bs2
O LED emite luz
para 0,13 segundo,
enquanto que o
sinal é alto.
As tensões (Vdd e Vss) neste diagrama de tempo não são rotuladas. Com o
carimbo de base, é compreendido que o sinal de alta é de 5 V (Vcc) e o sinal de
baixa é de 0 V (VSS).
Esta é uma prática comum em documentos que explicam a temporização dos
sinais HIGH e LOW. Muitas vezes, há um ou mais desses documentos para
cada componente dentro do circuito que um engenheiro está projetando. Os
engenheiros que criaram o BASIC Stamp tiveram que vasculhar muitos desses
tipos de documentos procurando informações necessárias para ajudá-los a
tomar decisões ao projetar o produto.
Às vezes, os tempos também são deixados de fora, ou apenas mostrados com
um rótulo, como tHigh e tLow. Em seguida, os valores de tempo desejados
para a tHigh e tLow estão listados na tabela em algum lugar após o
diagrama de temporização. Este conceito é discutido com mais detalhes no
Basic Analog and Digital, e em outros Stamps da Parallax no Guia do
Estudante.
 Coloque, salve e execute o programa PulseP13Led.bs2.
 Verificar ambos os circuitos do diodo emissor de impulsos,
simultaneamente, durante cerca de 13 centésimos de segundo, uma
vez a cada dois segundos.
' Robótica com o Boe-Bot - PulseBothLeds.bs2
' Envia pulso de 0,13 segundo a P13 e P12 a cada 2 segundos.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 13, 65000
PULSOUT 12, 65000
PAUSE 2000
LOOP
Sua Vez – Visualizando o Sinal do Servo à Velocidade Máxima
Lembre-se que o sinal do servo é 100 vezes mais rápido que o programa que
acabou de rodar. Primeiro, vamos tentar executar o programa de 10 vezes
mais rápido. Isso significa dividir todos os argumentos Duração (PULSOUT e
PAUSE) por 10.
DO
PULSOUT 13, 6500
PULSOUT 12, 6500
PAUSE 200
LOOP

Execute e verifique se ele faz o LEDs piscar 10 vezes mais rápido.
Agora, vamos tentar 100 vezes mais rápido (100 de duração). Em vez de
aparecer piscando, o LED apenas parece não ser tão brilhante como seria
quando você envia um sinal simples de alta. Isso porque o LED está
piscando, ligando e desligando, rapidamente, e por esses breves períodos de
tempo o olho humano não consegue detectar em tempo real cintilações on /
off, mas apenas uma alteração na luminosidade.

Modifique o programa para comandos parecidos com este:
DO
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
LOOP

Execute o programa modificado e verifique se ele faz dois LEDs
sobre o mesmo brilho.
 Tente substituir 850 no argumento de duração para o comando
PULSOUT P13.
DO
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
LOOP
 Execute o programa modificado e verifique se o LED P13 agora
parece um pouco mais brilhante do que o LED P12. Você pode
colocar suas mãos em torno do interior LEDs e espreitar para ver a
diferença. Eles diferem, porque a quantidade de tempo que os P13
LED ficam nele é maior do que a quantidade de tempo que o LED
permanece no P12.
 Tente substituir 750 no argumento de duração para ambos os
comandos PULSOUT.
DO
PULSOUT 13, 750
PULSOUT 12, 750
PAUSE 20
LOOP
 Execute o programa modificado e verifique que o brilho de ambos os
LEDs é o mesmo. Pode não ser óbvio, mas o nível de brilho entre
aqueles é dado por argumentos de duração de 650 e 850.
ATIVIDADE #3: LIGANDO OS SERVO MOTORES
Nesta atividade, você vai construir um circuito que liga o servo a uma fonte
de alimentação e um BASIC Stamp I / O pin. Os circuitos de LED que você
desenvolveu na última atividade serão utilizados mais tarde, para monitorar
os sinais do BASIC Stamp enviados para os servos para controlar seu
movimento.
Peças para Conexão dos Servos
(2) Servos de rotação contínua da Parallax.
(2) Circuitos de LED construídos e testados na atividade anterior
Encontrar as Instruções de Conexão para Sua Placa Transportadora
Existem diferentes revisões do Board of Education e BASIC Stamp
HomeWork. Além disso, existem diversas variações para o Board of
Education, com base em interface de programação. No Capítulo 1, você
usou o arquivo BASIC Stamp de Ajuda do Editor para determinar o tipo e
revisão de sua placa, e instruções especiais para placas mais antigas.
As instruções contidas neste livro foram escritas para apoiar as placas que
eram atuais no momento em que o mesmo foi escrito, e revisões anteriores
compatíveis:
• Board of Education Serial - Rev. C ou superior
• Board of Education USB - Rev. A ou superior
• BASIC Stamp HomeWork Board Serial - Rev. C ou superior
• BASIC Stamp HomeWork Board USB - Rev. A ou superior
 Examine a rotulagem no seu quadro de operadora e faça a anotação
do tipo e anotação da revisão.
 Para as placas mais antigas, verifique BASIC Stamp Editor Help para
anotações específicas para a sua placa.
(916) 624-8333
www.parallaxinc.com
www.stampsinclass.com
Vdd
Vin
Rev B
Figura 2-10
BASIC Stamp
Switching
P3
P2
P1
P0
X2
Board of Education
Vss
Rev C
X3
© 2000-2003
Rev A
15 14
13 12
STA
in C MP S
LA SS
Red
Black
X4
Vdd
X5
Vin
X3
Rev B
Vss
VR1
X3
Vdd
nc
Vss
X2
5
O BASIC Stamp
pode ser
programado para
ligar
internamente a
entrada do
circuito de LED
para Vdd ou Vss.
 Se sua placa é uma do tipo e teve revisões listadas acima, vá para uma
das páginas seguintes para continuar:


Board of Education: vá para página 58.
HomeWork Board: vá para página 62.
Conectando os Servos no Board of Education
 Desligue a energia, virando o interruptor da posição 3 para a posição
0, no Board of Education (ver Figura 2-11).
Reset
0
1
2
Figura 2-11
Desligue a
alimentação
Figura 2-12 mostra o cabeçalho servo no Board of Education. Esta placa
caracteriza um salto que você pode usar para se conectar a fonte de energia
do servo ou Vin ou Vdd. Para movê-lo, você tem que puxar para cima e para
fora do par de pinos que está ligado, em seguida, empurre-o para o par de
pinos que você quer, para descansar.
 Se você estiver usando o bateria de 6 V, certifique-se de que o salto
entre as portinholas do servo no Board of Education estão definidas
para Vin como mostrado no lado esquerdo da Figura 2 12.
Sobre baterias recarregáveis. O Boe-Bot requer 6 V, facilmente obtidos a
partir de 4 pilhas AA 1,5 V. Pilhas alcalinas AA são 1,5 V. No entanto, muitas
pilhas AA recarregáveis fornecem apenas 1,2 V, dando um total de 4,8 V, o que
não é suficiente para abastecer o BASIC Stamp e Boe-Bot. Se você não
conseguir encontrar pilhas de 1,5 V recarregáveis, você pode usar uma mais
barata Boe-Boost (# 30078) para adicionar uma quinta bateria 1,2 V
recarregável, trazendo de volta o total de 6 V.
 Se você estiver usando uma 7,5 V, 1000 mA centro de abastecimento
DC positivo, defina o salto para Vdd como mostrado no lado direito
da Figura 2- 12.
ATENÇÃO - Desvio de suprimentos AC movidos a DC pode danificar seus
servos.
Se você é inexperiente com fontes DC, considere ficar com a bateria de 6 V
que vem com o Boe-Bot.
Utilize apenas fontes de corrente contínua com potência de saída de tensão
entre 6 e 7,5 V, e avaliações de saída de corrente de 800 mA ou mais.
Somente utilize uma fonte DC, que está equipada com o mesmo tipo de ficha
conforme a bateria Boe-Bot (2,1 mm, de centro-positivo).
15 14 Vdd 13 12
Red
Black
X4
X5
Vin
Selecione Vdd se você
estiver usando uma fonte
DC que se conecta a uma
tomada AC (adaptador
AC).
15 14 Vdd 13 12
Selecione Vin se você
estiver usando a bateria
que vem com os kits BoeBot.
Red
Black
X4
Figura 2-12
Seleção de
Abastecimento das portas
de seu Servo no Board of
Education
X5
Vin
Todos os exemplos e instruções deste livro vão utilizar a bateria. Figura 2 13 mostra o esquema do circuito, que você irá construir no Board of
Education. O salto está definido no Vin.
 Conecte seus servos no seu Board of Education, como mostrado na
Figura 2-13.
Vin
White
Red
Black
P13
White
Red
Black
Vss
15 14 Vdd 13 12
Vin
White
Red
Black
P12
White
Red
Black
Red
Black
X4
Figura 2-13
Conexões do
servo para o
Board of
Education
X5
Vss
Como posso saber qual servo está ligado ao P13 e que servo está ligado ao
P12? Você apenas ligará seus servos em cabeçalhos com números superiores a
eles. Se o número acima do cabeçalho, onde o servo está conectado é de 13,
significa que o servo está ligado a P13. Se o número é 12, significa que ele está
ligado ao P12.
 Quando terminar a montagem do sistema, saiba que este deve
assemelhar-se a figura 2-14 (circuitos de LED não mostrados).
Figura 2-14
Board of Education com servos e
baterias conectados
 Se você removeu os circuitos de LED após a atividade # 2, certifique-
se de reconstruí-los como mostrado na Figura 2- 15. Eles serão os
sinais de monitoramento dos circuitos do servo.
Vdd
Vin
X3
P13
470 Ω
P12
470 Ω
LED
Vss
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vss
+
+
Figura 2-151
LED de sinal do
circuito do
monitor do
servo
Desligar a energia para o Board of Education
Nunca deixe o seu sistema ligado quando não estiver trabalhando nele.

Para desligar a alimentação do seu Board of Education, mova o
interruptor da posição-3 para a posição-0.
 Vá para Atividade # 4: Centralização dos Servos na página 67.
Conectando os Servos no BASIC Stamp HomeWork Board
Se você está conectando seus servos a um BASIC Stamp HomeWork Board
você vai precisar das peças listadas abaixo e mostradas na Figura 2-16:
Lista de Peças:
(1) Bateria com terminais estanhados (não incluída, consulte o
Apêndice A)
(2) Servos de rotação contínua da Parallax
(2) 3-pinos macho (não incluídos, consulte o Apêndice A)
(4) fios
(4) pilhas AA - 1,5 V alcalinas
(2) Circuitos LED, construídos e testados na atividade anterior
Figura 2-16
Peças de centralização do servo
para HomeWork Board
A Figura 2- 17 mostra um esquema dos circuitos de servo no HomeWork
Board. Antes de começar a construir este circuito, certifique-se de que a
energia está desligada.

A bateria de 9 V deve ser desconectada do clipe da bateria, e a
bateria com terminais estanhados não deve ter baterias carregadas.
Vbp
White
Red
Black
P13
Figura 2-17
Esquema de conexão do Servo para
o BASIC Stamp HomeWork Board
Vss
Vbp
White
Red
Black
P12
Nota: Vbp significa bateria de
tensão. Veja o i-box abaixo.
Vss

Remova os dois circuitos de LED / resistência, e guarde as peças.
 Construir as portas do servo mostradas no lado esquerdo da Figura 2-
18.
 Re-checagem - verificar se o fio preto com listra branca está ligado ao
VBP, e o fio preto sólido conectado ao Vss.
 Re-checagem - Verificar duas vezes para se certificar de que todas as
conexões para P13, VBP, Vss, VBP (mais um), e P12 coincidem
exatamente com o esquema de ligações.
 Conectar o plug do servo ao macho, como mostrado na Figura 2 18,
no lado direito da figura.
 Re-checagem - Verificar se as cores dos fios do servo correspondem a
legenda na figura
Vbp significa bateria de tensão. Ela se refere aos 6 VDC fornecida pelas
quatro pilhas de 1,5 V, cada. Esta tensão é levada diretamente para a
breadboard para alimentar os servos do Boe-Bot. Seu BASIC Stamp ainda
será alimentado pela bateria de 9 V.
Sobre baterias recarregáveis. O Boe-Bot requer 6 V, facilmente obtidos a
partir de 4 pilhas AA 1,5 V. Pilhas alcalinas AA são 1,5 V. No entanto,
muitas pilhas AA recarregáveis fornecem apenas 1,2 V, dando um total de 4,8
V, o que não é suficiente para abastecer o BASIC Stamp e o Boe-Bot. Se
você não conseguir encontrar pilhas de 1,5 V recarregáveis, você pode usar
uma mais barata, o Boe-Boost (# 30078) para adicionar uma quinta bateria
1,2 V recarregável, trazendo de volta o total de 6 V.
Figura 2-18: Diagrama de Fiação do Servo de ligação para o Board BASIC Stamp
HomeWork
Black wire with
(916) 624-8333
white stripe
www.parallaxinc.com
Vdd
Vin
Solid Black
Wire
Vdd
Vss
Porta conexões
Vin
Rev B
Vss
X3
X3
P15
P14
P13
P12
P11
P10
P9
P8
(916) 624-8333
www.parallaxinc.com
Rev B
 P13
 Vbp
 Vss
 Vbp
 P12
P15
P14
P13
P12
P11
P10
P9
P8
 White
 Red
 Black
 Red
 White
Conexões de porta conexões Servo
por cor fio
Sua configuração, então, assemelha-se a Figura 2 -19
Figura 2-19
Fontes duplas e Servos
Conectados
 Reconstruir o circuito de LED, como mostrado na Figura 2-20.
(916) 624-8333
www.parallaxinc.com
Vdd
X3
P13
470 Ω
P12
470 Ω
LED
LED
Vss
Vss
Vin
+
Rev B
Vss
Vss
+
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 2-20
Sinal de Circuito de LED
do monitor do servo.
© 2002
HomeWork Board
 Quando todas as suas conexões forem feitas e verificadas, carregue o
pacote de baterias com as baterias e volte a ligar a pilha de 9 V no
clipe de bateria do HomeWork Board.
Desligar a energia para o HomeWork Board.
Nunca deixe seu sistema ligado a energia quando você não estiver
trabalhando com ele. Daqui em diante, o desligar será realizado em dois
passos:
 Desligue a pilha de 9 V do clipe de bateria para desconectar a
alimentação do HomeWork Board. Isso desconecta a alimentação da
Stamp BASIC embutida, e dos soquetes de energia acima da
breadboard (Vdd, Vin, e Vss).
 Remover uma bateria do pacote de bateria. Isso desconecta a energia
dos servos.
 Vá para Atividade # 4: Centralização dos Servos
ATIVIDADE #4: CENTRALIZANDO OS SERVOS
Nesta atividade, você vai executar um programa que envia aos servos um
sinal, instruindo-os a ficar parados. Como os servos não são pré-ajustados na
fábrica, eles vão começar a rodar. Então você vai usar uma chave de fenda
para ajustá-los. Isso é chamado de 'centralização' dos servos. Após o ajuste,
você irá testar os servos para se certificar se estão funcionando
adequadamente. Os programas de teste irão enviar sinais que fazem com que
os servos girem no sentido horário e anti-horário em várias velocidades.
Ferramentas e Peças do Servo
A chave de fenda Parallax mostrada na Figura 2-21 é a única ferramenta
extra que você vai precisar para esta atividade. Se necessário, qualquer
chave de fenda Phillips # 1 ponto com um eixo de 1/8" (3,18 mm) pode
resolver o problema.
Figura 2-21
Chave de fenda
Parallax
Enviando o Sinal Central
A Figura 2-22 mostra o sinal, que tem de ser enviado para o servo ligado a
P12 para calibrar. Este é o chamado "centro" do sinal, e depois que o servo
for ajustado corretamente, este sinal o instrui a ficar parado. A instrução é
constituída por uma série de pulsos de 1,5 ms com uma pausa de 20 ms entre
cada pulso.
1.5 ms
1.5 ms
P12
20 ms
Figura 2-22
Diagrama de tempo
para
CenterServoP12.bs2
Os pulsos de 1,5 ms
instruem o servo a ficar
parado.
O programa para este sinal será um comando PULSOUT e um comando de
PAUSE dentro de um DO ... LOOP. Calcular o comando PAUSE do diagrama
de tempo é fácil, vai ser PAUSE 20 para o 20 ms entre os pulsos.
Descobrir o argumento do comando PULSOUT de Pin não é tão difícil, ele
vai ser 12, para I/O pino P12. Em seguida, vamos descobrir que o
argumento do comando PULSOUT de duração tem que ser para 1,5 pulsos
ms. 1,5 ms é de 1,5 milésimos de segundo, ou 0,0015 s. Lembre-se qual
número está no argumento do comando PULSOUT de duração, multiplicar
esse número por 2 microsiemens (2 milionésimos de segundo = 0,000002
s), e você vai saber quanto tempo vai durar o pulso. Você também pode
descobrir qual argumento do comando PULSOUT de duração tem que ser
se você quiser saber o quanto de tempo você quer o pulso dure. Basta
dividir 2 microsiemens na hora que quiser que o pulso dure. Com este
cálculo:
Duration argument =
Pulse duration 0.0015 s
= 750
2 µs
0.000002 s
... Agora sabemos que o comando para um pulso de 1,5 ms a P12 será
PULSOUT 12, 750.
É melhor um centro servo de cada vez, porque dessa forma você pode ouvir
quando o motor para e como ajustá-lo. Este programa só irá enviar o sinal
central para o servo ligado ao P12, e estas próximas instruções irão guiá-lo
para o devido ajuste. Depois de concluir o processo com o servo P12, você
vai repeti-lo com o servo ligado ao P13.
 Se você tem um Board of Education, certifique-se de definir o
interruptor de 3 posições para a posição-2, como mostrado na Figura
2-23.
0
1
2
Figura 2-23
Defina o interruptor de 3 posições
para a posição -2.
 Se você estiver usando o HomeWork Board, verifique as conexões
de energia tanto para checar seu BASIC como os seus servos. A
bateria de 9 V deve ser presa ao clipe de bateria, e a bateria 6 V
deverá ter as quatro baterias carregadas.
Se os servos começarem a funcionar (ou ter espasmos), logo que você
conectar a alimentação:
Provavelmente é porque o BASIC Stamp está executando um programa
que funcionou em uma atividade anterior.

Certifique-se de inserir, salvar e executar CenterServoP12.bs2
antes de continuar a centrar o servo com as instruções que seguem
o programa de exemplo.
 Coloque, salve e execute o programa CenterServoP12.bs2, em
seguida, continuar com as instruções que acompanham o programa
Programa de Exemplo: CenterServoP12.bs2
' Robótica com o Boe-Bot - CenterServoP12.bs2
' Este programa envia pulsos de 1,5 ms para o servo ligado a P12 para
' centralização manual.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 12, 750
PAUSE 20
LOOP
Se o servo ainda não foi centrado, sua ponta vai começar a girar, e você será
capaz de ouvir o motor interno rangendo.
 Se o servo ainda não estiver centrado, utilize uma chave de fenda
para ajustar suavemente o potenciômetro no servo, como mostrado
na Figura 2-24. Ajuste o potenciômetro até encontrar a configuração
que faz o giro parar o servo.
Atenção: não force muito com a chave de fenda! O potenciômetro dentro do
servo é muito delicado, por isso tome cuidado para não pressionar mais que o
necessário.
Figura 2-24
Centro de
Regulação de um
Servo
1) Introduza a ponta da chave de
fenda Phillips no buraco de acesso
do potenciômetro
2) Rode cuidadosamente
chave de fenda para ajustar
o potenciômetro até que o
servo pare de se mover.
 Verifique se o sinal de LED do monitor de circuito conectado a P12
está ativo. Deverá estar emitindo uma luz, que indica que os
impulsos estão sendo transmitidos para o servo ligado a P12.
Se o servo já foi centrado, não será ligado. É improvável, mas um servo
danificado ou defeituoso também não irá ligar. Atividade n º 6 vai descartar
esta possibilidade antes de os servos serem instalados no seu chassi BoeBot.
 Se o servo não ligar, vá para a seção Sua Vez, de modo que você
possa testar o outro centro do servo que está ligado ao P13.
O que é um potenciômetro? O 'potenciômetro' é como uma espécie de
resistência ajustável. A resistência de um potenciômetro é ajustada com uma
peça móvel. Em alguns potenciômetros, esta peça móvel é um botão ou uma
barra deslizante, outros têm órbitas que podem ser ajustadas com chaves de
fenda. A resistência do potenciômetro no interior do servo de rotação contínua
Parallax é ajustada com uma ponta # 1 da chave de parafusos Phillips. Você
pode aprender mais sobre potenciômetros em O que é um microcontrolador? e
no guia do estudante Basic Analog and Digital.
Sua Vez - Centrar o Servo Conectado ao P13
 Repita o processo para o servo ligado a P13 utilizando este
programa:
Programa de Exemplo: CenterServoP13.bs2
' Robótica com o Boe-Bot - CenterServoP13.bs2
' Este programa envia pulsos de 1,5 ms para o servo ligado a P13 para
' centralização manual.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 13, 750
PAUSE 20
LOOP
Lembre-se de desconectar completamente a energia quando você tiver
terminado.
Se você tem o Board of Education:

Mova a posição-3 para a posição-0.
Se você tem o BASIC Stamp HomeWork Board:

Desligue a pilha de 9 V do clipe de bateria para desligar a alimentação
do Board of Education, e:
 Remova uma bateria do pacote de bateria.
ATIVIDADE #5: COMO ARMAZENAR VALORES E CONTAR
Esta atividade introduz variáveis, que são utilizadas em programas de
PBASIC para armazenar valores. Os programas Boe-Bot mencionados
posteriormente neste livro dependem fortemente de variáveis. A coisa mais
importante sobre a capacidade de armazenar valores é que o programa pode
usá-los para contar. Assim que o seu programa puder contar os valores, ele
pode tanto controlar como manter o controle do número de vezes que algo
acontece.
Seus servos não precisam ser ligados à energia para essa atividade.

Se você tem um Board of Education, coloque a chave na posição-3
para a posição-1. O BASIC Stamp, Vdd, Vin, e Vss serão todos
ligados a energia, mas não haverá nenhuma energia ligada às portas do
servo.
 Se você tem um BASIC Stamp HomeWork Board, ligar a bateria de 9V
para o clipe de bateria para ligar o BASIC Stamp, Vdd, Vin, e Vss.
Basta retirar uma bateria do pacote de bateria para manter a energia dos
servos desligada.
Usando Variáveis para Armazenar Valores, Operações Matemáticas, e
Contagem
As variáveis podem ser utilizadas para armazenar valores. Antes que você
possa usar uma variável em PBASIC, você tem que dar-lhe um nome e
especificar seu tamanho. Isso é chamado de "declarar" uma variável.
variableName VAR Size
Você pode declarar quatro tamanhos diferentes de variáveis em PBASIC:
Tamanho – Armazena
Bit
–
0à1
Nib
–
0 à 15
Byte
–
0 à 255
Word –
0 à 65535, ou -32768 à +32767
O programa de exemplo seguinte envolve apenas um par de palavras
variáveis :
value
anotherValue
VAR
VAR
Word
Word
Depois de ter declarado uma variável, você também pode inicializar, o que
significa dar-lhe uma partida, ou valor inicial.
value = 500
anotherValue = 2000
Valor padrão - Se você não inicializar uma variável, o programa irá iniciar
automaticamente, armazenando o número zero nessa variável. Isso é chamado
de variável "valor padrão".
O “=” sinal no value = 500 é um exemplo de um operador. Você pode usar
outros operadores para fazer cálculos com variáveis. Aqui estão alguns
exemplos de multiplicação:
value = 10 * value
anotherValue = 2 * value
Programa de Exemplo: VariablesAndSimpleMath.bs2
Este programa demonstra como declarar, inicializar e executar operações
sobre variáveis.
 Antes de executar o programa, prever o que cada comando DEBUG irá
exibir.
 Coloque, salve e execute o programa VariablesAndSimpleMath.bs2.
 Compare os resultados de suas previsões e explique as diferenças.
' Robótica com o Boe-Bot – VariablesAndSimpleMath.bs2
' Declara variáveis e as usa para resolver alguns problemas de aritmética.
' {$STAMP BS2}
' {$PBASIC 2.5}
value
VAR
Word
anotherValue VAR
Word
' Declarar variáveis
value = 500
anotherValue = 2000
' Inicializa variáveis
DEBUG ? value
DEBUG ? anotherValue
' Mostra valores
value = 10 * anotherValue
' Executa operações
DEBUG ? value
' Mostra valores novamente
END
Como Funciona VariablesAndSimpleMath.bs2
Esse código declara duas palavras variáveis, value e anotherValue.
value
VAR
Word
' Declarar variáveis
anotherValue
VAR
Word
Esses comandos são exemplos de inicialização de variáveis para valores que
você determinar. Após esses dois comandos serem executados, o valor
armazenado será 500, e o outro valor armazenado será 2000.
value = 500
anotherValue = 2000
' Inicializar variáveis
Estes comandos de DEBUG ajudarão você a ver o que cada variável armazena
depois de inicializá-los. Como o valor atribuído foi 500 e outro valor foi
atribuído 2000, esses comandos de depuração enviaram a mensagem "valor
= 500" e " valor = 2000" para o DEBUG Terminal.
DEBUG ? value
'Mostrar valores
O comando de DEBUG "?" O formatador pode ser utilizado antes de uma
variável para fazer com que o DEBUG Terminal exiba seu nome, o valor
decimal é armazenado, e a conduta retorna. É muito útil para verificar os
conteúdos de uma variável.
O enigma nas próximas três linhas é "O que vai ser exibido" A resposta é o
valor será definido igual a dez vezes o outro valor. Se o outro valor for 2000,
o valor será definido igual a 20.000. A variável outro valor é inalterada.
'Executar operações
DEBUG ? value
novamente
'Mostrar valores
Sua Vez - Cálculos com Números Negativos
Se você quer fazer cálculos que envolvem números negativos, você pode
usar o formatador SDEC do comando DEBUG para exibi-los. Aqui está um
exemplo do que pode ser feito modificando VariablesAndSimpleMath.bs2.
 Delete a porção do VariablesAndSimpleMath.bs2:
'Executar operações
DEBUG ? value
novamente
'Mostrar valores
 Substitua pelo seguinte:
value = value - anotherValue
'Resposta = -1500
DEBUG "value = ", SDEC value, CR 'Mostrar valores
novamente

Execute o programa modificado e verifique as mudanças de valor
500 para -1.500.
Contando e Controlando Repetições
A maneira mais conveniente para controlar o número de vezes que uma
peça de código é executada é FOR ... NEXT. Aqui está a sintaxe:
FOR Counter = StartValue TO EndValue {STEP StepValue}…NEXT
Os três pontos “...” indicam que você pode colocar um ou mais comandos
juntos na declaração For e Next. Certifique-se de declarar a variável para ser
usada no contra- argumento. Os argumentos StartValue e EndValue podem
ser números ou variáveis( ou também uma expressão) se você ver alguma
coisa entre chaves, uma síntese de descrição, isso significa uma opção de
argumento. Em outras palavras, o FOR...NEXT loop irá trabalhar sem isso,
mas você pode usar um propósito especial
Você não tem que nomear a variável "counter". Por exemplo, você pode
chamá-lo de "myCounter".
myCounter
VAR
Word
Aqui está um exemplo de FOR...NEXT Next loop que é usado na variável
myCounter para contagem, Isso também exibirá o valor da variável
myCounter de cada vez através do loop.
FOR myCounter = 1 TO 10
DEBUG ? myCounter
PAUSE 500
NEXT
Programa de Exemplo: CountToTen.bs2
 Coloque,
salve
e
execute
o
programa
CountToTen.bs2.
' Robótica com o Boe-Bot - CountToTen.bs2
' Usa a variável em um loop FOR ... NEXT.
' {$STAMP BS2}
' {$PBASIC 2.5}
myCounter
VAR
Word
DEBUG ? myCounter
PAUSE 500
NEXT
DEBUG CR, "Pronto!"
END
Sua Vez - Diferentes Inícios e Fins para Valores e Contagem em Passos
Você pode usar valores diferentes para o argumento StartValue e para o.
argumento EndValue.
 Modifique o loop FOR…NEXT que ficará então parecido com:
DEBUG ? myCounter
PAUSE 500
NEXT
 Execute o programa modificado. Você notou que o BASIC Stamp é
contado para baixo em vez de para cima? Ele vai fazer isso sempre
que o argumento StartValue for maior do que o argumento
EndValue.
do argumento opcional {STEP StepValue} PASSO
StepValue. Você pode usá-lo para fazer contagem myCounter em etapas.
Lembre-se
Em vez de 9, 10, 11 ..., você pode fazer a contagem de dois em dois números
(9, 11, 13 ...) ou de cinco em cinco (10, 15, 20 ...), ou o que StepValue
daria, para a frente ou para trás. Aqui está um exemplo que usa a contagem
regressiva em passos de 3:

Adicionar STEP 3 loop FOR ... NEXT que deverá ficar como este:
FOR myCounter = 21 TO 9 STEP 3
DEBUG ? myCounter
PAUSE 500
NEXT
 Execute o programa modificado e verificar se ele faz a contagem
para trás em passos de 3.
ATIVIDADE #6: TESTANDO OS SERVOS
Há uma última coisa a fazer antes de montar seu Boe-Bot: testar os servos.
Nesta atividade, você irá executar programas que fazem os servos girar em
diferentes velocidades e direções. Ao fazer isso, você vai verificar que os
seus servos estão funcionando corretamente antes de você montar o seu BoeBot. Este é um exemplo de testes de subsistema. Realizar testes de
subsistema é um hábito que vale a pena desenvolver, porque não é
divertimento abrir o robô parte à parte apenas para corrigir um problema que
poderia ter sido resolvido antes de juntar as partes!
Testes de subsistema é a prática de testar os componentes individuais antes de
ir para o dispositivo maior. É uma estratégia valiosa que pode ajudar você a
ganhar competições de robótica. É também uma habilidade essencial usada por
engenheiros em todo o mundo para desenvolver tudo, desde brinquedos, carros
e jogos de vídeo para naves espaciais e robôs Roving Mars. Especialmente em
dispositivos mais complexos, pode se tornar quase impossível descobrir um
problema se os componentes individuais não forem testados previamente. Em
projetos aeroespaciais, por exemplo, desmontar um protótipo para corrigir um
problema pode custar centenas de milhares, ou mesmo milhões de dólares.
Nesse tipo de projeto, testes de subsistema são rigorosos e completos.
Largura de Pulso Controla a Velocidade e Direção
Lembre-se de centralizar os servos, um sinal com uma largura de pulso de
1,5 ms causaram uma parada dos servos. Isso foi feito através de um
comando PULSOUT com uma duração de 750. O que aconteceria se a
largura do sinal de pulso não fosse de 1,5 ms?
Na seção Sua Vez de Atividade #2, você programou o BASIC Stamp para
enviar série de pulsos de 1,3 ms a um LED. Vamos dar uma olhada na série
de pulsos e descobrir como ele pode ser usado para controlar um servo.
Figura 2-25 mostra como um servo de rotação contínua Parallax transforma
toda velocidade no sentido horário quando você a envia pulsos 1,3 ms.
Completas gamas de velocidade de 50-60 RPM.
1.3 ms
1.3 ms
Vdd (5 V)
standard servo
www.parallax.com
Vss (0 V)
20 ms
Figura 2-25
A 1,3 ms trem
de pulso
Desliga a
velocidade
Servo
totalmente no
sentido horário
O que é RPM? Rotações por minuto. É o número de voltas completas que
algo dá em um minuto.
O que é um trem de pulsos? Assim como um trem é uma série de carros, um
"trem de impulsos" é uma série de impulsos.
ServoP13Clockwise.bs2 envia este trem de pulsos para o servo ligado ao
P13.
 Coloque, salve e execute o programa ServoP13Clockwise.bs2.
 Verifique se o ponta do servo está girando entre 50 e 60 RPM no
sentido horário.
' Robótica com o Boe-Bot - ServoP13Clockwise.bs2
' Gira o servo ligado a P13 na velocidade máxima no sentido horário.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 13, 650
PAUSE 20
LOOP
Note-se que um impulso de 1,3 ms requer um argumento PULSOUT Duração
de comando 650, que é inferior a 750. Todas as larguras de impulso inferior
a 1,5 ms, e os argumentos Duração PULSOUT portanto inferior a 750, farão
com que o servo pare de girar no sentido horário.
Programa de Exemplo: ServoP12Clockwise.bs2
Ao alterar o argumento do comando PULSOUT do Pin 13-12, você pode
fazer o servo ligado a velocidade P12 voltar a completar no sentido horário.


Salve ServoP13Clockwise.bs2 como ServoP12Clockwise.bs2
Modificar o programa, atualizando os comentários e argumentos do
comando de Pin PULSOUT a 12.
 Executar o programa e verificar se o servo ligado a P12 agora está
girando entre 50 e 60 RPM no sentido horário.
' Robótica com o Boe-Bot - ServoP12Clockwise.bs2
' Gira o servo ligado a P12 na velocidade máxima no sentido horário.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 12, 650
PAUSE 20
LOOP
Programa de Exemplo: ServoP12Counterclockwise.bs2
Você provavelmente já adivinhou que fazer o argumento do comando
PULSOUT de duração superior a 750 faz com que o servo pare de girar para a
esquerda. Uma duração de 850 vai enviar 1,7 ms pulsos. Isso fará a
velocidade do servo completa a esquerda como mostrado na Figura 2-26.
1.7 ms
1.7 ms
Vdd (5 V)
standard servo
www.parallax.com
Vss (0 V)
20 ms
Figura 2-26
A 1,7 ms trem de
pulso torna a
velocidade de
Turno Completo
Servo antihorário
 Salve ServoP12Clockwise.bs2 como ServoP12Counterclockwise.bs2
 Modificar o programa, alterando o argumento do comando PULSOUT
de Duração 650-850.
 Executar o programa e verificar se o servo ligado a P12 agora está
girando entre 50 e 60 RPM sentido anti-horário.
' Robótica com o Boe-Bot - ServoP12Counterclockwise.bs2
' Gira o servo ligado a P12 na velocidade máxima no sentido anti-horário.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG " Programa funcionando!"
DO
PULSOUT 12, 850
PAUSE 20
LOOP
Modulação Largura de pulso. A voltagem que passa uma certa quantidade
de tempo, em dois estados diferentes pode ser considerada como uma série de
estados de repouso e pulsos. Aqui está uma lista de sinais de pulso diferentes
que controlam a velocidade de servo e direção:
•
Figura 2- 22 na página 67: 1,5 ms alta faz com que o servo fique
parado.
•
Figura 2 -25 na página 80: 1,3 ms elevado vira o servo no sentido
horário.
Figura 2 -26 na página 82: 1,7 ms alta faz com que rode o servo no
sentido horário.
Estes sinais gastam quantidades de tempo breves de níveis elevados (impulsos)
que são separados por sinais de baixas (estados de repouso). Um programa
pode ajustar a duração de pulso, que é a quantidade de tempo em que o sinal é
alto. Esta duração é vulgarmente chamada de "largura de pulso", porque a
quantidade de tempo que o sinal é elevado parece mais larga ou mais estreita
em um diagrama de temporização ou de um dispositivo semelhante a um
osciloscópio que traça a voltagem contra o tempo.
A modulação é o processo de ajuste da propriedade de um sinal que está sendo
transmitido para fazê-lo transmitir determinadas informações. Com um servo,
a propriedade que é modulada é a largura de pulso, a quantidade de tempo que
o sinal é alto. A informação transmitida é a velocidade e direção do servo.
Os sinais de controle do servo são exemplos de pulsos positivos, com baixos
estados de repouso e altos estados ativos. Pulsos negativos seriam a versão
invertida com altos estados de repouso e baixos estados ativos
Sua Vez - P13Clockwise.bs2
 Modificar o argumento do comando PULSOUT de Pin, de modo que
o servo ligado ao P13 vire a esquerda.
Programa de Exemplo: ServosP13CcwP12Cw.bs2
Você pode usar dois comandos PULSOUT para fazer ambos os servos
girarem ao mesmo tempo. Você também pode fazê-los girar em direções
opostas.
 Coloque, salve e execute o programa ServosP13CcwP12Cw.bs.
 Verificar se o servo ligado a P13 está girando a toda velocidade para
a esquerda, enquanto o ligado a P12 está girando a toda velocidade
no sentido horário.
' Robótica com o Boe-Bot - ServosP13CcwP12Cw.bs2
' Gira o servo ligado a P13 na velocidade máxima no sentido anti-horário
' e o servo ligado a P12 na velocidade máxima no sentido horário.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
LOOP
Isto será importante em breve. Pense nisso: quando os servos são montados
em cada lado do chassi, um vai ter que girar no sentido horário, enquanto o
outro gira para a esquerda para fazer o rolo de Boe-Bot em uma linha reta.
Isso parece estranho? Se você não pode imaginá-lo, tente o seguinte:
 Mantenha seus servos juntos back-to-back e execute o programa
novamente.
Sua Vez - Ajustar a Velocidade e Direção
Há quatro combinações diferentes de argumentos Duração PULSOUT que
serão usadas repetidamente ao programar seu movimento Boe-Bot nos
próximos capítulos. ServosP13CcwP12Cw.bs2 enviam uma dessas
combinações, de 850 a 650 para P13 e P12. Ao testar várias combinações
possíveis e preencher a coluna Descrição da Tabela 2 1, você irá se
familiarizar com eles e construir uma referência para si mesmo. Você vai
preencher a coluna Comportamento após o Boe-Bot estar totalmente
montado, quando você poderá ver como cada combinação o faz mover.

Tente as seguintes combinações PULSOUT, e preencha a coluna
Descrição com seus resultados
Tabela 2-1: Combinações Duração PULSOUT
Duração
P13
P12
Descrição
850
650
650
850
850
850
650
650
750
850
650
750
750
750
760
740
770
730
850
700
800
650
Velocidade máxima, P13 servo antihorário, servo P12 no sentido horário.
Ambos os servos devem
permanecer ainda por causa
dos ajustes feitos na
centralização Atividade # 4
Comportamento
FOR…NEXT para controlar o tempo de execução do Servo
Esperamos que, agora você compreenda plenamente que a largura de pulso
controla a velocidade e direção de um servo de rotação contínua Parallax. É
uma maneira muito simples de controlar a velocidade do motor e direção.
Há também uma maneira simples de controlar a quantidade de tempo que
um motor funciona, com um loop FOR...NEXT.
Aqui está um exemplo de um FOR ... NEXT loop que fará com que o servo
volte por alguns segundos:
FOR counter = 1 TO 100
PULSOUT 13, 850
PAUSE 20
NEXT
Vamos estabelecer a quantidade exata de tempo que este código faria com
que o servo ligasse. Cada vez através do loop, que o comando PULSOUT dura
1,7 ms, o comando PAUSE tem a duração de 20 ms, e leva em torno de 1,3
ms para o loop executar.
Uma vez através do loop = 1,7 ms + 20 ms + 1,3 ms = 23,0 ms.
Uma vez que o loop é executado 100 vezes, que é 23,0 ms vezes 100.
time = 100 × 23.0 ms
= 100 × 0.0230 s
= 2.30 s
Vamos dizer que você quer que o servo de funcione 4,6 segundos. Seu loop
FOR ... NEXT terá que executar o dobro de vezes:
PULSOUT 13, 850
PAUSE 20
NEXT
Programa de Exemplo: ControlServoRunTimes.bs2
 Coloque, salve e execute o programa ControlServoRunTimes.bs2
 Verificar se o servo P13 voltas para a esquerda cerca de 2,3
segundos, seguido pelo servo-P12 de viragem para o dobro do
tempo.
' Robótica com o Boe-Bot - ControlServoRunTimes.bs2
' Gira o servo P13 a velocidade máxima no sentido anti-horário por 2.3 s.
' Em seguida, gira o servo P12 o dobro do tempo.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter VAR Byte
PULSOUT 13, 850
PAUSE 20
NEXT
PULSOUT 12, 850
PAUSE 20
NEXT
END
Vamos dizer que você quer executar os dois servos, o servo P13 em uma
largura de pulso de 850 e o servo P12 em uma largura de pulso de 650.
Agora, cada interação do loop, vai demorar:
1.7ms –
1.3 ms –
20 ms –
1.6 ms –
--------24.6 ms
Servo conectado à P13
Servo conectado à P12
Duração da pausa
Code overhead
-----------------------------–
Total
Se você deseja executar os servos por um determinado período de tempo,
você pode calcular assim:
Número de pulsos = Tempo s / 0,0246 s Tempo = / 0,0246
Vamos dizer que queremos executar os servos por 3 segundos. Isso é:
Número de pulsos = 3 / 0,0246 = 122
Agora, você pode usar o valor 122 no EndValue do FOR ... NEXT loop, e
ele vai ficar assim:
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
Programa de Exemplo: BothServosThreeSeconds.bs2
Aqui está um exemplo para fazer os servos correrem em uma direção por
três segundos e, em seguida, mudar sua direção.
 Coloque, salve e execute o programa BothServosThreeSeconds.bs2.
' Robótica com o Boe-Bot - BothServosThreeSeconds.bs2
' Gira os dois servos em direções opostas por três segundos, então inverte
' a direção de ambos e gira por mais três segundos.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter VAR Byte
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
END
 Verifique se cada servo virou em uma direção por três segundos, e
então mudou de direção e voltou para mais três segundos. Você
notou que, enquanto os servos viraram em direção oposta ao mesmo
momento, eles estavam sempre girando em sentidos opostos? Por
que isso seria útil?
Sua Vez - Prever Tempo de Execução do Servo






Escolha o tempo (seis segundos ou menos) que você deseja que
seus servos virem.
Divida o número de segundos por 0,024.
A sua resposta é o número de voltas que você vai precisar.
Modificar BothServosThreeSeconds.bs2 faz com que ambos servos
corram para a quantidade de tempo que você selecionou.
Compare o seu tempo de execução previsto para o tempo de
execução real.
Lembre-se de desligar a alimentação de seu sistema (placa e servos)
quando você tiver terminado.
Para medir o tempo de execução, pressione e segure o botão Reset no seu
Board of Education (HomeWork Board ou BASIC Stamp). Quando você
estiver pronto para iniciar a contagem, desligue o botão Reset.
SUMÁRIO
Este capítulo o guiou através do aprendizado de como ligar, ajustar e testar
os servos de rotação contínua Parallax. Ao longo do caminho, uma
variedade de comandos PBASIC foi introduzida. O comando PAUSE faz a
parada do programa por períodos de tempo breves ou longos, dependendo do
argumento Duração que você usar. DO ... LOOP faz repetir um único ou
um grupo de comandos PBASIC repetidamente. HIGH e LOW foram
introduzidos como uma maneira de fazer o BASIC Stamp conectar um pino
de I / O para Vdd ou Vss. Sinais de alta e baixa foram visualizados com a
ajuda de um circuito de LED. Estes sinais foram utilizados para introduzir os
diagramas de temporização.
O comando PULSOUT foi introduzido como uma forma mais precisa de
entregar um sinal alto ou baixo, e um circuito de LED também foi utilizado
para visualizar os sinais enviados pelo comando PULSOUT. DO ... LOOP,
PULSOUT, e PAUSE foram então usados para enviar aos servos de rotação
contínua Parallax o sinal de parada, que é de 1,5 ms pulsos a cada 20 ms. O
servo foi ajustado com uma chave de fenda ao receber os pulsos 1,5 ms até
que ele ficou parado. Este processo é chamado de "centralização" do servo.
Após os servos estarem centrados, as variáveis foram introduzidas como um
meio de armazenamento de valores. As variáveis podem ser utilizadas em
operações matemáticas e contagem. FOR ... NEXT loops foram
introduzidos como uma maneira de contagem. FOR ... NEXT loops
controlam o número de vezes que as linhas de código entre as declarações
FOR e NEXT são executados. FOR ... NEXT loop foram então utilizados
para controlar o número de pulsos entregues a um servo, o qual, por sua vez
controla a quantidade de tempo que o servo é executado.
Questões
1. Como os servos de rotação contínua Parallax diferem dos servos
standard?
2. Quanto tempo dura um milissegundo? Como você pode abreviá-lo?
3. Que comandos PBASIC você pode usar para fazer outros comandos
PBASIC executar uma e outra vez?
4. O comando faz com que o BASIC Stamp internamente conecte um
de seus pinos I / O para Vdd? O comando faz o mesmo tipo de
conexão, para Vss?
5. Quais são os nomes das variáveis de tamanhos diferentes que podem
ser declarados em um programa PBASIC? Que tamanho de valor
pode cada tamanho de variável armazenar?
6. Qual é a chave para controlar a velocidade de um servo de rotação
contínua Parallax e sua direção? Como isso se relaciona com
diagramas de tempo? Como se relaciona aos comandos PBASIC?
Qual comando e argumento você pode ajustar para controlar a
velocidade de um servo de rotação contínua e direção?
Exercícios
1. Escreva um comando de PAUSE que aciona o BASIC Stamp a não
fazer nada por 10 segundos.
2. Modificar o loop FOR ... NEXT para que ele avance de 6-24 em 3
passos. Além disso, escreva a variável que você usará para fazer este
programa funcionar.
DEBUG ? counter
PAUSE 500
NEXT
Projeto
1. Escreva um programa que faz com que um LED esteja conectado a
P14 à luz ofuscante (on/off a cada pulso), enquanto o servo P12 está
girando.
2. Escrever um programa que usa os servos através de três segundos de
cada uma das quatro combinações diferentes de rotação. Dica: você
vai precisar de quatro diferentes FOR ... NEXT loops. Primeiro, os
dois servos devem girar para a esquerda, em seguida, ambos devem
girar no sentido horário. Em seguida, o servo P12 deve girar no
sentido horário e o servo P13 no sentido anti-horário e, finalmente, o
servo P12 deve girar para a esquerda enquanto que o servo-P13 gira
no sentido horário.
Soluções
Q1.Em vez de manter uma determinada posição como os servos padrões,
os servos de rotação contínua Parallax firam em uma determinada
direção a uma determinada velocidade.
Q2.Um milissegundo dura de um milésimo de segundo, e "ms" é a
abreviatura.
Q3.O comando DO ...LOOP é usado para fazer outros comandos
PBASIC executarem repetidamente.
Q4.HIGH liga o pino I / O para Vdd, LOW liga o pino I / O para VSS.
Q5.Os tamanhos variáveis são bit, nib, byte e word.
Bit – Armazena 0 a 1
Nib – Armazena 0 a 15
Byte – Armazena 0 a 255
Word – Armazena 0 a 65535 ou -32768 a +32767
Q6.A largura do pulso controla a velocidade e direção do servo. Como
visto em um diagrama de tempo, a largura de pulso é a elevação do
tempo. Em PBASIC, o pulso pode ser gerado com o comando
PULSOUT. A duração do argumento do comando PULSOUT ajusta a
velocidade e direção.
E1. PAUSE 10000
E2. A chave para escrever a declaração da variável é escolher um
tamanho variável grande o suficiente para manter o valor de 24. O
Nib não vai funcionar, já que o valor máximo que um Nib pode
armazenar é 15. Portanto, escolha um byte variável.
counter VAR Byte
FOR counter = 6 TO 24 STEP 3
DEBUG ? counter
PAUSE 500
NEXT
P1. A chave para resolver este problema consiste em enviar um trem de
impulsos para o diodo emissor de luz, bem como do servo.
' Robótica com o Boe-Bot - Ch02Prj01_DimlyLitLED.bs2
' Gira o servo e enviar o mesmo sinal para iluminar fracamente o LED
' P14.
'{$STAMP BS2}
'{$PBASIC 2.5}
DO
PULSOUT 12, 650
PULSOUT 14, 650
PAUSE 20
LOOP
' P12 servo gira no sentido horário
' P14 LED pisca é iluminado
P2. Primeiro, calcule o número de voltas necessárias para fazer os servos
correrem durante três segundos, para cada combinação de rotação.
Como dado na página 88, a sobrecarga de código é de 1,6 ms.
Quatro combinações (1,2,3,4). Cada combinação: Determinar
argumentos Duração PULSOUT:
1. Ambos horários: 12, 850 e 13, 850
2. Tanto no sentido horário: 12, 650 e 13, 650
3. CW 12 e 13 CCW: 12, 850 e 13, 650
4. 12 CCW e CW 13: 12, 650 e 13, 850
Cada combinação: Calcule quanto tempo um loop vai demorar:
1. Um loop = 1,7 + 1,7 + 20 ms + 1,6 = 25,0 ms = 0,025 s
2. Um circuito = 1,3 + 1,3 + 1,6 + 20 ms = 24,2 ms = 0,0242 s
3. Um loop = 1,7 + 1,3 + 20 ms + 1,6 = 24,6 ms = 0,0246 s
4. Um loop = 1,3 + 1,7 + 20 ms + 1,6 = 24,6 ms = 0,0246 s
Cada combinação: Calcule o número de pulsos necessários para 3 s
de execução:
1.Número de impulsos de 3 s / 0,025 s = 120
2. Número de pulsos = 3 s / s = 0,0242 123,9 = 124
Agora escreva quatro loops FOR ... Next, usando o número de
pulsos calculados para o argumento EndValue. Incluir os argumentos
PULSOUT corretos para a combinação de rotação.
' Robótica com o Boe-Bot - Ch02Prj02_4RotationCombinations.bs2
' Faz servos girarem 4 vezes em uma combinação horário/anti-horário.
'{$STAMP BS2}
'{$PBASIC 2.5}
counter
VAR
Word
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
' Loop por três segundos
' P13 servo anti-horário
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
' P13 servo sentido horário
PULSOUT 13, 650
PULSOUT 12, 850
' P12 servo sentido anti-horário
PAUSE 20
NEXT
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
END
' P12 servo horário
Montagem e Teste do seu Boe-Bot · Página 97
Capítulo 3: Montagem e Teste do seu Boe-Bot
Este capítulo contém instruções para construir e testar seu Boe-Bot. É
especialmente importante concluir a parte de testes antes de passar para o
próximo capítulo. Ao fazer isso, você pode ajudar a evitar uma série de erros
comuns que levam a mistificar comportamento Boe-Bot em capítulos
posteriores. Aqui está um resumo do que você vai fazer em cada uma das
atividades deste capítulo:
Atividade Resumo
1
2
3
4
Montando o Boe-Bot.
Testar novamente os servos para se certificar de que eles estão
conectados corretamente.
Ligar e testar um alto-falante que o avisará quando as baterias do BoeBot estiverem baixas.
Usar o Terminal de depuração para controlar e testar a velocidade de
servo.
ATIVIDADE #1: MONTANDO O ROBÔ BOE-BOT
Esta atividade irá guiá-lo através da montagem do Boe-Bot, passo-a-passo.
Em cada etapa, você irá reunir algumas das peças, e depois montá-las de
modo que elas coincidam com as imagens. Todas as imagens são
acompanhadas de instruções, certifique-se de segui-las cuidadosamente.
Ferramentas e Peças do Servo
Todas as ferramentas mostradas na Figura 3-1 são comuns e podem ser
encontradas na maioria dos lares e lojas escolares. Elas também podem ser
compradas em lojas de ferramentas locais.
Ferramentas
(1) Chave de fenda Parallax
(Phillips # 1 ponto,
incluído)
(1) 1/4 "Chave combinada
(opcional, mas útil)
(1) Alicate de
bico
(opcional)
Figura 3-1
Ferramentas
de
montagem
Boe-Bot
Montagem da Parte Superior do Hardware


Comece reunindo a lista de peças a seguir.
Em seguida, siga as instruções abaixo.
Lista de Peças:
Veja a figura 3-2.
(1) chassi Boe-Bot
(4) 1 "impasses
(4) parafusos de cabeça
redonda, 1/4 "4-40
(1) em borracha, 13/32
"Instruções:
Instruções:
 Introduza o "anel isolante 13/32 de
borracha para dentro do buraco no
centro do chassi de Boe-Bot.
 Certifique-se de que a ranhura na
aresta exterior do anel de borracha
está encaixada na borda do furo no
chassi.
 Use os quatro parafusos "1/4 4-40
para prender os quatro suportes para
o chassi, como mostrado.
Boe-Bot Peças - As peças para o Boe-Bot ou estão incluídas no kit completo
Boe-Bot ou em uma combinação do kit completo do Board of Education e
partes do kit de Robótica. Se você estiver usando uma HomeWork Board, você
precisa de uma bateria com cabos de estanho em vez de um plugue barril, e
dois cabeçalhos de 3 pinos adicionais. Veja o Apêndice A: Lista de peças e
opções de Kit na página 365 para mais informações.
Figura 3- 2
Chassi e
parte de
cima do
Hardware
Peças
(esquerda);
montadas
(à direita)
Removendo os Chifres do Servo
 Desligue a energia do seu BASIC Stamp e dos servos
 Remova todas as pilhas AA da bateria.
 Desligue os servos de sua placa.
Lista de peças:
Veja a Figura 3 -3.
(2) Servos de rotação
contínua, Parallax instruções
anteriormente centradas:
Phillips
Screw
Control
Horn
Instruções:
 Use uma chave de fenda Phillips para
remover os parafusos que seguram as
pontas de controle de servo nos eixos
de saída.
 Puxe cada um chifre para cima e para
fora do eixo de saída do servo.
 Guarde os parafusos, pois eles serão
usados num passo posterior.
Figura 3-3
Chassi e parte de
cima do Hardware
Output
Shaft
Peças (esquerda);
montadas (à
direita)
Pare!

Antes deste passo seguinte, você deve ter concluído essas atividades do
Capítulo 2: Servo Motores Do Seu Boe-Bot.
• Atividade #3: Ligando os Servos Motores, página 55.
• Atividade #4: Centralização dos Servos, página 67.
Montagem dos Servos no Chassi
Servo, Opções de Montagem - Manobras ágeis x potenciômetros e acesso
de manutenção.
As fotografias neste texto mostram os servos montados a partir do interior, e
orientados de modo que o bujão de acesso do potenciômetro esteja voltado
para o centro do chassi. Isto posiciona os eixos perto do centro do Boe-Bot,
permitindo uma manobra ágil. Se você for diligente em centrar seus servos
antes de construir o seu Boe-Bot, isso não causará problemas.
Muitos instrutores preferem a possibilidade de montar os servos a partir do
exterior, orientando assim o bujão de acesso do potenciômetro para estar
voltado para a frente do Boe-Bot. Isto tem a vantagem de permitir um acesso
fácil para ajustar estes potenciômetros montados sobre um robô, e também
para a substituição rápida dos servos danificados. No entanto, o Boe-Bot terá
uma base de roda mais ampla e será um pouco menos ágil em manobras. Você
pode achar que você precisa ajustar um pouco alguns valores em seus
programas para alcançar os mesmos resultados. A escolha é sua.
Lista de peças:
Ver Figura 3- 4.
(2) Chassi Boe-Bot,
parcialmente montado.
(2) Servos de rotação contínua
da Parallax
(8) Parafusos de cabeça
redonda, 3/8 "4-40
(8) Porcas, 4-40
Instruções:
 Coloque os servos ao chassi com os

parafusos Phillips e porcas.
Use pedaços de fita adesiva para
rotular os servos esquerda (L) e
direito (R).
Figura 3-4
Montagem
dos Servos
no Chassi
Partes
(esquerda);
montados (à
direita)
Montagem da Bateria de Pacote
A figura 3-5 mostra dois conjuntos diferentes de peças. Utilize as peças do
lado esquerdo se você tem um Board of Education, e as peças do lado direito
se você tiver um HomeWork Board.
Lista de Peças para o Boe-Bot com
um Board of Education:
Ver a Figura 3 5 (do lado esquerdo).
um HomeWork Board:
Veja a Figura 3 5 (lado direito).
(1) Chassi do Boe-Bot (parcialmente
montado)
(2) parafusos Phillips cabeça chata,
3/8 "4-40
(2) Porcas, 4-40
(1) Bateria com plug de centropositivo
(1) Chassi do Boe-Bot (parcialmente
montado)
(2) parafusos Phillips cabeça chata,
3/8" 4-40
(2) Porcas, 4-40
(1) Bateria com terminais estanhados
Figura 3-5
Bateria e
Hardware
de
montagem
Instruções:
 Por meio dos parafusos de cabeça chata e porcas, prenda a bateria à




parte de baixo do chassi do Boe-Bot, como mostrado no lado
esquerdo da Figura 3 6.
Certifique-se de inserir os parafusos através da bateria e, em seguida,
aperte as porcas na parte de cima do chassi.
Como mostrado no lado direito da Figura 3-6, puxe o fio de
alimentação da bateria através do furo com o anel de borracha do
centro do chassi.
Puxe os fios do servo através do mesmo buraco.
Organize os fios do servo e os de alimentação, como mostrado.
Figura
3- 6
Bateria
instalada
Montagem das Rodas
Lista de peças:
(1) Boe-Bot parcialmente
montado (não mostrado)
(1) Cupilha 1/16”
(1) Roda de arrasto
(2) Pneus de tira de
borracha
(2) Rodas usinadas de
plástico
(2) Os parafusos que foram
removidos dos servos
Figura 3- 7
Roda do
Hardware
Instruções:
O lado esquerdo da Figura 3-8 mostra a roda de arrasto do Boe-Bot montada
no chassi. A roda de arrasto é uma bola de plástico com um furo
atravessando seu centro. A cupilha prende a roda no chassi e funciona como
um eixo para a mesma.
 Alinhe o orifício na roda de suporte com os furos na porção traseira
do chassi.
 Passe a cupilha através dos três furos (chassi esquerdo, roda de
arrasto, chassi direito).
 Curve as extremidades da cupilha para que ela não deslize para trás,
escapando do furo.
O lado direito da figura 3-8 mostra as rodas motrizes do Boe-Bot montadas
nos servos.
 Estique os pneus de tira de borracha e encaixe-os nas bordas externas
das rodas.
 As rodas de plásticos apresentam uma reentrância que se encaixa
sobre o eixo de saída do servo. Pressione as rodas de plástico no
eixos de saída dos servos certificando-se que as linhas de eixo
afundem no recesso.
Figura 3- 8
Montagem
das rodas
Roda de
arrasto (à
esquerda);
rodas
motrizes (à
direita)
Colocando a Placa no Chassi
Board of Education:
Lista de Peças para Boe-Bot com o
HomeWork Board:
Ver lado esquerdo da Figura 3 -9.
Ver lado direito da figura 3-9.
(1) chassi Boe-Bot (parcialmente
montado)
(4) parafusos cabeça de panela, 1/4"
4-40
(1) Board of Education com BASIC
Stamp 2
(1) chassi Boe-Bot (parcialmente
montado)
(4) parafusos cabeça de panela, 1/4"
4-40
(1) BASIC Stamp HomeWork Board
Figura 3 -9
Chassi do
Boe-Bot e
Placas
Board of
Education (à
esquerda);
HomeWork
Board (à
direita)
A figura 3-10 mostra como conectar o servo na Board of Education (lado
esquerdo) e na HomeWork Board (lado direito).


Volte a ligar os servos nos seus respectivos encaixes.
Certifique-se de conectar o plugue rotulado 'L' à porta P13 e o
plugue rotulado 'R' à porta P12
White
Red
Black
White
Red
Black
White
Stripe
(916) 624-8333
www.parallaxinc.com
15 14 Vdd 13 12
Vdd
Red
Black
X4
X5
Board of Education
Vin
SolidB
Rev
Black
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
 P13 - White
 Vbp - Red
 Vss - Black
 Vbp - Red
 P12 - White
Figura 310
Portas
Servo
conectadas
na Board
of
Education
e na
HomeWor
k Board
HomeWork Board
A Figura 3-11 mostra o chassi do Boe-Bot com as respectivas placas
colocadas.
 Coloque a placa sobre os pinos de elevação, de modo que os furos da
extremidade da placa e os pinos fiquem alinhados.
 Certifique-se que o breadboard está mais próximo das rodas motrizes
do que da roda de arrasto.
 Prenda a placa nos pinos utilizando os parafusos cabeça de panela.
Figura 3 -11
Placas
ligadas ao
chassi do
Boe-Bot
Na Board of Education
Na HomeWork Board
A figura 3-12 mostra robôs Boe-Bot já montados. À esquerda com uma
Board of Education (Serial Rev C) e à direita com uma HomeWork Board.
 Por baixo do chassi, puxe o excesso de fios dos servos e da bateria
através do furo com o anel de borracha.
 Coloque os fios em excesso entre os servos e o chassi.
Figura 3-12
Boe-Bot
montados
Board of Education
HomeWork Board
ATIVIDADE #2: TESTANDO NOVAMENTE OS SERVOS
Nesta atividade, você realizará um teste a fim de verificar se as conexões
elétricas entre a placa e os servos estão corretas. A figura 3-13 a frente, a
parte traseira, os lados esquerdo e direito do seu Boe-Bot. Precisamos nos
certificar que o servo da direita gira quando recebe pulsos de P12 e que o
servo da esquerda gira quando recebe pulsos de P13.
Esquerda
Traseira
Frente
Figura 3-13
Frente, traseira,
direita e esquerda
do seu Boe-Bot.
Direita
Testando a Roda Direita
O programa de exemplo a seguir testará o servo ligado à roda direita,
mostrado na Figura 3-14. Esse programa fará com que a roda gire no sentido
horário durante três segundos, pare por um segundo, e, por fim, gire no
sentido anti-horário por três segundos.
Clockwise 3 seconds
Stop 1 second
Counterclockwise 3 seconds
Figura 3-14
Testando a roda direita
Programa de Exemplo: RightServoTest.bs2
 Colocar o Boe-Bot sobre o seu nariz para que as rodas motrizes não







toquem o solo.
Insira as baterias.
Se você tem uma Board of Education, passe o interruptor da posição3 para a posição-2.
Se você tem uma HomeWork Board, ligar a bateria de 9 V ao clipe
da bateria.
Coloque, salve e execute o programa RightServoTest.bs2.
Verifique se a roda direita gira no sentido horário durante três
segundos, para por um segundo, e então gira no sentido anti-horário
por três segundos.
Se a roda direita ou servo não se comportarem como previsto,
consulte a seção “Solução de Problemas do Servo”.
Se a roda direita ou servo se comportarem adequadamente, passe
para a seção “Sua Vez”, onde você irá testar a roda esquerda.
' Robótica com o Boe-Bot - RightServoTest.bs2
' Servo Direito gira no sentido horário por três segundos, para um segundo,
' em seguida, gira no sentido horário de três segundos.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programa em andamento!"
counter
VAR
Word
PULSOUT 12, 650
PAUSE 20
NEXT
' No sentido horário, 3 segundos.
PULSOUT 12, 750
PAUSE 20
NEXT
' Para um segundo.
PULSOUT 12, 850
PAUSE 20
NEXT
' No sentido anti-horário, 3 segundos.
END
Sua Vez – Testando a Roda Esquerda
Agora é a vez de executar o mesmo teste na roda esquerda como mostrado
na Figura 3-15. Isto envolve a modificação do programa RightServoTest.bs2
de modo que os comandos PULSOUT sejam enviados para o servo ligado ao
P13 ao invés do servo ligado a P12.
Tudo que você tem a fazer é mudar os três comandos PULSOUT para que eles
leiam PULSOUT 13 ao invés de PULSOUT 12.
Clockwise 3 seconds
Stop 1 second
Counterclockwise 3 seconds
Figura 3-15
Testando a roda
esquerda
 Salve RightServoTest.bs2 como LeftServoTest.bs2.
 Mude os três comandos PULSOUT para que eles leiam PULSOUT 13 ao
invés de PULSOUT 12.
 Salve e execute o programa.
 Verifique se a roda esquerda gira no sentido horário durante três
segundos, pára por um segundo, e então gira no sentido anti-horário
por três segundos.
 Se a roda esquerda ou servo não se comportarem como previsto,
consulte a seção “Solução de Problemas do Servo”.
 Se a roda esquerda ou servo se comportarem adequadamente, seu
Boe-Bot está funcionando corretamente e você está pronto para
iniciar a próxima atividade.
Solução de Problemas do Servo: Aqui está uma lista de alguns problemas
comuns e como corrigi-los.
O servo não liga de maneira nenhuma.

Se você estiver usando um Board of Education, certifique-se se o
interruptor de 3 posições está na posição-2. Você pode, então, voltar a
executar o programa pressionando e soltando o botão Reset
 Se você estiver usando um BASIC Stamp HomeWork Board,
certifique-se de que a bateria tem pilhas novas, todas posicionadas
corretamente no caso.
 Double-check: Verifique novamente as conexões do servo usando
Figura 3-10 na página 107 como um guia. Se você estiver usando uma
HomeWorkBoard, você também pode querer dar uma segunda olhada
na Figura 2- 18 na página 65.
 Verificar e certificar-se de que você digitou o programa corretamente.
O servo direito não liga, mas o esquerdo liga.
Isto significa que os servos estão trocados. O servo que está ligado ao P12
deve ser conectado ao P13, e o servo que está ligado ao P13 deve ser
conectado ao P12
 Desligue a alimentação.





Desligue ambos os servos
Ligue o servo que foi conectado ao P12 a P13.
Ligue o outro servo (que foi conectado ao P13) para P12.
Reconecte a alimentação
Execute novamente RightServoTest.bs2.
A roda não para totalmente, ela roda vagarosamente.
Isto significa que o servo pode não estar exatamente centrado.
Há duas formas de corrigir isto:

Ajuste de hardware. Volte e refaça o Capítulo 2, Atividade # 4:
Centralização dos Servos na página 67. Se os servos não são
montados para dar fácil acesso as portas do potenciômetro, considere
reorientadas para a remontagem.
 Ajuste de software: Se a roda gira para a esquerda lentamente, use um
valor que é um pouco menor do que 750. Se ele está girando em
sentido horário use um valor que é um pouco maior do que 750. Este
novo valor será utilizado no lugar do 750 para todos os comandos
PULSOUT, para todas as rodas que você testou neste livro
A roda não para por um segundo entre as rotações no sentido horário e
anti-horário.
A roda pode girar rapidamente por três segundos em uma direção e quatro em
outra. Ela também pode girar rapidamente por três segundos, em seguida,
apenas um pouco mais lenta por um segundo, em seguida, girar de novo,
rapidamente, por três segundos. Ou pode girar rapidamente na mesma direção
por 7 segundos. De qualquer maneira, isso significa que o potenciômetro está
desajustado.

Retire as rodas, e repita o exercício de Atividade # 4: Centralização
dos Servos na página 67.
ATIVIDADE #3: CIRCUITO DO INDICATOR “START/RESET” E
SEU PROGRAMA
Quando a tensão fica abaixo do nível que um dispositivo necessita para
funcionar corretamente, isto é chamado de “brownout”. O BASIC Stamp se
protege da queda de energia fazendo seu processador e chips de memória do
programa ficarem dormentes até que a fonte de tensão retorne a níveis
normais. Uma queda abaixo de 5,2 V no Vin resulta em uma queda abaixo
de 4,3 V na saída do regulador de tensão interno do BASIC Stamp. Um
circuito chamado de detector de queda de energia, ou “brownout”, no
BASIC Stamp está sempre atento a essa condição. Quando ocorre queda de
energia, o detector de “brownout” desativa o processador do BASIC Stamp
e a memória do programa.
Quando a voltagem torna a ficar acima de 5,2 V, o BASIC Stamp começa a
funcionar novamente, mas não no mesmo lugar do programa. Ao invés, ele
começa a partir do início do programa. É o mesmo que acontece quando
você desliga e torna a ligar a energia, ou, também, quando você pressiona e
solta o botão Reset na sua placa.
Quando as baterias do Boe-Bot estão acabando, as quedas de energia podem
fazer o programa reiniciar quando você menos espera. Isso pode gerar
comportamentos incompreensíveis por parte do Boe-Bot. Pode ocorrer de o
Boe-Bot estar realizando um percurso já programado e, de repente, ele
parecer perdido e ir para alguma direção aleatória. Se a bateria baixa for a
causa, pode ser que o programa do Boe-Bot recomeçou. Em outros casos, o
Boe-Bot pode começar a se movimentar de maneira confusa, uma vez ao
começar a girar, os servos sobrecarregam as baterias que já estão fracas. O
programa tenta fazer com que os servos girem e, em uma fração de segundo,
eles são reiniciados e fazem isso repetidamente.
Essas situações mostram que um programa indicador de “start/reset” pode
ser um dispositivo de diagnóstico extremamente útil, bem como uma
ferramenta útil do robô. Uma forma de indicar o “reset” é incluir um sinal
inconfundível no início de todos os programas do Boe-Bot. O sinal ocorre
quando a energia está ligada a uma tomada, e também quando o programa é
reiniciado devido a ocorrência de um “brownout”. Um sinal eficaz para
essas situações pode ser um som emitido por um alto-falante toda vez que o
programa do BASIC Stamp é executado desde o início ou reiniciado.
Instruções Especiais para o BASIC Stamp HomeWork Board
Embora o indicador de reset irá te dizer quando a bateria de 9 V do BASIC
Stamp está acabando, ele não vai dizer quando o suprimento do servo (a
bateria) está acabando. Você sempre pode perceber quando a bateria está fraca,
pois os servos irão mover-se gradualmente cada vez mais lentos durante a
operação normal. Quando você observar este sintoma, substitua as pilhas
gastas com pilhas novas ou recém recarregadas.
Este exercício irá introduzir um dispositivo chamado de 'alto-falante
piezoelétrico' (“piezospeaker”) que você pode usar para gerar sons. Este
alto-falante emite tons diferentes dependendo da frequência de sinais de alta
/ baixa que recebe do BASIC Stamp. O símbolo esquemático e desenho da
peça para o alto-falante piezoeléctrico é mostrado na Figura 3-16. Este altofalante será usado para emitir sons quando o BASIC Stamp for reiniciado,
tanto nesta atividade, assim como no resto das atividades propostas por esse
livro.
Figura 3-16
Alto-falante piezoelétrico
(“piezospeaker”)
O que é "frequência?" É a medida de quantas vezes algo ocorre em um
determinado período de tempo.
O que é um "elemento piezoelétrico 'e como ele pode fazer um som? É um
cristal que muda de forma ligeiramente quando a tensão é aplicada ao mesmo.
Através da aplicação de tensões elevadas e grandes quantidades de um cristal
piezoeléctrico a uma taxa rápida, faz com que o cristal piezoeléctrico mude sua
forma rapidamente. O resultado é a vibração. Objetos vibrando fazem com que
o ar em torno deles vibre também. Isto é o que nosso ouvido detecta como sons
e tons. Cada taxa de vibração tem um tom diferente. Por exemplo, se você
arranca uma única corda de violão, ele vai vibrar a uma frequência, e você
ouvirá um tom particular. Se você arranca uma corda de violão diferente, ele
vai vibrar em uma frequência diferente e fazer um som diferente.
Elementos piezoelétricos têm muitos usos. Por exemplo, quando a força é
aplicada a um elemento piezoeléctrico, que pode criar tensão. Alguns
elementos piezoelétricos têm uma frequência em que eles naturalmente
vibram. Estes podem ser utilizados para criar tensões nas frequências que
funcionam como o oscilador de relógio para os vários computadores e
microcontroladores.
Peças Necessárias
(1) Boe-Bot montado e testado
(1) Alto-falante piezoelétrico
(Alguns) Fios
Se o seu “piezospeaker” tem uma etiqueta que diz "Remova a vedação
após a lavagem" apenas retire-a e prossiga. Seu “piezospeaker” não
necessita de ser lavado!
Construindo o Circuito Indicador de Start/Reset
A Figura 3-17 mostra a esquemática do circuito de alarme do
““piezospeaker”” tanto para o Board of Education como para o BASIC
Stamp HomeWork Board. A Figura 3-18 mostra um diagrama de fios para
cada uma das placas.
Sempre desconecte a alimentação antes de construir ou modificar
circuitos!

Se você tem um Board of Education, coloque o interruptor de 3
posições para a posição-0
 Se você tiver um Basic Stamp HomeWork Board, desconectar a
bateria de 9 V do clipe da bateria e remover a bateria do pacote de
bateria.
 Construa o circuito mostrado nas Figuras 3-17 e 3-18.
Os circuitos do “piezospeaker” e do servo permanecerão conectados ao
seu Board para o resto das atividades neste texto.
Todos os esquemas de circuitos, a partir deste ponto, vão mostrar
circuitos que devem ser adicionados ao servo existente e circuitos
“piezospeaker”.
Todos os diagramas de fiação irão mostrar o circuito do esquema antes e
junto com o servo e conexões do circuito “piezospeaker”.
P4
Figura 3-17
Programa do Circuito
Indicador de Start/Reset
Vss
To Servos
To Servos
15 14 Vdd 13 12
(916) 624-8333
Rev B
www.parallax.com
Red
Black
X4
Vdd
X5
Vin
Vdd
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Board of Education
Rev C
© 2000-2003
Vin
Vss
X3
X3
+
Figura 3-18
Diagramas de
fiação para o
Programa Start
/ Reset
Indicador de
Circuito
Board of
Education
(esquerda) e
HomeWork
Board (direita)
HomeWork Board
Programando o Indicador de Start/Reset
O programa de exemplo a seguir testará o “piezospeaker”. Esse programa
usa o comando FREQOUT para mandar sinais alto/baixo precisamente
cronometrados para o alto falante. A sintaxe do comando FREQOUT é:
FREQOUT Pin, Duration, Freq1 {,Freq2}
Segue um exemplo de um comando FREQOUT que será usado no programa
de exemplo.
FREQOUT 4, 2000, 3000
O argumento Pin é 4, o que significa que os sinais alto/baixo serão enviados
para o pino I/O P4. O argumento de duração, que é o tempo que os sinais de
alta/baixa vão durar, é de 2000, que é de 2000 ms ou 2 segundos. O
argumento Freq1 é a frequência dos sinais de alta / baixa. Neste exemplo, os
sinais de alta / baixa farão um tom 3000 hertz, ou 3 kHz.
A frequência pode ser medida em hertz (Hz). O hertz é uma medida de
quantas vezes por segundo, algo acontece. Um hertz é simplesmente uma vez
por segundo, e é abreviado 1 Hz. Um quilohertz é de mil vezes por segundo, e
é abreviado 1 kHz.
FREQOUT sintetiza digitalmente tons. O comando FREQOUT aplica pulsos
de alta / baixa de diferentes durações que fazem a vibração de um piezospeaker
se assemelhar a vibrações naturais de cordas de música.
Programa de Exemplo: StartResetIndicator.bs2
Este exemplo de programa emite um sinal sonoro ao ser iniciado e, em
seguida, executa um programa que envia mensagens DEBUG a cada meio
segundo. Essas mensagens continuarão indefinidamente, porque elas estão
localizadas entre os comandos DO e LOOP. Se a alimentação do BASIC
Stamp for interrompida enquanto ele está no meio do DO...LOOP, o
programa recomeçará do início. Ao ser reiniciado, ele emitirá um sinal
sonoro novamente. Você pode simular uma condição de queda de energia
pressionando e soltando o botão Reset na sua placa ou desconectando e
reconectando a alimentação da bateria da sua placa.
Aprenda a criar efeitos sonoros e música com o BASIC Stamp! Baixar o
livro “O que é um microcontrolador?” de www.parallax.com/go/WAM, e
tentar o exemplo de circuito e programas no Capítulo 8.
Para saber ainda mais sobre os sinais que o FREQOUT gera, baixar
Understanding Signals com o PropScope de www.parallax.com/go/PropScope
e ler o Capítulo 7.
 Reconecte a sua placa a energia.
 Coloque, salve e execute o programa StartResetIndicator.bs2.
 Verifique se o “piezospeaker” emitiu um som claro e audível por
dois segundos antes da mensagem "Aguardando Reset..." ser exibida
no DEBUG Terminal.
 Se você não ouviu um som, verifique se a fiação e os códigos
possuem erros. Repita até obter um som audível de seu alto-falante.
 Se você ouviu um som audível, tente simular a condição de queda de
energia pressionando e soltando o botão Reset na sua placa.
Verifique se o “piezospeaker” emite um som claro e audível após
cada reinicialização.
 Desconecte e reconecte sua fonte de bateria e verifique se isso gera
um som de aviso de reinicialização também.
' Robótica com o Boe-Bot - StartResetIndicator.bs2
' Teste do circuito do “piezospeaker”.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva
' PBASIC diretiva
DEBUG CLS, "Beep!!!"
FREQOUT 4, 2000, 3000
' Exibe enquanto alto falante emite som.
' Sinal de programa start/reset
DO
DEBUG CR, “Aguardando Reset...”
PAUSE 500
LOOP
'
'
'
'
DO...LOOP
Exibe mensagem
A cada 0.5 segundos
Até hardware ser resetado.
Como Funciona o Programa StartResetIndicator.bs2
O programa StartResetIndicator.bs2 inicia apresentando a mensagem
"Beep!" Então, imediatamente depois de exibir a mensagem, o comando
FREQOUT emite um som de 3 kHz no alto-falante piezoelétrico por 2 s.
Como as instruções são executadas rapidamente pelo BASIC Stamp, temos a
impressão de que a mensagem será exibida no mesmo instante que o
“piezospeaker” emite o som.
Após emitir o som, o programa entra em DO...LOOP, exibindo a mesma
mensagem "Aguardando Reset..." repetidamente. Toda vez que o botão de
reset no Board of Education é pressionado ou a alimentação é desconectada
e reconectada, o programa reinicia exibindo a mensagem "Beep!" e emitindo
o som de 3 kHz.
Sua Vez - Adicionando StartResetIndicator.bs2 em um Programa
Diferente
O comando FREQOUT no programa indicador de bateria será utilizado no
início de cada programa de exemplo daqui em diante. Você pode considerálo parte da "rotina de inicialização" para todos os programas do Boe-Bot.
Uma rotina de inicialização é composta de todos os comandos necessários
para obter um dispositivo ou programa instalado e funcionando. Muitas vezes,
inclui a criação de certos valores variáveis, ruídos sonoros, e para dispositivos
mais complexos, auto teste e calibração.
 Abrir o programa HelloOnceEverySecond.bs2
 Copie o comando FREQOUT do programa StartResetIndicator.bs2 no
programa HelloOnceEverySecond.bs2, acima da seção DO...LOOP.
 Execute o programa modificado e verifique se ele responde com um
som de aviso toda vez que o BASIC Stamp é reinicializado (seja
pressionando e soltando o botão Reset na placa ou desconectando e
reconectando a bateria).
ATIVIDADE #4: TESTANDO O CONTROLE DE VELOCIDADE
COM O DEBUG TERMINAL
Nesta atividade, você criará um gráfico de velocidade do servo pela largura
de pulso. O processo poderá ser muito mais rápido ao utilizar a janela de
transmissão do DEBUG Terminal, mostrada na Figura 3-19. Você pode usar
a janela de transmissão para enviar as mensagens BASIC Stamp. Enviando
mensagens que dizem ao BASIC Stamp qual a largura de pulso enviada ao
servo, você pode testar a velocidade do servo em várias larguras de pulso.
Transmitir
Windowpane
Receber
Windowpane
Figura 3-19
DEBUG
Terminal de
Transmissão
e Recepção
Windowpanes
Largura de pulso é uma forma comum de descrever quanto tempo um
pulso dura. O motivo pelo qual é chamado "largura" de pulso é porque a
quantidade de tempo que um pulso dura está relacionada com a largura
no diagrama de temporização. Pulsos que duram mais tempo são mais
largos em diagramas de tempo e pulsos que duram por curtos períodos de
tempo são estreitos.
Usando o Comando DEBUGIN
Você provavelmente já está familiarizado com o comando DEBUG e sabe
como ele pode ser usado para enviar mensagens a partir do BASIC Stamp
para o DEBUG Terminal. O lugar onde as mensagens são vistas é chamado
janela “Receive” porque é o lugar onde as mensagens recebidas do BASIC
Stamp são exibidas. O DEBUG Terminal também tem uma janela de
transmissão, o que permite que você envie informações para o BASIC
Stamp enquanto um programa está em execução. Você pode usar o comando
DEBUGIN para fazer o BASIC Stamp receber o que você digita na janela e
transmitir e armazená-lo em uma ou mais variáveis.
O comando DEBUGIN coloca o valor que você digitar na janela de
transmissão dentro de uma variável. No seguinte programa de exemplo, uma
variável denominada Pulsewidth será usada para armazenar os valores que
o comando DEBUGIN recebe.
pulseWidth
VAR
Word
Agora, o comando DEBUGIN pode ser usado para capturar um valor decimal
que você coloca na janela de transmissão do DEBUG Terminal e armazenálo em Pulsewidth:
DEBUGIN DEC pulseWidth
Você pode então programar o BASIC Stamp para usar esse valor. Aqui ele é
usado na argumentação Duração do comando PULSOUT:
PULSOUT 12, pulseWidth
Programa de Exemplo: TestServoSpeed.bs2
Este programa permite que você defina o argumento Duração do comando
PULSOUT incorporando a janela de transmissão do DEBUG Terminal.
 Continue esta atividade com o Boe-Bot virado, apoiado sobre seu
nariz para que as rodas não toquem o chão.
 Coloque, salve e execute o programa TestServoSpeed.bs2.
 Aponte para a janela de transmissão do DEBUG Terminal com o
mouse e clique nela para ativar o cursor nessa janela para digitação
 Digite 650 e, em seguida, pressione a tecla Enter.
 Verifique se o servo roda a toda a velocidade no sentido horário por
seis segundos.
Quando o servo estiver girando, você será solicitado a digitar outro valor.


Digite 850 e, em seguida, pressione a tecla Enter.
Verificar se o servo roda a toda no sentido horário por 6 segundos.
Tente medir a velocidade de rotação da roda em RPM (rotações por minuto)
para uma gama de larguras de pulso entre 650 e 850. Veja como:
 Coloque uma marca na roda para que você possa ver o quanto ela
gira em 6 segundos.
 Utilize o DEBUG Terminal para testar o quanto a roda gira para cada
uma destas larguras de pulso: 650, 660, 670, 680, 690, 700, 700, 710,
720, 730, 740, 750, 760, 770, 780, 790, 800, 810, 820, 830, 840, 850.
 Para cada largura de pulso, multiplique o número de voltas por 10
para obter o RPM. Por exemplo, se a roda realiza 3,65 voltas
completas, ela gira a 36,5 RPM.
 Explique com suas próprias palavras, como você pode usar a largura
de pulso para controlar a velocidade do servo de rotação contínua.
'
'
'
'
'
Robótica com o Boe-Bot - TestServoSpeed.bs2
Pede a largura de pulso e, em seguida, conta o número de revoluções da
roda.
A roda girará por 6 segundos.
Multiplique por 10 para obter as rotações por minuto (RPM).
'{$STAMP BS2}
'{$PBASIC 2.5}
Counter
VAR
pulseWidth
VAR
pulseWidthComp VAR
FREQOUT 4, 2000, 3000
Word
Word
Word
' Programa de sinal start/reset.
DO
DEBUG "Informe a largura de pulso: "
pulseWidthComp = 1500 - pulseWidth
PULSOUT 13, pulseWidthComp
PAUSE 20
NEXT
LOOP
Como Funciona o Programa TestServoSpeed.bs2
Três variáveis são declaradas, counter para o loop FOR...NEXT, pulsewidth
para os comandos DEBUGIN e PULSOUT e é o pulseWidthComp que
armazena um valor que é usado em um segundo no comando PULSOUT.
counter
pulseWidth
pulseWidthComp
VAR
VAR
VAR
Word
Word
Word
O comando FREQOUT é usado para sinalizar que o programa foi iniciado.
FREQOUT 4,2000,3000
O restante do programa é posicionado dentro de um DO...LOOP, então ele
irá executar repetidamente. O operador do DEBUG Terminal (que é você) é
solicitado a digitar uma largura de pulso. O comando DEBUGIN armazena
esse valor na variável pulseWidth.
DEBUG "Informe a largura de pulso: "
Para fazer uma medição mais precisa, dois comandos PULSOUT têm que ser
enviados. Ao fazer um comando PULSOUT usar a mesma quantidade inferior
a 750, e outra superior a 750, a soma dos dois argumentos Duração PULSOUT
será sempre 1500. Isso assegura que os dois comandos PULSOUT
combinados tenham a mesma quantidade de tempo. O resultado é que não
importa a duração do seu comando PULSOUT, o loop FOR...NEXT ainda vai
levar a mesma quantidade de tempo para ser executado. Isso fará com que as
medições de RPM que você vai tomar na seção Sua Vez sejam mais
precisas.
Este próximo comando leva a largura de pulso que você digitou, e calcula
uma largura de pulso que vai fazer 1500, quando os dois são somados. Se
você entrar com uma largura de pulso de 650, pulseWidthComp será 850.
Se você entrar com uma largura de pulso de 850, pulseWidthComp será
650. Se você entrar com uma largura de pulso de 700, pulseWidthComp
será 800. Tente alguns outros exemplos. Todos eles irão somar 1500.
pulseWidthComp = 1500 - pulseWidth
O loop FOR...NEXT que corre por 6 segundos envia pulsos para o servo da
direita (P12). O valor pulseWidthComp é enviado para o servo da esquerda
(P13), fazendo com que ele gire no sentido oposto.
PULSOUT 13, pulseWidthComp
PAUSE 20
NEXT
Sua Vez - Tópico Avançado: Criando o gráfico da Largura de Pulso x
Velocidade de Rotação
A Figura 3-20 mostra um exemplo de uma curva de transferência para um
servo de rotação contínua. O eixo horizontal mostra a largura de impulsos
em ms, e o eixo vertical mostra a velocidade de rotação em RPM. Neste
gráfico, o sentido horário é negativo e anti-horário é positivo. A curva de
faixas de transferências deste servo em particular é cerca de -48 RPM para
48 RPM em toda a gama de testes de largura de pulso que varia de 1,3 ms
para 1,7 ms.
Rotational Velocity vs. Pulse Width for Servo
60
Rotational Velocity, RPM
40
Figura 3- 20
Exemplo de
transferência de
Curva para Servo de
Rotação Contínua da
Parallax
20
0
-20
-40
-60
1.300
1.350
1.400
1.450
1.500
1.550
1.600
1.650
1.700
Pulse Width, m s
Right Servo
Lembre-se que o argumento Duração do comando PULSOUT está em 2
unidades ms. PULSOUT 12, 650 envia pulsos que duram 1,3 ms para P12.
PULSOUT 12, 655 envia pulsos de 1,31 ms, PULSOUT 12, 660 envia
pulsos de 1,32 ms, e assim por diante.
Você pode usar a Tabela 3- 1 para gravar os dados para a sua própria curva
de transferência. Tenha em mente que o programa de exemplo é o controle
da roda direita com os valores inseridos. A roda esquerda gira no sentido
oposto.
 Marque a sua roda direita para que você tenha um ponto de
referência para contar as revoluções
 Execute o programa TestServoSpeed.bs2.
Tabela 3 1: Largura de Pulso e RPM para Parallax Servo Rotação Contínua
Largur
a de
Pulso
(ms)
Velocida
de (RPM)
Largur
a de
Pulso
(ms)
Velocida
de (RPM)
Largur
a de
Pulso
(ms)
Velocida
de (RPM)
Largur
a de
Pulso
(ms)
1.300
1.400
1.500
1.600
1.310
1.410
1.510
1.610
1.320
1.420
1.520
1.620
1.330
1.430
1.530
1.630
1.340
1.440
1.540
1.640
1.350
1.450
1.550
1.650
1.360
1.460
1.560
1.660
1.370
1.470
1.570
1.670
1.380
1.480
1.580
1.680
1.390
1.490
1.590
1.690
Velocida
de (RPM)
1.700
 Clique na janela de transmissão do DEBUG Terminal.
 Digite o valor 650.
 Conte quantas voltas a roda fez.
Como o servo gira por 6 segundos, você pode multiplicar esse valor por
10 para obter rotações por minuto (RPM).
 Multiplique esse valor por 10 e digite o resultado ao lado da entrada
da tabela de 1.3 ms
 Digite o valor 655, e conte quantas voltas a roda fez.
 Multiplique esse valor por 10 e digite o resultado ao lado da entrada
da tabela de 1.31 ms
 Aumente as suas durações de 5 (0,01 ms) até que você esteja em 850
(1,7 ms).
 Use uma planilha eletrônica, calculadora ou papel quadriculado para
representar graficamente os dados.
 Repita esse processo para o outro servo.
Para repetir essas medições para a roda esquerda, modificar os comandos
PULSOUT para que os pulsos com duração de pulseWidth sejam enviados
para P13 e pulsos com duração de pulseWidthComp sejam enviados para
P12.
SUMÁRIO
Este capítulo abrange montagem e testes do Boe-Bot. Isso envolve a
montagem mecânica do conjunto, como conectar as várias peças móveis
para o chassi do Boe-Bot. E também a montagem do circuito, ligando servos
e “piezospeaker”. O teste envolveu um novo teste dos servos depois que eles
foram desligados para a construção do Boe-Bot.
O conceito de queda de energia foi introduzido junto com o que essa
condição faz com um programa em execução no BASIC Stamp. “Brownout”
faz com que o BASIC Stamp desligue e, em seguida, inicie a execução do
programa desde o início. Um “piezospeaker” foi adicionado para indicar o
início de um programa. Se o “piezospeaker” soar no meio de um programa
em execução quando não é esperado, isso pode indicar uma condição de
“brownout”. Condições de “brownout” podem, por sua vez, indicar baterias
baixas. Para fazer o “piezospeaker” emitir um som para indicar uma
reinicialização, o comando FREQOUT foi introduzido. Este comando faz parte
de uma rotina de inicialização que será usado no início de todos os
programas do Boe-Bot.
Até este capítulo, o DEBUG Terminal tinha sido usado para exibir as
mensagens enviadas para o computador através do BASIC Stamp. Estas
mensagens foram exibidas na janela de Recebimento. O DEBUG Terminal
também tem uma janela de transmissão que você pode usar para enviar
valores para o BASIC Stamp. O BASIC Stamp pode capturar esses valores
executando o comando DEBUGIN, que recebe um valor enviado pela janela
de transmissão do DEBUG Terminal e as armazena em uma variável. O
valor pode então ser utilizado pelo programa PBASIC. Esta técnica foi
utilizada para definir as larguras de pulso para controlar e testar a velocidade
e direção do servo. Também foi usado como um auxílio para a coleta de
dados para traçar a curva de transferência de um servo de rotação contínua
da Parallax.
Questões
1. Cite alguns comportamento característicos da queda de energia do
Boe-Bot?
2. Como pode ser utilizado um “piezospeaker” para detectar queda de
energia?
3. O que é o reset?
4. O que é a rotina de reinicialização?
5. Quais são os três (ou mais) possível erros que podem ocorrer quando
os servos forem desconectados e reconectados?
6. Qual é o comando que você deve mudar no programa
RightServoTest.bs2 para testar a roda esquerda ao invés da roda
direita?
Exercícios
1. Escreva um comando FREQOUT que emita um som diferente daquele
usado no reset para indicar o término de um programa.
2.
Escreva um comando FREQOUT que emite um som (diferente dos
sons de início e término de programa) que significa que um passo
intermediário em um programa tenha sido concluído. Tente um valor
com duração de 100 ms com uma frequência de 4 kHz.
Projetos
1. Modifique o programa RightServoTest.bs2 para que ele emita um
som indicando que o teste está completo.
2. Modifique o programa TestServoSpeed.bs2 para que ele use o
comando DEBUGIN para inserir a largura dos pulsos dos servos
direito e esquerdo assim como o número de pulsos que devem ser
enviados em um loop FOR...NEXT. Utilize esse programa para
controlar os movimentos do seu Boe-Bot através da janela de
transmissão do DEBUG Terminal.
Soluções
Q1.Os sintomas incluem comportamentos excêntricos, como ir em
direções inesperadas ou fazer uma dança confusa.
Q2.Um comando FREQOUT no início de todos os programas Boe-Bot faz
com que o “piezospeaker” emita um som. Este som ocorre a cada vez
que um reset acidental acontece devido às condições de queda de
energia.
Q3.A reinicialização é ocorre quando a energia é interrompida e o
programa BASIC Stamp começa a correr novamente a partir do
início do programa.
Q4.Uma rotina de inicialização consiste nas linhas de código que são
utilizadas no início do programa. Estas linhas de código são
executadas toda vez que o programa começa a partir do início.
Q5.1)As linhas servo P12 e P13 são trocadas.
2) Um ou ambos os servos são conectados invertidos, de modo que o
código de cores vermelho-preto-branco está incorreto.
3) O interruptor de alimentação não está na posição-2.
4) As baterias 9V ou AA não estão instaladas.
5) O servo de centralização potenciômetro está fora de ajuste.
Q6.Os comandos PULSOUT devem ser mudados para ler PULSOUT 13 em
vez de 12.
E1. A chave é modificar o comando FREQOUT usado no programa de
StartResetIndicator.bs2, isto é, FREQOUT, 4, 2000, 3000. Por
exemplo: FREQOUT, 4, 500, 3500 iria funcionar.
E2. FREQOUT 4, 100, 4000.
P1. A chave para resolver este programa é adicionar à linha do Exercício
1 acima do comando END no programa RightServoTest.bs2.
'
'
'
'
Robótica com o Boe-Bot - Ch03Prj01_TestCompleteTone.bs2
Servo direito gira no sentido horário por três segundos, pára um
segundo, em seguida, gira no sentido anti-horário por três
segundos. O som significa que o teste foi concluído.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
' Sinal de início de programa.
PULSOUT 12, 650
PAUSE 20
NEXT
' Sentido horário por 3 segundos.
PULSOUT 12, 750
PAUSE 20
NEXT
' Pára por um segundo.
PULSOUT 12, 850
PAUSE 20
NEXT
' Sentido anti-horário por 3 segundos.
FREQOUT 4, 500, 3500
' Sinal de fim do programa.
END
P2. Para resolver este problema, TestServoSpeed.bs2 deve ser ampliado
para receber três dados: servo pulsewidth da esquerda, servo
pulsewidth da direita, e número de pulsos. Então, a malha
FOR...NEXT com dois comandos PULSOUT do servo deve ser
adicionada para realmente mover os servo motores. Além disso,
todas as variáveis devem ser declaradas no início do programa. Um
exemplo de solução é mostrado abaixo. Nota: Este projeto funciona
melhor quando testado com as rodas do Boe-Bot apoiadas.
' Robótica com o Boe-Bot - Ch03Prj02_DebuginMotion.bs2
' Informe a largura de pulso dos servos e duração para as duas rodas
' através do Debug Terminal.
'{$STAMP BS2}
'{$PBASIC 2.5}
ltPulseWidth
rtPulseWidth
pulseCount
VAR
VAR
VAR
Word
Word
Byte
' Largura de pulso do servo esquerdo
' Largura de pulso do servo direito
' Número de pulsos para os servos
counter
VAR
Word
' Contador de loop
DO
DEBUG "Informe largura de pulso do servo esquerdo: "
' Digite os valores no
DEBUGIN DEC ltPulseWidth
' Debug Terminal
DEBUG "Informe largura de pulso do servo direito: "
DEBUGIN DEC rtPulseWidth
DEBUG "Informe o número de pulsos: "
DEBUGIN DEC pulseCount
FOR counter = 1 TO pulseCount
PULSOUT 13, ltPulseWidth
PULSOUT 12, rtPulseWidth
PAUSE 20
NEXT
LOOP
' Envia número específico de pulsos
' Servo esquerdo mexe
' Servo direito mexe
Navegação do Boe-Bot · Página 135
Capítulo 4: Navegação do Boe-Bot
O Boe-Bot pode ser programado para executar uma variedade de manobras.
As manobras e técnicas de programação apresentadas neste capítulo serão
reutilizadas em capítulos posteriores. A única diferença é que, neste capítulo,
o Boe-Bot irá cegamente executar as manobras. Nos próximos capítulos, o
Boe-Bot irá realizar manobras semelhantes em resposta às condições
detectadas com seus sensores.
Este capítulo também apresenta técnicas para ajustar e calibrar a navegação do
Boe-Bot. Incluem-se as técnicas para o drive dianteiro do Boe-Bot fazer voltas
mais precisas e calcular distâncias.
Atividade
1
2
3
4
5
6
Resumo
Programar o Boe-Bot para executar as manobras básicas: ir
para frente, para trás, girar à esquerda, à direita, e girando em
torno do eixo.
Ajustar as manobras de Atividade N º 1 de modo que elas
sejam mais precisas.
Use matemática para calcular o número de pulsos para fazer o
Boe-Bot percorrer uma distância pré-determinada.
Em vez de programar o Boe-Bot para fazer partidas e paradas
bruscas, escreva programas que fazem o Boe-Bot acelerar e
desacelerar gradualmente suas manobras.
Escreva sub-rotinas para executar as manobras básicas para que
cada sub-rotina possa ser usada repetidas vezes em um
programa.
Grave manobras complexas na memória do programa não
utilizada do módulo BASIC Stamp e escreva programas que
possam reproduzir essas manobras.
ATIVIDADE #1: MANOBRAS BÁSICAS DO BOE-BOT
A Figura 4-1 mostra a frente do seu Boe-Bot, sua traseira, seu lados esquerdo
e direito. Quando o Boe-Bot vai para a frente, na foto, ele teria que rolar para
a borda direita da página. Ao andar de ré, seria em direção à borda esquerda
da página. A curva para a esquerda seria fazer o Boe-Bot apto para dirigir fora
do topo da página, e uma curva à direita teria voltado para a parte inferior da
página.
Vire a esquerda
Para trás
Para frente
Figura 4-1
Direções do seu
Boe-Bot.
Vire a direita
Andando para Frente
Aqui está uma coisa engraçada: para fazer com que o Boe-Bot vá para a
frente, sua roda esquerda tem que girar no sentido anti-horário, mas sua roda
direita tem que girar no sentido horário. Se você ainda não compreendeu isso,
dê uma olhada na Figura 4-2 e veja se você consegue se convencer de que é
verdade. Visto a partir da esquerda, a roda tem que girar sentido anti-horário
para o Boe-Bot avançar. Visto a partir da direita, a outra roda tem que girar no
sentido horário para o Boe-Bot avançar.
Sentido antihorário
frente
Lado esquerdo
Sentidohorário
Figura 4-2
Rotação da
roda de
movimento.
frente
Lado direito
Lembre-se do capítulo 2 que o argumento Duração do comando PULSOUT
controla a velocidade e direção das voltas do servo. Os argumentos
StartValue e EndValue do loop FOR...NEXT controla, o número de pulsos
que são entregues. Uma vez que cada pulso tem a mesma quantidade de
tempo, o argumento EndValue também controla o momento em que o servocorre. Aqui está um programa de exemplo que fará com que o Boe-Bot ande
para a frente por cerca de três segundos.
Programa de Exemplo: BoeBotForwardThreeSeconds.bs2


Certifique-se de que a energia esteja ligada ao BASIC Stamp e aos
servos.
Coloque, salve e execute o programa BotForwardThreeSeconds.bs2
' Robótica com o Boe-Bot - BoeBotForwardThreeSeconds.bs2
' Faça o Boe-Bot ir para a frente por três segundos.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
' Faz os servos funcionarem por 3 segundos.
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
END
Como Funciona o Programa BoeBotForwardThreeSeconds.bs2
Desde o capítulo 2, você já adquiriu muita experiência com os elementos
deste programa: a declaração de variável, um loop FOR...NEXT, comandos
PULSOUT com Pin e argumentos de Duration, e os comandos PAUSE. Aqui
está uma revisão do que cada um faz e se relaciona com os movimentos dos
servos.
Primeiro, uma variável é declarada que será usada no loop FOR...NEXT.
counter VAR Word
Você deve reconhecer o próximo comando, que gera um sinal que indica o
início do programa. Ele será usado em todos os programas que os servos
executam.
FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset.
Este loop FOR...NEXT envia 122 conjuntos de pulsos para os servos, cada um
a P13 e P12, parando por 20 ms após cada jogo e, em seguida, volta para o
topo do loop.
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
PULSOUT 13, 850 faz com que o servo esquerdo gire no sentido anti-horário,
enquanto PULSOUT 12, 650 faz com que o servo direito gire no sentido
horário. Portanto, ambas as rodas estarão voltadas para a parte da frente do
Boe-Bot, fazendo com que ele se dirija para a frente. Demora cerca de 3
segundos para que o loop FOR ... NEXT execute 122 vezes, de modo que o
Boe-Bot impulsiona para a frente durante cerca de 3 segundos.
Sua Vez - Ajustar a Distância e Velocidade
 Ao alterar o argumento EndValue FOR ... NEXT do circuito de 122
para 61, você pode fazer o Boe-Bot avançar a metade do tempo. Este,
por sua vez, fará com que o Boe-Bot avance a metade da distância.
 Salve o programa BoeBotForwardThreeSeconds.bs2 com outro nome.
 Alterar no loop FOR...NEXT EndValue de 122 para 61.
 Execute o programa e verifique se ele funcionou em metade do tempo
e andou a metade da distância
 Execute essas tarefas novamente, mas desta vez, mude no loop
FOR…NEXT EndValue para 244.
O argumento de duração PULSOUT de 650 e 850 causou aos servos uma
rotatividade próxima a velocidade máxima. Ao trazer cada um dos
argumentos duração PULSOUT mais perto do valor de 750, você pode diminuir
a velocidade do seu Boe-Bot.
 Modifique seu programa com estes comandos PULSOUT:
PULSOUT 13, 780
PULSOUT 12, 720
 Execute o programa e verifique se o Boe-Bot se move mais devagar.
Andando para Trás, Rotacionando e Girando ao Redor de Seu Eixo
Tudo o que é preciso para obter outros movimentos de seu Boe-Bot são
diferentes combinações de argumentos Duration PULSOUT. Por exemplo, esses
dois comandos PULSOUT podem ser usados para fazer o seu Boe-Bot ir para
trás:
PULSOUT 13, 650
PULSOUT 12, 850
Estes dois comandos farão seu Boe-Bot realizar uma curva para a esquerda
(sentido anti-horário, como você estivesse olhando para ele de cima):
PULSOUT 13, 650
PULSOUT 12, 650
Estes dois comandos farão seu Boe-Bot realizar uma curva para a direita
(sentido horário como você estivesse olhando para ele de cima):
PULSOUT 13, 850
PULSOUT 12, 850
Você pode combinar todos estes comandos em um único programa fazendo o
Boe-Bot andar para a frente, virar à esquerda, virar à direita, em seguida,
andar para trás.
Programa de Exemplo: ForwardLeftRightBackward.bs2
 Coloque, salve e execute o programa ForwardLeftRightBackward.bs2.
Dica - para entrar rapidamente no programa use o menu de ferramentas do
BASIC Stamp Editor (copiar e colar) para fazer quatro cópias de um loop
FOR...NEXT. Então, apenas ajuste os valores do PULSOUT Duration e o
loop FOR…NEXT EndValues.
' Robótica com o Boe-Bot - ForwardLeftRightBackward.bs2
' Ande para a frente, esquerda, direita e depois para trás, testando e
' ajustando.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
' Sinal de programa start/reset.
' Para frente
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
' Vire a esquerda, cerca de 1/4 de volta
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
' Vire a direita, cerca de 1/4 de volta
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200
' Para trás
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
END
Sua Vez – Girando em Torno de Algo
Você pode fazer o Boe-Bot girar em torno de uma das suas rodas. O truque é
manter uma roda parada enquanto a outra gira. Por exemplo, se você deixar a
roda esquerda parada e fazer a roda direita girar no sentido horário (para a
frente), o Boe-Bot irá virar para a esquerda.
PULSOUT 13, 750
PULSOUT 12, 650
Se você quiser girar para a frente e para a direita, simplesmente pare a roda
direita, e faça a roda esquerda girar no sentido anti-horário (para a frente).
PULSOUT 13, 850
PULSOUT 12, 750
Estes são os comandos PULSOUT para rotação para trás e para a direita.
PULSOUT 13, 650
PULSOUT 12, 750
Finalmente, estes são os comandos PULSOUT para rotação para trás e para a
esquerda.
PULSOUT 13, 750
PULSOUT 12, 850
 Salve o programa ForwardLeftRightBackward.bs2 como




PivotTests.bs2
Substitua o comando PULSOUT já discutido no lugar das rotinas para a
frente, para a esquerda, para a direita e para trás.
Ajuste o tempo de execução de cada manobra mudando o loop
FOR…NEXT EndValue para 30.
Não se esqueça de alterar o comentário ao lado de cada loop
FOR…NEXT para refletir cada nova ação de pivô.
Execute o programa modificado e verifique as diferentes ações
funcionando.
ATIVIDADE #2: AJUSTANDO AS MANOBRAS BÁSICAS
Imagine escrever um programa que instrui o Boe-Bot a viajar a velocidade
máxima, para a frente, por quinze segundos. E se o Boe-Bot virar ligeiramente
para a esquerda ou para a direita enquanto anda, quando na verdade ele
deveria andar em uma linha reta? Não há necessidade de fazer o Boe-Bot
voltar e reajustar os servos com uma chave de fenda para consertar isso. Você
pode simplesmente ajustar o programa um pouco para conseguir que as duas
rodas do Boe-Bot girem na mesma velocidade. Utilizar a chave de fenda para
fazer essa correção seria um “ajuste de hardware”, enquanto a correção na
programação é um “ajuste de software”.
Corrigindo a Trajetória do Boe-Bot
O primeiro passo é analisar um percurso do Boe-Bot por tempo suficiente para
saber se ele está curvando para a esquerda ou para a direita quando deveria
estar indo reto. Dez segundos em um percurso reto para a frente devem ser
suficientes. Isto pode ser obtido com uma simples modificação no programa
BoeBotForwardThreeSeconds.bs2 da atividade anterior.
Programa de Exemplo: BoeBotForwardTenSeconds.bs2
 Abra o programa BoeBotForwardThreeSeconds.bs2.
 Renomeie e salve como BoeBotForwardTenSeconds.bs2.
 Modifique o EndValue do FOR counter de 122 para 407. O programa
deve ficar da seguinte maneira:
'Robótica com o Boe-Bot - BoeBotForwardTenSeconds.bs2
'Faça o Boe-Bot andar para a frente por dez segundos.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
' Numero de pulsos – tempo de execução.
'
'
'
'
Servo esquerdo, máxima velocidade, sentido
anti-horário.
Servo direito, máxima velocidade, sentido
horário.
NEXT
END
 Execute o programa e verifique se o seu Boe-Bot não desvia para a
direta ou para a esquerda à medida que anda para a frente por dez
segundos.
Sua Vez – Ajustando a Velocidade do Servo para Corrigir o Percurso do
Boe-Bot
Se o seu Boe-Bot já estiver andando perfeitamente em linha reta, tente esse
exemplo de qualquer maneira. Se você seguir as instruções, ele deve fazer com
que o seu Boe-Bot desvie ligeiramente para a direita.
Vamos supor que o Boe-Bot desvie ligeiramente para a esquerda. Há formas
de analisar este problema: ou a roda esquerda está girando muito devagar, ou a
roda direita, muito rápido. Como o Boe-Bot já está andando na sua velocidade
máxima, acelerar a roda esquerda não é uma opção, mas diminuir a velocidade
da roda direita deve resolver a situação.
Lembre-se de que a velocidade do servo é determinada pelo argumento
Duration do comando PULSOUT. Quanto mais perto de 750 é o argumento do
comando Duration, mais devagar o servo girará. Isso significa que você deve
mudar o 650 no comando PULSOUT 12,650 para algo mais perto de 750. Se o
Boe-Bot está apenas um pouco fora do rumo, talvez PULSOUT 12,663 irá
resolver. Se os servos estiverem muito desalinhados, talvez PULSOUT 12,690
vá resolver.
Provavelmente serão necessárias várias tentativas para obter o valor correto.
Vamos supor que seu primeiro palpite é que PULSOUT 12,663 irá resolver
esse problema, mas termina por não ser suficiente porque o Boe-Bot ainda
está virando um pouco para a esquerda. Então tente PULSOUT 12,670. Talvez
isso super corrija e faça que o PULSOUT 12,665 resolva. Isso é chamado de
"processo iterativo", ou seja, é um processo de tentativas e refinamentos para
chegar ao valor correto.
Se o seu Boe-Bot desvia para a direita em vez da esquerda, isso significa que
você precisa desacelerar a roda esquerda, reduzindo a duração de 850 no
comando PULSOUT 13,850. Novamente, quanto mais próximo chegar do
valor de 750, mais lento o servo irá girar.
 Modifique o programa BoeBotForwardTenSeconds.bs2 para que o seu
Boe-Bot ande em linha reta para a frente.
 Use fita adesiva ou etiquetas para identificar cada servo com os
melhores valores para PULSOUT.
 Se o Boe-Bot já anda para a frente em linha reta, tente as modificações
que acabamos de discutir apenas para ver o efeito. Ele deve fazer com
que o Boe-Bot ande em uma curva, em vez de uma linha reta.
Você pode achar que é uma situação completamente diferente quando você
programa o seu Boe-Bot para ir para trás.
 Modifique o programa BoeBotForwardTenSeconds.bs2 para fazer o
Boe-Bot andar para trás por dez segundos
 Repita o teste em uma linha reta.
 Repita os passos para corrigir o argumento Duration do comando
PULSOUT para endireitar o movimento para trás do Boe-Bot.
Ajustando as Curvas
Ajustes de software também podem ser feitos para fazer o Boe-Bot girar em
um ângulo específico, como 90 graus. O tempo que o Boe-Bot funciona em
um único lugar determina o quanto ele vai girar. Porque o loop FOR...NEXT
controla o tempo de execução, você pode ajustar o argumento EndValue
FOR...NEXT loop para ficar mais perto do ângulo de giro que você deseja.
Aqui está a rotina para
ForwardLeftRightBackward.bs2:
virar
à
esquerda
do
programa
FOR counter = 1 TO 24 ' Virar à esquerda - cerca 1/4 de
' volta
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
Vamos supor que o Boe-Bot vire um pouco mais do que 90 graus (1/4 de um
círculo completo). Tente FOR counter = 1 para 23, ou talvez FOR counter =
1 para 22. Se ele não voltar longe o suficiente, aumente o tempo de rotação
com o aumento do argumento FOR…NEXT do loop EndValue para qualquer
valor que o faça completar um quarto da volta.
Se você se encontrar com um valor ligeiramente acima de 90 graus e o outro
ligeiramente abaixo, tente escolher o valor que faça o girar um pouco mais,
então desacelere os servos lentamente. No caso de rodar para a esquerda, o
argumento PULSOUT Duration deve ser mudado de 650 para algo um pouco
mais próximo de 750. Tal como acontece com o exercício para andar em linha
reta, este também será um processo iterativo.
Sua Vez – Giros de 90 Graus
 Modifique o programa ForwardLeftRightBackward.bs2 para que ele
faça giros precisos de 90°.
 Atualize ForwardLeftRightBackward.bs2 com os valores PULSOUT que
você determinou para o Boe-Bot andar para a frente e para trás.
 Atualize as etiquetas dos servos com a notação apropriada de
EndValue para um giro de 90°.
Carpete pode causar erros de navegação. Se você estiver executando o BoeBot em carpetes, não espere resultados perfeitos! Um tapete é como um gramado
de campo de golfe - a forma como o carpete está inclinado pode afetar como seu
Boe-Bot se desloca, especialmente em longas distâncias. Para manobras precisas,
coloque o Boe-Bot em uma superfície lisa.
ATIVIDADE #3: CALCULANDO DISTÂNCIAS
Em competições de robótica, os robôs com navegação mais precisa recebem
possuem pontuações mais alta. Uma competição popular é chamada ‘dead
reckoning’ e seu único objetivo é fazer o robô ir a um, ou mais locais, e, em
seguida, retornar exatamente ao ponto de partida.
Você pode se lembrar das inúmeras vezes que perguntou a seus pais, enquanto
estavam a caminho do destino das férias ou da casa de parentes:
“Já chegamos?”
Talvez, depois de você ter ficado mais velho e já ter aprendido a dividir na
escola, você tenha começado a observar os placas na estrada, indicando a
distância da cidade de destino, e o velocímetro do carro. Assim, você
conseguia obter uma boa estimativa do tempo ainda necessário para chegar no
destino, dividindo a velocidade pela distância. Essa equação é dada por:
time =
distance
speed
Exemplo – Tempo no Sistema
Inglês
Exemplo – Tempo no Sistema
Métrico
Se você está a 140 milhas de distância
de seu destino, viajando a 70 milhas
por hora, você vai levar duas horas
para chegar lá.
Se você está a 200 quilômetros de seu
destino, viajando a 100 quilômetros
por hora, você vai levar duas horas
para chegar lá.
140 miles
70 miles/hour
1 hour
= 140 miles ×
70 miles
time =
200 kilometers
100 kilometers/hour
1 hour
= 200 km ×
100 km
time =
= 2 hours
= 2 hours
Você pode fazer o mesmo exercício com o Boe-Bot, exceto que você tem
controle do quão longe é o destino. Aqui está a equação que você vai usar:
servo run time =
Boe - Bot distance
Boe - Bot speed
Você terá de fazer um teste de velocidade do Boe-Bot. O caminho mais fácil é
colocar uma régua ao lado do robô e andar para frente por um segundo. Ao
medir o quanto o Boe-Bot andou, você saberá a sua velocidade. Se sua régua
for graduada em polegadas, sua resposta será em polegadas por segundo
(in/s), se for graduada em centímetros, sua resposta será em centímetros por
segundo (cm/s).
 Coloque, salve e execute o programa ForwardOneSecond.bs2.
 Coloque o Boe-Bot ao lado de uma régua, conforme mostrado na
Figura 4-3.
 Alinhe o ponto onde a roda toca o chão com o ponto 0 in/cm da
marcação da régua.
Figura 4-3: Medindo a Distância do Boe-Bot
6-9VDC
15 14 Vdd 1 3 12
9 Vdc
Battery
Red
Black
X4
Pwr
STAM
in CLA PS
SS
TM
1
Sout
Sin
ATN
Vss
P0
P1
P2
P3
P4
P5
P6
P7
U1
Vin
Vss
Rst
Vdd
P15
P14
P13
P12
P11
P10
P9
P8
Vss
P0
P2
P4
P6
P8
P1 0
P1 2
P1 4
Vd d
Vss
P1
P3
P5
P7
P9
P11
P1 3
P1 5
Vin
X1
Reset
X5
Vin
Vdd
Vss
X3
P1 5
P1 4
P1 3
P1 2
P11
P1 0
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
0
1 2
Board of Education
Rev C
© 2000-2003
Measured Distance
inch
cm


1
1
2
3
4
5
4
3
2
6
7
8
5
6
7
8
10
Pressione o botão Reset na placa para voltar a executar o programa.
Meça até que ponto o seu Boe-Bot andou, escrevendo a medida em
que a roda está tocando o chão aqui: __________________ in / cm.
'Programa Exemplo: ForwardOneSecond.bs2
"Robótica com o Boe-Bot - ForwardOneSecond.bs2
'Faça o Boe-Bot andar para a frente por um segundo.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
END
9
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Você pode também pensar sobre a distância que acabou de gravar com
velocidade, em unidades por segundo. Vamos dizer que seu Boe-Bot viajou 9
in (23 cm). Caso tenha levado um segundo para o Boe-Bot andar tudo isso,
significa que o percurso do Boe-Bot foi em torno de 9 pol/s (23 cm/s). Agora,
você consegue descobrir quantos segundos o Boe-Bot leva para percorrer uma
determinada distância.
Polegadas e centímetros por segundo
A abreviatura de polegadas é “in” e a abreviatura de centímetros é “cm”. Da
mesma forma, polegadas por segundo é abreviado “in/s”, e centímetros por
segundo é abreviado “cm/s”. Ambas são medições de velocidade convenientes
para o Boe-Bot. Há 2,54 centímetros em 1 polegada. Você pode converter
polegadas para centímetros, multiplicando o número de polegadas por 2,54. Você
pode converter centímetros em polegadas dividindo-se o número de centímetros
por 2,54.
Exemplo – Tempo para 20
polegadas
centímetros
À 9 in/s, seu Boe-Bot tem 2,22 s para
percorrer 20 polegadas.
À 23 cm/s, seu Boe-Bot tem 2,22 s
para percorrer 51 centímetros.
time =
20 in
9 in/s
= 20 in ×
= 2.22 s
time =
1s
9 in
51 cm
23 cm/s
= 51 cm ×
1s
23 cm
= 2.22 s
No Capítulo 2, Atividade nº 6, aprendemos que é preciso 24.60 ms (0,0246 s)
cada vez que os dois servos PULSOUT e um comando de PAUSE é executado
em um loop FOR...NEXT. A recíproca deste valor é o número de pulsos por
segundo, que transmite para cada circuito de servo. A recíproca é quando você
troca o numerador e o denominador de uma fração. Outra maneira de dar uma
recíproca é dividir uma fração em número ou o número, 1 ÷ 0.0246 s/pulsos =
40.65 pulsos/s.
Uma vez que você sabe a quantidade de tempo que você quer que seu Boe-Bot
avance (2,22 s) e o número de pulsos que o BASIC Stamp envia para os
servos a cada segundo (40,65 pulsos / s), você pode usar esses valores para
calcular quantos pulsos enviar para os servos. Este é o número que você terá
que usar em seu argumento EndValue FOR...NEXT loop.
40.65 pulses
s
= 90.24... pulses
≈ 90 pulses
pulses = 2.22 s ×
Os cálculos neste exemplo foram feitos em dois passos. Em primeiro lugar,
descobrir quanto tempo os servos têm que correr para fazer o Boe-Bot
percorrer uma determinada distância, em seguida, descobrir quantos pulsos
são necessários para fazer os servos serem executados por tanto tempo.
pulses =
Boe − Bot dis tan ce 40.65 pulses
×
Boe − Bot speed
s
polegadas
centímetros
À 9 in/s, seu Boe-Bot precisa de 2,22
s para percorrer 20 in.
À 23 cm/s, seu Boe-Bot precisa de
2,22 s para percorrer 51 cm.
20 in 40.65 pulses
×
9 in/s
s
1 s 40.65 pulses
= 20 in ×
×
9 in
1s
= 20 ÷ 9 × 40.65 pulses
= 90.333... pulses
≈ 90 pulses
pulses =
51 cm 40.65 pulses
×
s
23 cm/s
1s
40.65 pulses
= 51 cm ×
×
23 cm
1s
= 51 ÷ 23 × 40.65 pulses
pulses =
= 90.136... pulses
≈ 90 pulses
Sua Vez – A Distância de Seu Boe-Bot
Agora, é hora de tentar fazer isso com as distâncias que você escolheu.
 Se você não tiver feito isso, use uma régua e o programa
ForwardOneSecond.bs2 para determinar a velocidade do seu Boe-Bot
em in/s ou cm/s.
 Decida qual distância você quer que seu Boe-Bot percorra.
 Use a equação de pulsos para descobrir quantos pulsos chegam aos
servos do Boe-Bot:
pulses =
Boe − Bot dis tan ce 40.65 pulses
×
Boe − Bot speed
s
 Modifique o programa BoeBotForwardOneSecond.bs2 para que ele
forneça o número de pulsos que você determinou para sua distância.
 Execute o programa e teste para ver o quão perto chegou.
Esta técnica tem fontes de erro. A atividade que você acabou de completar não
leva em conta o fato de que levou um certo número de pulsos para o Boe-Bot
chegar até a velocidade máxima. Também não leva em conta qualquer distância
que o Boe-Bot poderia deslizar antes de uma parada completa. As velocidades do
servo também vão mais devagar quando as baterias perdem a carga.
Você pode aumentar a precisão de distâncias do Boe-Bot com dispositivos
chamados "encoders", que contam em quantos buracos o Boe-Bot passará. Kits
Encoder e outros acessórios específicos do Boe-Bot estão disponíveis a partir
www.parallax.com/go/Boe-Bot.
ATIVIDADE #4: MANOBRAS DE RAMPA
'Rampa' é uma maneira de aumentar ou diminuir gradualmente a velocidade
dos servos, em vez de iniciar ou parar abruptamente. Esta técnica pode
aumentar a expectativa de vida de ambas as baterias do seu Boe-Bot e de seus
servos.
Programação para Rampa
A chave para conseguir subir uma rampa é usar as variáveis juntamente com
as constantes do comando PULSOUT e argumento de Duration. Figura 0-6
mostra o loop FOR…NEXT utilizado para fazer o Boe-Bot, estando
completamente parado, subir uma rampa na sua velocidade máxima. Toda vez
que o loop FOR…NEXT se repete, a variável pulseCount aumenta 1. No primeiro
passo, pulseCount é 1, então é como se usássemos o comando PULSOUT 13,
751 e PULSOUT 12, 749. O segundo tempo entre o loop, o valor de
pulseCount é 2, então é como se estivesse usando o comando PULSOUT 13,
752 e PULSOUT 12, 748. A medida que o valor da variável de pulseCount
aumentar, o mesmo acontecerá com a velocidade dos servos. No centésimo
loop, a variável pulseCount é 100, então é como usar o comando PULSOUT
13, 850 e PULSOUT 12, 650, que é a velocidade máxima para frente do
Boe-Bot.
pulseCount
VAR
Word
FOR pulseCount = 1 TO 100
PULSOUT 13, 750 + pulseCount
PULSOUT 12, 750 - pulseCount
PAUSE 20
1, 2, 3,
…100
Figura 4-4
Exemplo de rampa
NEXT
Lembre-se do capítulo 2, atividade #5, O loop FOR…NEXT pode também ser
contado de baixo para cima em um número menor. Você pode usar essa rampa
de velocidade para voltar para baixo novamente FOR pulseCount = 100 1.
Esse é um programa de exemplo que usa loop FOR…NEXT para subir a rampa
em grande velocidade e depois descê-la.
Programa de Exemplo: StartAndStopWithRamping.bs2
 Coloque, salve e execute o programa StartAndStopWithRamping.bs2.
 Verifique se o Boe-Bot acelera gradualmente até sua velocidade
máxima, se mantém a velocidade máxima por um tempo, e depois
desacelera gradualmente até sua parada completa.
' -----[ Título ]------------------------------------------------------------' Robótica com o Boe-Bot - StartAndStopWithRamping.bs2
' Subindo a rampa, andando para frente e descendo a rampa.
' {$STAMP BS2}
' {$PBASIC 2.5}
pulseCount
VAR
Word
' Contador do loop FOR...NEXT.
' -----[ Inicialização ]---------------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Rotina Principal ]--------------------------------------------------' Subindo a rampa.
' Loop para subir a rampa com 100 pulsos.
PAUSE 20
' Pulso = 1.5 ms + pulseCount.
' Pulso = 1.5 ms – pulseCount.
' Pausa por 20 ms.
NEXT
' Andando para a frente por 75 pulsos.
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
'
'
'
'
Loop manda 75 pulsos a frente.
1.7 ms pulsos para servo esquerdo.
1.3 ms pulsos para servo direito.
Pausa por 20 ms.
PAUSE 20
NEXT
'
'
'
'
Loop para descer a rampa com 100 pulsos.
Pulso = 1.5 ms + pulseCount.
Pulso = 1.5 ms - pulseCount.
Pausa por 20 ms.
END
' Fica parado até pressionar reset.
' Descendo a rampa e parada total.
Sua Vez
Você também pode criar rotinas para combinar subidas e descidas da rampa
com outras manobras. Aqui está um exemplo de como subir uma rampa a
velocidade rápida de trás para frente. A única diferença entre essa rotina e a
rotina de subir a rampa de frente é o valor de pulseCount subtraído de 750 no
comando PULSOUT 13, antes de estava adicionado. Da mesma forma,
pulseCount foi adicionado ao valor de 750 no comando PULSOUT 12, antes
de onde estava subtraído.
' Subindo a rampa a velocidade máxima de trás para
frente.
PAUSE 20
NEXT
Você também pode fazer uma rotina que envolva a rampa e a realização de
curvas somando o valor pulseCount para 750 em ambos os comandos
PULSOUT. Subtraindo pulseCount de 750 em ambos comandos PULSOUT,
você pode subir a rampa e fazer uma volta para outra direção. Aqui está um
exemplo de um quarto de volta na rampa. Os servos não terão a oportunidade
de atingir a velocidade máxima antes que eles tenham de diminuir suas
velocidades novamente.
' Subindo a rampa com curva para a direita.
PAUSE 20
NEXT
' Descendo a rampa com curva para a direita.
PAUSE 20
NEXT
 Abra o programa ForwardLeftRightBackward.bs2 da Atividade #1, e
salve como ForwardLeftRightBackwardRamping.bs2.
 Modifique o novo programa para que o seu Boe-Bot suba e desça
rampas antes de cada manobra.
ATIVIDADE #5: SIMPLIFICANDO A NAVEGAÇÃO COM SUBROTINAS
No próximo capítulo, o Boe-Bot terá que realizar manobras para evitar
obstáculos. Um dos ingredientes chave para evitar obstáculos é executar
manobras pré-programadas. Uma maneira de executar manobras préprogramadas é com sub-rotinas. Esta atividade introduz sub-rotinas, e também
duas abordagens diferentes para a criação de manobras reutilizáveis com subrotinas.
Dentro da Sub-Rotina
Uma sub-rotina PBASIC tem duas partes. Uma parte é o chamado da subrotina. É o comando do programa que manda pular para a parte reutilizável do
código e, em seguida, voltar quando tiver terminado. A outra parte é, de fato,
a sub-rotina. Ela possui, no início, seu nome e termina com o comando
RETURN.
A Figura 4-5 mostra a parte do programa PBASIC que contém uma parte
chamada sub-rotina. A sub-rotina é o comando GOSUB My_Subroutine. A
sub-rotina atual é qualquer coisa dentro do My_Subroutine: rotulada pelo
comando RETURN. Ela funciona da seguinte maneira: quando o programa for
para o comando GOSUB My_Subroutine, ele procurará pelo nome
My_Subroutine. Como é mostrado pela seta (1), o programa salta para
My_Subroutine e começa a executar os comandos. O programa continua
linha por linha desde o início, então você verá a mensagem “Comando na subrotina” no seu DEBUG Terminal. PAUSE 1000 causa um segundo de pausa.
Então o programa voltará para o comando RETURN, a seta (2) mostrará como
ele pula de volta para o comando imediatamente após o comando GOSUB.
Nesse caso, é um comando DEBUG que exibe a mensagem “Após sub-rotina”.
DO
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
LOOP
2
"Antes da sub-rotina”, CR
1000
My_Subroutine
"Após sub-rotina", CR
1000
1
Figura 4-5
Sub-rotinas
básicas
My_Subroutine:
DEBUG "Comando na sub-rotina", CR
PAUSE 1000
RETURN
Programa de Exemplo – OneSubroutine.bs2
 Coloque, salve e execute o programa OneSubroutine.bs2.
' Robótica com o Boe-Bot - OneSubroutine.bs2
' Este programa demonstra uma chamada de sub-rotina simples.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG
PAUSE
GOSUB
DEBUG
END
"Antes da sub-rotina”, CR
1000
My_Subroutine
"Após sub-rotina", CR
My_Subroutine:
DEBUG "Comando na sub-rotina", CR
PAUSE 1000
RETURN
 Observe o DEBUG Terminal, e pressione o botão Reset algumas
vezes. Você deve ver o mesmo conjunto de três mensagens na ordem
certa todas as vezes.
Aqui está um programa de exemplo que tem duas sub-rotinas. Uma sub-rotina
emite um som agudo, enquanto a outra emite um som grave. Os comandos
entre DO e LOOP chamam cada uma das sub-rotinas por vez. Tente este
programa e observe o efeito.
Programa de Exemplo – TwoSubroutines.bs2
 Coloque, salve e execute o programa TwoSubroutines.bs2.
' Robótica com o Boe-Bot - TwoSubroutines.bs2
' Este programa mostra que uma sub-rotina é um bloco de comandos reutilizável.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
GOSUB
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
DEBUG
LOOP
High_Pitch
"De volta no principal", CR
1000
Low_Pitch
"De volta no principal, de novo", CR
1000
"Repete...”, CR, CR
High_Pitch:
DEBUG "Som agudo", CR
FREQOUT 4, 2000, 3500
RETURN
Low_Pitch:
DEBUG "Som grave", CR
FREQOUT 4, 2000, 2000
RETURN
Vamos tentar colocar as rotinas de navegação para a frente, para a esquerda,
para a direita e para trás dentro de sub-rotinas. Aqui está um exemplo:
Programa de Exemplo – MovementsWithSubroutines.bs2
 Coloque, salve e execute o programa MovementsWithSubroutines.bs2.
Dica: você pode usar o menu Editar no BASIC Stamp Editor para
copiar e colar blocos de código de um programa para outro.
' Robótica com o Boe-Bot - MovementsWithSubroutines.bs2
' Fazendo movimentos para a frente, para a esquerda, para a direita e para
' trás em sub-rotinas reutilizáveis.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
FREQOUT 4, 2000, 3000
GOSUB Forward
GOSUB Left
GOSUB Right
GOSUB Backward
END
Frente:
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
RETURN
Esquerda:
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
RETURN
Direita:
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200
RETURN
Para trás:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
Você deve reconhecer o padrão de movimento que o seu Boe-Bot faz, é o
mesmo realizado pelo programa ForwardLeftRightBackward.bs2. É evidente
que há muitas maneiras diferentes de estruturar um programa que irá resultar
nos mesmos movimentos. Uma terceira abordagem é dada no exemplo abaixo.
Programa de Exemplo –
MovementsWithVariablesAndOneSubroutine.bs2
Aqui está outro programa de exemplo que faz com que o Boe-Bot execute as
mesmas manobras, mas ele só usa uma sub-rotina e algumas variáveis para
fazê-lo.
Você certamente notou que até este ponto cada manobra Boe-Bot foi feita
com blocos de código semelhantes. Compare estes dois trechos:
' Para frente a velocidade
máxima
' Descendo a rampa de ré a
velocidade máxima.
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 20
NEXT
O que faz com que esses dois blocos de código realizem diferentes manobras
são alterações nos argumentos FOR StartValue EndValue e nos argumentos
Duration PULSOUT. Estes argumentos podem ser variáveis, e essas variáveis
podem ser alteradas várias vezes durante o tempo de execução do programa
para gerar diferentes manobras. Em vez de usar sub-rotinas separadas com
argumentos Duration PULSOUT específicos para cada manobra, o programa
abaixo usa a mesma rotina repetidamente. A chave para fazer diversas
manobras é definir as variáveis para os valores corretos para a manobra que
você quer antes de chamar a sub-rotina.
 Coloque, salve e execute o programa
MovementWithVariablesAndOneSubroutine.bs2.
' Robótica com o Boe-Bot - MovementWithVariablesAndOneSubroutine.bs2
' Faça uma rotina de navegação que aceita parâmetros.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
Word
pulseLeft
VAR
Word
pulseRight
VAR
Word
pulseCount
VAR
Byte
FREQOUT 4, 2000, 3000
' Para frente
pulseLeft = 850: pulseRight = 650: pulseCount = 64: GOSUB Navigate
' Curva para esquerda
' Curva para direita
' Para trás
END
Navigate:
PULSOUT 13, pulseLeft
PULSOUT 12, pulseRight
PAUSE 20
NEXT
PAUSE 200
RETURN
O seu Boe-Bot executou a sequência de frente-esquerda-direita-ré? Este
programa pode ser, a princípio, difícil de ler, porque as instruções são
organizadas de uma maneira nova. Em vez de ter cada declaração variável e
cada comando GOSUB em uma linha diferente, eles são agrupados na mesma
linha e separados por dois pontos. Aqui, os dois pontos funcionam da mesma
forma que um retorno de transporte para separar cada instrução PBASIC.
Usando dois pontos, desta forma permite que todos os novos valores de
variáveis para uma manobra sejam armazenados em conjunto, e na mesma
linha que a chamada de sub-rotina.
Sua Vez
Aqui está a sua competição de “dead reckoning” mencionada anteriormente:
 Modifique o programa
MovementWithVariablesAndOneSubroutine.bs2 para fazer seu BoeBot andar em um quadrado, olhando para frente nos dois primeiros
lados e olhando para trás nos outros dois. Dica: você terá que usar o
seu próprio argumento EndValue PULSOUT determinado na Atividade
n º 2, página 146.
ATIVIDADE #6: TÓPICO AVANÇADO - CONSTRUINDO
MANOBRAS COMPLEXAS NO EEPROM
Quando você fizer o download do programa PBASIC no seu BASIC Stamp, o
BASIC Stamp Editor converterá seu programa para um número de valores
chamado ‘tokens’. Esses tokens são como o BASIC Stamp usa as instruções
para executar o programa. Eles são armazenados em dois chips pequenos
pretos em cima do BASIC Stamp. Esse chip é um tipo especial de memória de
computador chamado ‘EEPROM,’ ao qual o suporte de eletricidade é
apagável e programável, memória apenas de leitura. O módulo BASIC Stamp
EEPROM pode guardar 2048 bytes (2 KB) de informações. O que não é usado
para armazenamento de programa (que constrói a partir do endereço 2047
para o endereço 0) pode ser usado para armazenamento de dados (que constrói
a partir do endereço 0 para o endereço 2047).
Se os dados que você armazenar em EEPROM colidirem com o seu
programa, o programa PBASIC não será executado corretamente.
Memória EEPROM é diferente de RAM (memória de acesso aleatório) de
armazenamento variável em vários aspectos:
• EEPROM leva mais tempo para armazenar um valor, às vezes até
vários milissegundos.
• EEPROM pode aceitar um número finito de ciclos de escrita, em torno
de 10 milhões de gravações. RAM tem capacidade ilimitada de
leitura/gravação.
• A função primária da EEPROM é armazenar programas e os dados
podem ser armazenados no espaço residual.
Você pode ver o conteúdo da EEPROM do BASIC Stamp no BASIC Stamp
Editor clicando em Executar e selecionando Mapa de Memória. A Figura 4-6
mostra o Mapa de Memória para MovementsWithSubroutines.bs2. Note o
mapa condensado do EEPROM no lado esquerdo da figura. Esta área
sombreada na pequena caixa na parte inferior mostra a quantidade de
EEPROM que o MovementsWithSubroutines.bs2 ocupa.
As imagens do mapa de memória mostradas nesta atividade foram retiradas
do BASIC Stamp Editor v2.1. Se você estiver usando uma versão diferente
do BASIC Stamp Editor, o seu mapa de memória conterá as mesmas
informações, mas pode ser formatado de forma diferente.
Figura 4-6
BASIC Stamp
Editor de Mapa
de Memória
Enquanto estamos aqui, observe também que a variável counter que
declaramos como uma palavra é visível no registro 0 do Mapa RAM.
Este programa pode parecer grande, enquanto você estava o digitando, mas
ocupa apenas 136 dos 2.048 bytes de memória disponíveis do programa.
Atualmente, há espaço suficiente para uma lista bastante longa de instruções.
Uma vez que um caractere ocupa um byte na memória, há espaço para 1.912
instruções de direção de um caractere.
Navegação do EEPROM
Até este ponto, temos tentado três diferentes abordagens de programação para
fazer com que o drive dianteiro de sua unidade Boe-Bot vire à esquerda, vire à
direita, e retorne. Cada técnica tem seus méritos, mas tudo será complicado se
você quiser que o seu Boe-Bot execute um conjunto maior e mais complexo
de manobras. Os exemplos de programas futuros usarão os blocos de código,
agora familiares, nas sub-rotinas para cada manobra básica. Em cada manobra
é dado um código de uma letra como referência. Listas longas destas letras de
códigos podem ser armazenadas em EEPROM e, em seguida, lidas e
descodificadas durante a execução do programa. Isso evita o tédio de repetir
longas listas de sub-rotinas, ou de ter que alterar as variáveis antes de cada
comando GOSUB.
Essa abordagem de programação requer algumas novas instruções PBASIC:
dados da diretiva e comandos READ e SELECT...CASE...ENDSELECT.
Vamos dar uma olhada em cada um antes de testar um programa de exemplo.
A cada uma das manobras básicas é dado um único código de letras que
correspondem à sua sub-rotina: F para Forward, B para Backward, L para
Left_Turn, e R para Right_Turn. Os movimentos complexos do Boe-Bot
podem ser rapidamente coreografados fazendo uma série de códigos de
leitura. A última carta na sequência é um Q, que significa "parar" quando os
movimentos forem maiores. A lista é salva na EEPROM durante o download
do programa com a diretiva de dados, que se parece com isso:
DATA
"FLFFRBLBBQ"
Cada letra é armazenada em um byte de EEPROM, começando no endereço 0
(a menos que diga a ele para começar em outro lugar). O comando READ pode
então ser usado para obter esta lista de volta para fora de EEPROM, enquanto
o programa está sendo executado. Estes valores podem ser lidos dentro do
DO…LOOP assim:
DO UNTIL (instruction = "Q")
READ address, instruction
address = address + 1
' PBASIC code block omitted here.
LOOP
A variável de endereço é a localização de cada byte na EEPROM que está
armazenando uma letra de código. A Instrução variável irá manter o valor real
desse byte, à nossa carta de código. Note que a cada loop, o valor da variável
de endereço é aumentado em um. Isto irá permitir que cada letra possa ser lida
a partir de bytes consecutivos na EEPROM, começando no endereço 0.
O comando DO…LOOP tem condições opcionais que são úteis para diferentes
circunstâncias. O DO UNTIL (condition)...LOOP permite o loop de um
ciclo de repetição até que ocorra uma determinada condição. DO WHILE
(condition)...LOOP permite que o loop repita somente enquanto uma
determinada condição exista. Nosso programa de exemplo usará DO…LOOP
UNTIL (condition). Neste caso, DO…LOOP é repetido até que o caractere
"Q" seja lido da EEPROM.
A afirmação SELECT...CASE...ENDSELECT pode ser usada para selecionar
uma variável e avaliá-la em uma base, caso-a-caso e também executar blocos
de código em conformidade. Aqui está o bloco de códigos que vai olhar para
cada valor de letra mantido na variável de instrução e, em seguida, chamar a
sub-rotina adequada, para cada caso, de uma determinada letra.
SELECT instruction
CASE "F": GOSUB Forward
CASE "B": GOSUB Backward
CASE "R": GOSUB Right_Turn
CASE "L": GOSUB Left_Turn
ENDSELECT
Aqui estão estes conceitos, todos juntos em um único programa.
Programa de Exemplo: EepromNavigation.bs2
 Leia atentamente as instruções de código e comentários no programa
EepromNavigation.bs2 para entender o que cada parte do programa
faz.
 Coloque, salve e execute o programa EepromNavigation.bs2.
'Robótica com o Boe-Bot - EepromNavigation.bs2
'Navegar usando caracteres armazenados em EEPROM.
' {$STAMP BS2}
' Stamp diretiva.
' {$PBASIC 2.5}
' PBASIC diretiva.
DEBUG "programa funcionando!"
' -----[ Variáveis ]---------------------------------------------------------
pulseCount
address
instruction
VAR
VAR
VAR
Word
Byte
Byte
' Armazena número de pulsos.
' Armazena endereço do EEPROM.
' Armazena instrução do EEPROM.
' -----[ EEPROM Dados ]-----------------------------------------------------'
Address: 0123456789
'
||||||||||
DATA
"FLFFRBLBBQ"
' Essas duas linhas comentadas mostram
' EEPROM endereço de cada dado
' Instruções de navegação.
' -----[ Inicialização ]----------------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Rotina Principal ]--------------------------------------------------DO UNTIL (instruction = "Q")
READ address, instruction
address = address + 1
' Dados das instruções de endereço.
' Adiciona 1 no endereço na próxima leitura
SELECT instruction
CASE "F": GOSUB Forward
CASE "B": GOSUB Backward
CASE "L": GOSUB Left_Turn
CASE "R": GOSUB Right_Turn
ENDSELECT
'
'
'
'
Chama diferentes sub-rotinas
Para cada caractere possível
Que pode ser obtido em
EEPROM.
LOOP
END
' Fica parado até pressionar o Reset.
' -----[ Sub-rotina - Frente ]----------------------------------------------Forward:
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
'
'
'
'
'
Sub-rotina para andar para frente.
Envia 64 pulsos.
1.7 ms pulsos para o servo esquerdo.
1.3 ms pulsos para o servo direito.
Pausa por 20 ms.
' Retorna para loop da rotina principal.
' -----[ Sub-rotina – Trás ]-------------------------------------------------Backward:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
' Sub-rotina para andar para trás.
' Envia 64 pulsos.
' 1.3 ms pulsos para o servo esquerdo.
' 1.7 ms pulsos para o servo direito.
' Pausa por 20 ms.
' Retorna para loop da rotina principal.
' -----[ Sub-rotina – Curva a esquerda ]-------------------------------------Left_Turn:
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
RETURN
'
'
'
'
'
'
Sub-rotina para virar à esquerda.
Envia 24 pulsos.
1.3 ms pulsos para o servo esquerdo.
1.3 ms pulsos para o servo direito.
Pausa por 20 ms. NEXT
Retorna para loop da rotina principal.
' -----[ Sub-rotina - Curva a direita ]--------------------------------------Right_Turn:
' Sub-rotina vire a direita.
' Envia 24 pulsos.
PULSOUT 13, 850
' 1.7 ms pulsos para o servo esquerdo.
PULSOUT 12, 850
' 1.7 ms pulsos para o servo direito.
PAUSE 20
' Pausa por 20 ms.
NEXT
RETURN
' Retorna para a seção da rotina principal.
Seu Boe-Bot dirigiu em um retângulo indo para frente nos primeiros dois
lados e para trás no segundo? Se ele estiver parecendo mais com um trapézio,
você pode querer ajustar o argumento FOR...NEXT do loop EndValue para
tornar a fazer voltas precisas de 90 graus
Sua Vez
 Com EepromNavigation.bs2 ativo no BASIC Stamp Editor, clique em
Executar e selecione Mapa de Memória.
As instruções armazenadas vão aparecer em destaque, em azul, no início do
Mapa EEPROM, como mostrado na Figura 4- 7. Os números mostrados são
os códigos ASCII hexadecimais que correspondem aos caracteres inseridos
em sua declaração DATA.
Figura 4 -7
Mapa de memória
com instruções
armazenadas
visíveis no mapa
do EEPROM
 Clique na caixa ASCII exibida perto do canto inferior esquerdo da
janela Mapa de Memória.
Agora as instruções de direção aparecerão em formatos mais familiares,
mostrados na Figura 4-8. Ao invés dos códigos ASCII, elas aparecerão como
os caracteres reais que você gravou usando a diretiva DATA.
Figura 4- 8
Close-up da
detalhada do
EEPROM Mapa
após exibição Box
ASCII.
Este programa armazena um total de 10 caracteres na EEPROM. Esses dez
caracteres foram acessados por uma variável de endereço do comando READ.
A variável de endereço foi declarada como um byte, então ela pode acessar até
256 locais, bem mais que os 10 necessários. Se a variável de endereço é
redeclarada a ser uma variável de texto, você poderá, teoricamente, acessar até
65535, muito mais locais do que os que estão disponíveis. Tenha em mente
que se o programa se torna maior, o número de endereços disponíveis para a
realização de EEPROM de dados fica menor.
Você pode modificar a sequência de dados existentes para um novo conjunto
de direções. Você também pode adicionar declarações de dados adicionais. Os
dados são armazenados em sequência, de modo que o primeiro caractere na
segunda sequência de dados ficará armazenado imediatamente após o último
caractere na primeira sequência de dados.
 Tente alterar, adicionando e deletando os caracteres na diretiva DATA, e
reexecute o programa. Lembre-se que o último caractere na diretiva
DATA deve sempre conter o “Q.”
 Modifique a diretiva DATA para fazer seu Boe-Bot executar a
sequência familiar de movimentos de frente-esquerda-direita-para trás.
 Tente adicionar a segunda diretiva DATA. Lembre-se de remover “Q”
do final para a primeira diretiva DATA e adicioná-lo ao final do
segundo. Caso contrário, o programa irá executar apenas os comandos
na primeira diretiva DATA.
Programa de exemplo – EepromNavigationWithWordValues.bs2
Este programa a seguir é um exemplo que parece complicado à primeira vista,
mas é uma maneira muito eficiente para projetar coreografias de programas
para o Boe-Bot. Este programa usa exemplo de armazenamento de dados
EEPROM, mas não usa sub-rotinas. Em vez disso, um único bloco de código
é utilizado, com variáveis no lugar do FOR...NEXT do loop EndValue e
argumentos PULSOUT Duration.
Por padrão, a diretiva DATA armazena bytes de informações EEPROM. Para
armazenar word-sized itens de dados, você pode adicionar o modificador
Palavra da diretiva DATA, antes de cada item de dados em sua fita. Cada item
de dados word-sized usará dois bytes de EEPROM de armazenamento, de
modo que os dados serão acessados através de qualquer outra localização de
endereços. Ao utilizar mais de uma diretiva de dados, é mais conveniente
atribuir um rótulo a cada uma. Dessa forma, os comandos de leitura podem se
referir ao rótulo para recuperar itens de dados sem a necessidade de descobrir
em qual endereço EEPROM cada sequência de itens de dados começa. Dê
uma olhada neste trecho de código:
' addressOffset
Pulses_Count DATA
Pulses_Left DATA
Pulses_Right DATA
0
Word 64,
Word 850,
Word 650,
2
4
6
8
Word 24, Word 24, Word 64, Word 0
Word 650, Word 850, Word 650
Word 650, Word 850, Word 850
Cada uma das três instruções de DATA começa com a sua própria nomeação. O
modificador Word precede cada item de dados, e os itens são separados por
vírgulas. Estas três cadeias de dados serão armazenadas no EEPROM uma
após a outra. Nós não precisaremos fazer as contas para descobrir o número
do endereço de um determinado item de dados, porque os rótulos e a variável
addressOffset vão fazer isso automaticamente. O comando READ usa cada
rótulo para determinar o endereço EEPROM onde essa sequência se inicia, e
em seguida, adiciona o valor da variável addressOffset sabendo quantos
números de endereços e mudam até encontrar a DataItem correta. A
DataItem encontrada no endereço resultante será armazenada na variável do
argumento do comando READ. Note-se que o modificador palavra também
vem antes da variável que armazena o valor obtido a partir do EEPROM.
DO
READ Pulses_Count + addressOffset, Word pulseCount
READ Pulses_Left + addressOffset, Word pulseLeft
READ Pulses_Right + addressOffset, Word pulseRight
addressOffset = addressOffset + 2
' PBASIC code block omitted here.
LOOP UNTIL (pulseCount = 0)
No primeiro loop, addressOffset = 0. O primeiro comando READ vai
recuperar um valor de 64 desde o primeiro endereço no rótulo
Pulses_Count, e colocá-lo na variável pulseCount. O segundo comando
READ recupera um valor de 850 desde o primeiro endereço indicado pelo
rótulo Pulses_Left, e coloca-o na variável pulseLeft. O terceiro comando
de leitura recupera um valor de 650 a partir do primeiro endereço especificado
pela etiqueta Pulses_Right e coloca-o na variável pulseRight. Note-se que
estes são os três valores da coluna "0" do trecho de código acima. Quando o
valor destas variáveis é colocado no bloco de código que segue, é o seguinte:
FOR counter = 1 TO
pulseCount
PAUSE 20
NEXT
....becomes....
FOR counter = 1 TO
64
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
Você reconhece a manobra básica gerada por este bloco de código?
 Olhe para as outras colunas do trecho de código na página 172 e
antecipe que o bloco de código FOR…NEXT ... apareça na segunda,
terceira e quarta vez através do loop.
 Olhe para o LOOP UNTIL (pulseCount = 0) a declaração no
programa abaixo. O <> operador significa “não é igual a”. O que vai
acontecer na quinta vez depois do loop?
 Coloque,
salve
e
execute
o
programa
EepromNavigationWithWordValues.bs2.
'Robótica com o Boe-Bot - EepromNavigationWithWordValues.bs2
'Guardar listas de valores de texto ditados.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Variáveis ]---------------------------------------------------------counter
pulseCount
addressOffset
VAR
VAR
VAR
Word
Word
Byte
' Armazena o número de pulsos.
' Armazena o deslocamento do nome.
instruction
pulseRight
pulseLeft
VAR
VAR
VAR
Byte
Word
Word
' Armazena instruções EEPROM.
' Armazena a largura dos pulsos de Servo.
' -----[ EEPROM Dados ]------------------------------------------------------' addressOffset
Pulses_Count DATA
Pulses_Left DATA
Pulses_Right DATA
0
2
4
6
8
Word 64, Word 24, Word 24, Word 64, Word 0
' -----[ Inicialização ]-----------------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Menu da Rotina ]----------------------------------------------------DO
READ Pulses_Count + addressOffset, Word pulseCount
READ Pulses_Left + addressOffset, Word pulseLeft
READ Pulses_Right + addressOffset, Word pulseRight
addressOffset = addressOffset + 2
PAUSE 20
NEXT
LOOP UNTIL (pulseCount = 0)
END
' Fica parado até pressionar o Reset.
O seu Boe-Bot fez uma realizou o familiar movimento para frente-esquerdadireita-para trás? Você está completamente entediado com ele até agora? Você
deseja ver o seu Boe-Bot fazer outra coisa, ou coreografar sua própria rotina?
Sua Vez - Fazendo Suas Próprias Rotinas de Navegação
 Salvar EepromNavigationWithWordValues.bs2. Sob um novo nome.
 Substituir as diretivas DATA com as apresentadas abaixo.
 Executar o programa modificado e ver o que o seu Boe-Bot faz.
Pulses_Count DATA
Pulses_Left DATA
Pulses_Right DATA
Word
Word
Word
Word
Word
Word
60,
110,
850,
740,
650,
760,
Word
Word
Word
Word
Word
Word
80,
100,
800,
715,
700,
785,
Word
Word
Word
Word
Word
Word
100,
80,
785,
700,
715,
800,
Word
Word
Word
Word
Word
Word
110,
60,
760,
650,
740,
850,
Word
Word
Word
Word
Word
0
750,
750
750,
750
 Faça uma tabela com três linhas, uma para cada diretiva DATA e uma
coluna para cada manobra do Boe-Bot que você quiser fazer,
acrescentando o item Word 0 na linha Pulses_Count.
 Use a tabela para planejar a coreografia do seu Boe-Bot, preenchendo
no loop FOR ...NEXT os argumentos EndValue e PULSOUT
Duration que você vai precisar para cada o bloco de códigos de cada
manobra.
 Modificar seu programa com suas diretrizes DATA recém mapeados.
 Coloque, salve e execute o seu programa personalizado. O seu BoeBot fez o que você queria que ele fizesse? Continue trabalhando nele
até que ele faça.
SUMÁRIO
Este capítulo apresentou as manobras básicas do Boe-Bot: para frente, para
trás, virar para a esquerda ou direita, girar ao redor de seu próprio eixo. O tipo
de manobra é determinado pelos comandos PULSOUT e argumentos
Duration. A distância que as manobras vão é determinada pelo loop FOR
…NEXT e pelos argumentos StartValue e EndValue.
O Capítulo 2 inclui um ajuste de hardware, centrando fisicamente os servos do
Boe-Bot com uma chave de fenda. Este capítulo destacou os ajustes finos
feitos por manipulação do software. Especificamente, a diferença na
velocidade de rotação entre os dois servos foi compensada mudando o
comando PULSOUT e o argumento Duration para maior rapidez dos servos.
Isso muda a trajetória do Boe-Bot a partir de uma curva para uma linha reta se
os servos não estiverem perfeitamente ajustados. Para refinar o giro para que o
Boe-Bot se volte para o ângulo desejado, os argumentos StartValue e
EndValue de um loop FOR...NEXT pode ser ajustado.
A programação do Boe-Bot para percorrer uma distância pré-definida pode ser
conseguida através da medição da distância a que se desloca em um segundo,
com o auxílio de uma régua. Usando esta distância, e o número de pulsos em
um segundo de tempo de execução, pode-se calcular o número de impulsos
necessários para cobrir a distância desejada.
A rampa foi introduzida como uma forma de acelerar e desacelerar
gradualmente. É interessante para com os servos, e nós recomendamos que
você use suas próprias rotinas de rampa em vez de iniciar e parar com rotinas
abruptas como mostrado no programa de exemplos. A rampa é realizada,
levando em conta a mesma variável que é usada com o argumento Counter
no loop FOR ... NEXT e adicionando ou subtraindo-o de 750 no comando
PULSOUT do argumento Duration.
As sub-rotinas foram introduzidas como uma maneira de fazer manobras préprogramadas reutilizáveis por um programa PBASIC. Em vez de escrever
todo um loop FOR ... NEXT para cada nova manobra, uma única sub-rotina
que contém um loop FOR ... NEXT pode ser executada conforme a
necessidade com o comando GOSUB. A sub-rotina começa com um rótulo, e
termina com o comando RETURN. Uma sub-rotina é chamada a partir do
programa principal com um comando GOSUB. Quando a sub-rotina é concluída
e encontra o comando RETURN, o próximo comando a ser executado é o
imediatamente após o comando GOSUB.
O EEPROM do BASIC Stamp armazena o programa para ele funcionar, mas
você pode tirar vantagem de qualquer parte não utilizada do programa para
armazenar valores. Esta é uma ótima maneira de armazenar rotinas de
navegação personalizadas. A diretiva de dados pode armazenar valores em
EEPROM. Bytes são armazenados por padrão, mas adicionando o
modificador Word para cada item de dados permite armazenar valores até
65535 no valor de dois bytes no espaço de memória EEPROM. Você pode ler
os valores de volta para fora da EEPROM usando o comando READ. Se você
está recuperando uma variável word-sized, certifique-se de colocar um Word
modificador antes da variável que receberá o valor que READ. SELECT…CASE
foi introduzido como uma forma de avaliar uma variável caso a caso, e
executando um bloco diferente de códigos do caso. Condições opcionais DO
... LOOP são úteis em determinadas circunstâncias; DO UNTIL
(Condition)...LOOP e DO...LOOP
UNTIL
(Condition) foram
demonstradas como formas de manter a execução de um DO ... LOOP até que
seja
detectada
uma
condição
particular.
Questões
1. Que direção a roda esquerda tem que tomar para o Boe-Bot ir para a
frente? Em que direção a roda direita tem que girar?
2. Quando o Boe-Bot pivoteia para a esquerda, o que as rodas direita e
esquerda estão fazendo? Que comandos PBASIC você precisa para
fazer o Boe-Bot pivotear para a esquerda?
3. Se o seu Boe-Bot virar ligeiramente para a esquerda quando você
estiver executando um programa para fazê-lo ir para a frente, como
você corrige isso? O comando precisa ser ajustado e que tipo de ajuste
que você deve fazer?
4. Se o seu Boe-Bot viaja 11 pol/s, quantos pulsos ele vai utilizar para
fazê-lo viajar 36 polegadas?
5. Qual é a relação entre um argumento FOR…NEXT Counter e o
comando PULSOUT Duration que faz com que a rampa seja possível?
6. Que diretiva você pode usar para pré-armazenar valores BASIC Stamp
do EEPROM antes de executar um programa?
7. Que comando que você pode usar para recuperar um valor armazenado
na EEPROM e copiá-lo para uma variável?
8. Que bloco de código você pode usar para selecionar uma determinada
variável e avaliá-la, caso a caso, e executar um bloco de código
diferente para cada caso?
9. Que diferentes condições podem ser usadas com DO…LOOP?
Exercícios
1. Escreva uma rotina que faz com que o Boe-Bot recue para 350 pulsos.
2. Vamos dizer que você testou seus servos e descobriu que ele leva 48
pulsos para fazer um giro de 180° com o botão direito. Com esta
informação, escreva rotinas para fazer o Boe-Bot executar voltas de
30, 45 e 60 graus.
3. Escreva uma rotina que faz com que o Boe-Bot vá para a frente, em
seguida, entre e saia de uma rampa pivoteando e, em seguida, continue
andando para a frente.
Projetos
1. Está na hora de preencher a coluna 3 do Quadro 2-1 na página 86.
Para fazer isso, modifique os argumentos PULSOUT Duration no
programa BoeBotForwardThreeSeconds.bs2 usando cada par de
valores da coluna 1. Grave seu comportamento resultante do BoeBot para cada par na coluna 3. Depois de concluída, esta tabela
servirá como um guia de referência quando você criar seu próprio
cálculo de manobras do Boe-Bot.
2. A figura 4-9 mostra dois cursos simples. Escreva um programa
que vai fazer o seu Boe-Bot navegar ao longo de cada figura.
Assuma distâncias em linha reta (incluindo o diâmetro do círculo)
para ser 1 yd ou 1 m.
Figura 4-1
Cursos Simples
Soluções
Q1.
Q2.
Roda esquerda no sentido anti-horário, roda direita no sentido
horário.
A roda direita está girando no sentido horário (para frente), e a
roda esquerda não está se movendo.
PULSOUT 13, 750
PULSOUT 12, 650
Q3.
Você pode desacelerar a roda direita para corrigir a guinada à
esquerda. O comando PULSOUT para a roda direita precisa ser
ajustado.
PULSOUT 12, 650
Ajuste 650 para algo mais próximo de 750 para desacelerar a roda
para baixo.
PULSOUT 12, 663
Q4.
Considerando os dados abaixo, deve levar 133 pulsos para viajar
36 polegadas:
Boe-Bot speed = 11 in/s
Boe-Bot distance = 36 in/s
pulses =( Boe-Bot distance/Boe-Bot speed) * (40.65 pulses / s)
= (36 / 11 ) * (40.65)
= 133.04
= 133
Q5.
O loop FOR…NEXT variável pulseCount pode ser usado como um
deslocamento (mais ou menos) a 750 (posição média) no
argumento Duration.
FOR pulseCount = 1 to 100
PULSOUT 12, 750 – pulseCount
PAUSE 20
NEXT
Q6.
Q7.
Q8.
Q9.
A diretiva DATA.
O comando READ.
E1.
FOR counter = 1 to 350
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
SELECT...CASE...ENDSELECT.
UNTIL e WHILE.
' Backward
E2. FOR counter = 1 to 8 '
degrees
Rotate
right
30
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
' Rotate right 45 degrees
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
' Rotate right 60 degrees
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
' Forward
' Ramping pivot turn
PULSOUT 13, 750 + counter
PULSOUT 12, 750
PAUSE 20
NEXT
PULSOUT 13, 750 + counter
PULSOUT 12, 750
PAUSE 20
NEXT
PULSOUT 13, 850
' Forward
PULSOUT 12, 650
PAUSE 20
NEXT
P1.
P13
850
650
850
650
750
650
750
760
770
850
P12
650
850
850
650
850
750
750
740
730
700
Descrição
Full Speed: P13 CCW, P12 CW
Full Speed: P13 CW, P12 CCW
Full Speed: P13 CCW, P12 CCW
Full Speed: P13 CW, P12 CW
P13 Stopped, P12 CCW Full speed
P13 CW Full Speed, P12 Stopped
P13 Stopped, P12 Stopped
P13 CCW Slow, P12 CW Slow
P13 CCW Med, P12 CW Med
P13 CCW Full Speed, P12 CW Medium
Comportamento
Forward
Backward
Right rotate
Left rotate
Pivot back left
Pivot back right
Stopped
Forward slow
Forward medium
Veer right
800
650
P13 CCW Medium, P12 CW Full Speed
Veer left
P2.
O círculo pode ser feito por um desvio direito contínuo. Por
tentativa e erro, uma régua pode ajudá-lo a chegar no valor
PULSOUT correto. Um círculo com uma jarda de diâmetro.
' Robótica com o Boe-Bot - Capítulo 4 - Circle.bs2
' Boe-Bot navega em um círculo com uma jarda de diâmetro.
'{$STAMP BS2}
'{$PBASIC 2.5}
pulseCount
VAR
Word
FREQOUT 4, 2000, 3000
' Contador de pulsos dos servos.
' -----[ Rotina Principal ]-------------------------------------------Main:
DO
PULSOUT 13, 850
' Veer right
PULSOUT 12, 716
PAUSE 20
LOOP
Para fazer o triângulo, primeiro calcule o número de pulsos
necessários para um metro ou jarda de linha reta, como na questão 4.
Em seguida, ajuste suas distâncias para combinar com seu Boe-Bot e
superfície particular. Para um triângulo padrão, o Boe-Bot deve viajar
um metro/jarda para frente e, em seguida, fazer uma volta de 120
graus. Isto deve ser repetido três vezes para os três lados do triângulo.
Você pode ter que ajustar o pulseCount EndValue na sub-rotina
Right_Rotate120 para obter um giro preciso de 120 graus.
' Robótica com o Boe-Bot - Capítulo 4 - Triangle.bs2
' Boe-Bot navega no formato de um triângulo com lados de uma jarda.
' Anda reto, gira 120 graus. Repete três vezes.
'{$STAMP BS2}
'{$PBASIC 2.5}
counter
pulseCount
VAR
VAR
Nib
Word
FREQOUT 4, 2000, 3000
Main:
GOSUB Forward
GOSUB Right_Rotate120
NEXT
END
Forward:
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
Right_Rotate120:
PULSOUT 13, 850
PULSOUT 12, 850
' Triângulo tem três lados.
' Contador de pulsos dos servos
' Repete três vezes para o triângulo
' Para frente, uma jarda
' Gira para direita, 120 graus
PAUSE 20
NEXT
RETURN
Navegação Tátil com Bigodes · Página 185
Capítulo 5: Navegação Tátil com Bigodes
Muitos tipos de maquinaria robótica contam com uma variedade de opções
táteis. Por exemplo, um interruptor tátil pode detectar quando um braço
robótico encontrou um objeto. O robô pode ser programado para pegar o
objeto e colocá-lo em outro lugar. Fábricas usam interruptores táteis para
contar objetos em uma linha de produção, e também para alinhar objetos
durante os processos industriais. Em todos estes casos, os interruptores que
fornecem entradas ditam alguma outra forma de saída programada. As
entradas são eletronicamente controladas pelo produto, seja ele um robô, ou
uma calculadora, ou uma linha de produção. Com base no estado das chaves,
o braço do robô pega um objeto, ou a calculadora mostra as atualizações, ou a
linha de produção da fábrica reage com motores ou servos para orientar os
produtos.
Neste capítulo, você vai construir interruptores táteis, chamados de “bigodes”,
em seu Boe-Bot e testá-los. Então você vai programar o Boe-Bot para
monitorar o estado dessas opções e decidir o que fazer quando encontrar um
obstáculo. O resultado final será a navegação autônoma pelo toque.
NAVEGAÇÃO TÁTIL
Os bigodes são assim chamados porque é isso que esses amortecedores
aparentam, embora alguns argumentem que eles se parecem mais com
antenas. De qualquer modo, esses bigodes são mostrados montados num BoeBot na Figura 5-1. Bigodes dão ao Boe-Bot a capacidade de perceber o mundo
ao seu redor através do toque, muito parecido com as antenas de uma formiga
ou os bigodes de um gato. As atividades neste capítulo usam os bigodes por si
só, mas eles também podem ser combinados com outros sensores, você vai
aprender sobre isto em capítulos posteriores para aumentar a funcionalidade
do seu Boe-Bot.
Figura 5-1
Boe-Bot com bigodes
ATIVIDADE #1: CONSTRUINDO E TESTANDO OS BIGODES
Antes de passar para os programas que fazem o Boe-Bot navegar com base no
que ele pode tocar, é essencial construir e testar os bigodes primeiro. Esta
atividade irá guiá-lo através da construção e teste dos bigodes.
Circuito do Bigode e Montagem
 Reunir os bigodes mostrados na Figura 5-2.
 Desligue a alimentação de sua placa e servos.
Lista de Peças:
(2) Fios do bigode
(2) 7/8” parafusos de
cabeça de panela 4-40
Phillips
(2) ½″ espaçador
redondo
(2) Arruelas de Nylon,
tamanho #4
(2) Conector de 3pinos m/m
(2) Resistências, 220
Ω (vermelhovermelho-marrom)
(2) Resistências, 10
kΩ (marrom-pretolaranja)
Figura 5-2
Bigodes do
Hardware
Construindo os Bigodes
 Remova os dois parafusos frontais que prendem sua placa aos suportes
frontais.
 Consulte a Figura 5-3, enquanto segue as instruções restantes.
 Passe a arruela de nylon e, então, um espaçador redondo de ½”em
cada um dos parafusos 7/8”.
 Fixe os parafusos através dos furos da sua placa e dentro dos suportes
abaixo, mas não aperte-os por completo ainda.
 Deslize as extremidades dos fios dos bigodes em torno dos parafusos,
um acima da arruela e outro abaixo, posicionando-os para que eles se
cruzem uns sobre os outros, sem se tocar.
 Aperte os parafusos nos suportes.
Whisker
below
washer
Whisker
above
washer
Figura 5-3
Montando os bigodes
O próximo passo é adicionar circuito de bigodes como mostrado na Figura 5-4
do alto-falante e circuitos do servo que você construiu e testou nos Capítulos 2
e 3.
 Se você tem um Board of Education construa o circuito de bigodes
mostrado na Figura 5-4 usando o diagrama de fiação da Figura 5-5 na
página 190 como referência.
 Se você tiver uma HomeWork Board construa o circuito bigodes
mostrado na Figura 5-4 usando o diagrama de fiação na Figura 5-6 da
página 191 como referência.
 Certifique-se de ajustar cada bigode para que eles fiquem próximos,
mas não toquem o conector de 3 pinos no breadboard. Uma distância
de cerca de 1/8” (3 mm) é recomendada.
Vdd
Vdd
10 kΩ
10 kΩ
P7
220 Ω
Figura 5-4
Esquema dos bigodes
P5
220 Ω
Right
Whisker
Vss
Left
Whisker
Vss
Figura 5-5: Diagrama de Fiação dos Bigodes para o Board of Education
Left
Whisker
To Servos
15 14 Vdd 13 12
Red
Black
X4
Vdd
X5
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Board of Education
Rev C
© 2000-2003
Right
Whisker
Use as resistências de 220 Ω (códigos de cores vermelho-vermelho-marrom)
para conectar P5 e P7 aos seus correspondentes conectores de 3 pinos. Use
os 10 resistores kΩ (códigos de cor marrom-preto-laranja) para ligar Vdd a
cada conector de 3 pinos.
Figura 5-6: Diagrama de Fiação do Bigode para o HomeWork Board
Left
Whisker
To Servos
(916) 624-8333
Rev B
www.parallax.com
Vdd
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
HomeWork Board
Right
Whisker
Use as resistências de 220 Ω (códigos de cores vermelho-marrom-vermelho)
para conectar P5 e P7 para seus correspondentes conectores de 3 pinos. Use
os 10 resistores kΩ (códigos de cor marrom-preto-laranja) para ligar Vdd
para cada conectores de 3 pinos.
Testando os Bigodes
Dê uma segunda olhada no esquema dos bigodes (Figura 5-7). Cada traço é
tanto a extensão mecânica como a conexão elétrica térrea de um polo simples
e um curso simples normalmente aberto. A razão pela qual os bigodes estão
ligados à terra (VSS) é porque os furos metalizados na borda externa da placa
estão todos conectados a VSS. Isto é verdade tanto para o Board of Education
como para o BASIC Stamp HomeWork Board. Os suportes de metal e
parafusos fornecem a conexão elétrica para cada bigode.
Vdd
Vdd
10 kΩ
10 kΩ
P7
220 Ω
P5
220 Ω
Right
Whisker
Vss
Left
Whisker
Figura 5-7
Esquema de bigodes
Uma segunda olhada
Vss
O BASIC Stamp pode ser programado para detectar quando um bigode é
pressionado. Pinos de I / O são ligados a cada interruptor de circuito para
monitorar a tensão nos resistores de 10 kΩ levantados. A Figura 5-8 ilustra
como isso funciona. Enquanto um determinado bigode não for pressionado, a
tensão no pino de I / O ligada a esse bigode é de 5 V. Quando um bigode é
pressionado, a linha de I / O é curta para o chão (VSS), assim a linha de I / O
vê 0 V.
Todos I / O pinos por padrão entram cada vez que um programa PBASIC
começa. Isto significa que os pinos de I / O conectados aos bigodes
funcionarão automaticamente como entradas. Como uma entrada, um pino de
I / O ligado a um circuito de bigodes vai provocar a sua entrada de registo
para armazenar um 1, se a tensão é de 5 V (bigode não pressionado) ou um 0
se a voltagem é de 0 V (bigode pressionado). O DEBUG Terminal pode ser
usado para exibir estes valores.
Como você consegue que o BASIC Stamp diga a você se ele está lendo um 1
ou 0?
Porque o circuito está ligado a P7, este valor 1 ou 0 aparecerá na variável
chamada IN7. IN7 é chamado de “input register”. Variáveis de registro de
entrada são construídas dentro e não tem que ser declaradas no início de seu
programa. Você pode ver que valor esta variável está armazenando usando o
comando DEBUG BIN1 IN7. O BIN1 é um formatador que informa ao
DEBUG Terminal que um dígito binário (1 ou 0) seja exibido.
Figura 5-8
Detectando
Contatos
Elétricos
Programa de Exemplo: TestWhiskers.bs2
Este próximo programa de exemplo é projetado para testar os bigodes para se
certificar que estão funcionando corretamente. Ao exibir os dígitos binários
armazenados no P7 e registradores de entrada P5 (IN7 e IN5), o programa vai
mostrar se o BASIC Stamp detecta contato com um bigode. Quando o valor
armazenado em um determinado registro de entrada é 1, o bigode não é
pressionado. Quando é 0, o bigode é pressionado.
 Volte a ligar a sua placa e servos.
 Coloque, salve e execute o programa TestWhiskers.bs2.
 Este programa faz uso do DEBUG Terminal, por isso deixe o cabo de
programação ligado ao BASIC Stamp enquanto o programa está sendo
executado.
'
'
'
'
Robótic com o Boe-Bot - TestWhiskers.bs2
Mostra quais pinos I/O estão conectados aos sensores dos bigodes.
{$STAMP BS2}
' Stamp diretiva.
{$PBASIC 2.5}
' PBASIC diretiva.
DEBUG "WHISKER STATES", CR,
"Left
Right", CR,
"------ ------"
DO
DEBUG CRSRXY, 0, 3,
"P5 = ", BIN1 IN5,
" P7 = ", BIN1 IN7
PAUSE 50
LOOP
 Observe os valores exibidos no DEBUG Terminal, que devem mostrar
que tanto o P7 e P5 são iguais a 1.
 Verifique a Figura 5-5 na página 190 (Figura 5-6 na página 191) para
que você saiba qual é o "bigode de esquerda" e qual é o "bigode de
direita".
 Pressione o bigode para a direita em seu conector de três pinos, e
observe os valores exibidos no DEBUG Terminal. Ele agora deve ser:
P5 = 1 = 0 P7
 Pressione o bigode de esquerda em seu conector de três pinos, e anote
o valor exibido no DEBUG Terminal novamente. Desta vez, deve lerse:
P5 = 0 = 1 P7
 Pressione os dois bigodes contra os conector de três pinos. Agora ele
deve ler
P5 = 0 = 0 P7
 Se os bigodes passaram em todos esses testes, você está pronto para
seguir em frente, caso contrário, verifique se o programa e os circuitos
estão livre de erros.
O que é um Cursor? O que é CRSRXY?
De acordo com o dicionário online Merriam-Webster, um "cursor" é: "Um item
móvel usado para marcar uma posição como uma dica visual em uma tela de
vídeo que indica a posição”. À medida que você move o mouse, o ponteiro que
se move sobre sua tela é um cursor. Cursor do DEBUG Terminal é um pouco
diferente porque ele não pisca ou faz qualquer coisa para indicar a sua posição.
Mas, onde quer que o cursor do DEBUG Terminal esteja é onde o próximo
caractere será impresso.
CRSRXY é um formatador que lhe permite organizar convenientemente as
informações que o seu programa envia para o DEBUG Terminal. O formatador
CRSRXY 0, 3, no comando:
DEBUG CRSRXY, 0, 3,
"P5 =", BIN1 IN5,
"P7 =", BIN1 IN7
... coloca o cursor na coluna 0, linha 3, no DEBUG Terminal. Isto faz com que
seja exibido bem abaixo do cabeçalho de tabela os “Whisker States”. Cada vez
através do loop, os novos valores substituem os valores antigos, porque o cursor
volta para o mesmo lugar.
ATIVIDADE #2: TESTANDO OS BIGODES EM CAMPO
Suponha que você tenha que testar os bigodes em algum momento longe de
um computador. Se o DEBUG Terminal não estiver disponível, o que você
pode fazer? Uma solução seria a de programar o BASIC Stamp para que ele
envie um sinal de saída que corresponda ao sinal de entrada que está
recebendo. Isto pode ser feito com um par de circuitos de LED e um programa
que acende os LEDs em ligados e desligados com base nas entradas dos
bigodes.
Lista de Peças:
(2) Resistores 220 Ω (vermelho-vermelho-marrom)
(2) LEDs vermelhos
Construindo o Circuito de Teste de LED dos Bigodes
 Se você tem um Board of Education, adicione o circuito mostrado na
Figura 5-9, com a ajuda do diagrama de fiação na Figura 5-10 (página
197).
 Se você tiver uma HomeWork Board adicione o circuito mostrado na
Figura 5-9, com a ajuda do diagrama de fiação na Figura 5-11 (página
198).
P10
Figura 5-9
Esquema de Teste do
LED dos bigodes
220 Ω
P1
220 Ω
LED
Vss
LED
Adicione estes
circuitos de LED.
Vss
Lembre-se que um LED é uma válvula de corrente de mão única.
Se ele estiver conectado da maneira incorreta, ele não deixará passar corrente
através, e por isso não emitirá luz. Para o LED emitir luz quando o BASIC Stamp
enviar um sinal de alta, o ânodo do diodo emissor de luz deve ser ligado à
resistência 220 Ω, e o seu cátodo deve ser ligado a VSS. Veja a Figura 5-10 ou 511.
Figura 5-10: Bigode mais Diagrama de Fiação do LED para o Board of Education.
Left
Whisker
To Servos
15 14 Vdd 13 12
This
lead
is the
anode
Red
Black
X4
Vdd
X5
Vin
Vss
Flat spot on
plastic case
indicates
cathode.
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Board of Education
Rev C
© 2000-2003
This lead is
the anode.
Right
Whisker
Figura 5-11: Bigode mais Diagrama de Fiação do LED para o HomeWork Board.
Left
Whisker
To Servos
(916) 624-8333
Rev B
www.parallax.com
Vdd
Vin
Vss
X3
Connect
the
anode
to the
220 Ω
resistor.
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
HomeWork Board
Flat spot on
plastic case
indicates
cathode
The anode
connects to
the 220 Ω
resistor.
Right
Whisker
Programando e Testando os Circuitos LED dos Bigodes.
 Reconecte a energia a sua placa.
 Salve o programa TestWhiskers.bs2 como TestWhiskersWithLeds.bs2.
 Insira essas duas instruções IF...THEN entre a PAUSE 50 e
comandos de LOOP.
IF (IN7 = 0) THEN
HIGH 1
ELSE
LOW 1
ENDIF
IF (IN5 = 0) THEN
HIGH 10
ELSE
LOW 10
ENDIF
Estas são chamadas declarações IF ... THEN e serão completamente
introduzidas na próxima atividade. Estas declarações são usadas para tomar
decisões em PBASIC. A primeira das duas declarações IF ... THEN define
P1 alta, o que acende o LED quando o bigode conectado a P7 é pressionado
(IN7 = 0). A parte ELSE da instrução faz o P1 ir devagar, desligando o LED
quando o bigode não está pressionado. A segunda instrução IF ... THEN faz
a mesma coisa para o bigode ligado ao P5 e o LED conectado ao P10.
 Execute o programa TestWhiskersWithLeds.bs2.
 Teste o programa pressionando suavemente os bigodes. Os LEDs
vermelhos devem acender quando cada traço tiver feito contato com
seu conector de 3 pinos.
ATIVIDADE #3: NAVEGANDO COM OS BIGODES
Na atividade anterior, o BASIC Stamp foi programado para detectar se um
determinado bigode foi pressionado. Nesta atividade, o BASIC Stamp vai ser
programado para tirar proveito dessas informações para orientar o Boe-Bot.
Quando o Boe-Bot está andando e um bigode é pressionado, significa que o
Boe-Bot esbarrou em alguma coisa. Um programa de navegação precisa
aproveitar esta entrada, decidir o que isso significa, e chamar um conjunto de
manobras que farão o Boe-Bot sair do obstáculo, virar e ir em uma direção
diferente.
Programando o Boe-Bot para Navegar Baseado em Dados Obtidos Pelos
Bigodes
Este próximo programa faz com que o Boe-Bot vá para a frente até encontrar
um obstáculo. Neste caso, o Boe-Bot sabe quando encontra um obstáculo,
batendo nele com um ou ambos de seus bigodes. Assim que o obstáculo é
detectado pelos bigodes, as rotinas de navegação e sub-rotinas desenvolvidas
no capítulo 4 farão com que o Boe-Bot volte e vire. Então, o Boe-Bot retoma
o movimento para frente até que ele esbarre em outro obstáculo.
Para fazer isso, o Boe-Bot precisa ser programado para tomar decisões.
PBASIC tem um comando chamado IF ... THEN que toma as decisões. A
sintaxe para IF ... THEN é
IF (condition) THEN…{ELSEIF (condition)}…{ELSE}…ENDIF
O "..." significa que você pode colocar um bloco de código (um ou mais
comandos) entre as palavras-chave. Um IF…ELSEIF…ELSEIF…ELSE
executará o bloco de código para a primeira condição que acaba por ser
verdadeira. Em seguida, ele salta para o ENDIF e continua a partir de lá. O
seguinte programa de exemplo toma decisões com base nas entradas dos
bigodes e chama as sub-rotinas para fazer o Boe-Bot agir. As sub-rotinas são
semelhantes as que você desenvolveu no Capítulo 4. Aqui é usado IF ...
THEN.
IF (IN5 = 0) AND (IN7 = 0) THEN
GOSUB Back_Up
' Ambos bigodes detectam obstáculo,
GOSUB Turn_Left ' Volta e faz curva em U (vira a esquerda
' duas vezes)
GOSUB Turn_Left
ELSEIF (IN5 = 0) THEN ' Bigode esquerdo detecta obstáculo
GOSUB Back_Up
' Volta e vira a direita
GOSUB Turn_Right
ELSEIF
GOSUB
GOSUB
ELSE
GOSUB
ENDIF
(IN7 = 0) THEN '
Back_Up
'
Turn_Left
'
Forward_Pulse '
'
Bigode direito detecta obstáculo
Volta e vira a esquerda
Ambos bigodes 1, sem contato
Impulso para a frente e
Checa novamente
Programa de exemplo: RoamingWithWhiskers.bs2
Este programa demonstra uma maneira de avaliar as entradas do bigode e
decidir qual sub-rotina de navegação chamar usando IF...THEN.
 Volte a ligar a sua placa e servos.
 Coloque, salve e execute o programa RoamingWithWhiskers.bs2.
 Deixe o Boe-Bot vagar. Quando ele encontrar obstáculos em seu
caminho, ele deve fazer dar ré, voltar, e depois andar em uma nova
direção.
'
'
'
'
'
-----[ Title ]-------------------------------------------------------------Robótica com o Boe-Bot - RoamingWithWhiskers.bs2
Boe-Bot usando os Bigodes para detector objetos e navegar ao redor deles.
{$STAMP BS2}
' Stamp diretiva.
{$PBASIC 2.5}
' PBASIC diretiva.
' -----[ Variables ]---------------------------------------------------------pulseCount
VAR
Byte
' FOR...NEXT contador de loop.
' -----[ Initialization ]----------------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Rotina Principal ]--------------------------------------------------DO
' Ambos bigodes detectam obstáculo,
GOSUB Back_Up
' Volta e faz curva em U (vira a esquerda duas vezes)
GOSUB Turn_Left
GOSUB Turn_Left
ELSEIF (IN5 = 0) THEN
' Bigode esquerdo detecta obstáculo
GOSUB Back_Up
' Volta e vira a direita
GOSUB Turn_Right
ELSEIF
GOSUB
GOSUB
ELSE
GOSUB
ENDIF
LOOP
(IN7 = 0) THEN
Back_Up
Turn_Left
Forward_Pulse
' Bigode direito detecta obstáculo
' Volta e vira a esquerda
' Ambos bigodes 1, sem contato
' Impulso para a frente e
' Checa novamente
' -----[ Sub-Rotinas ]-------------------------------------------------------Forward_Pulse:
PULSOUT 13,850
PULSOUT 12,650
PAUSE 20
RETURN
' Envia um único pulso para a frente
Turn_Left:
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
' Curva a esquerda, 90 graus
Turn_Right:
PULSOUT 13, 850
PULSOUT 12, 850
' Curva a direita, 90 graus
PAUSE 20
NEXT
RETURN
Back_Up:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
' Ré
Como RoamingWithWhiskers Funciona
As declarações IF ... THEN, na seção Rotina Principal, verifica primeiro os
bigodes para quaisquer estados que requeiram atenção. Se ambos os bigodes
são pressionados (IN5 = 0 e IN7 = 0), a “volta em U” é executada,
chamando a sub-rotina Back_Up em seguida chamar a sub-rotina Turn_Left
duas vezes seguida. Se apenas o bigode esquerdo é pressionado (IN5 = 0),
então o programa chama a sub-rotina Back_Up seguida pela sub-rotina Turn
Right. Se a haste direita é pressionada (IN7 = 0), a sub-rotina é chamada
Back_Up, seguida pela sub-rotina Turn_Left. A única combinação possível
que não tenha sido coberta é se nenhum bigode não foi pressionado (IN5 e
IN7 = 1 = 1). O comando ELSE chama a sub-rotina Forward_Pulse neste
caso.
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
GOSUB Back_Up
GOSUB Turn_Right
GOSUB Back_Up
GOSUB Turn_Left
ELSE
GOSUB Forward_Pulse
ENDIF
As sub-rotinas Turn_Left, Turn_Right e Back_Up devem parecer bastante
familiares, mas a sub-rotina Forward_Pulse tem uma reviravolta. Ela só
envia um pulso, em seguida, retorna. Isso é realmente importante, porque
significa que o Boe-Bot pode verificar seus bigodes entre cada pulso para
frente. Isso significa que o Boe-Bot procura por obstáculos cerca de 40 vezes
por segundo enquanto viaja para frente.
Forward_Pulse:
PULSOUT 12,650
PULSOUT 13,850
PAUSE 20
RETURN
Uma vez que cada velocidade máxima para a frente de pulso faz com que o
Boe-Bot ande cerca de meio centímetro, é uma boa idéia enviar apenas um
pulso, e então voltar e verificar os bigodes novamente. Uma vez que a
instrução IF ... THEN está dentro de um DO ... LOOP, cada vez que o
programa retornar de um Forward_Pulse, ele consegue um LOOP, que envia
o programa de volta para to DO. O que acontece então? A instrução IF ...
THEN verifica os bigodes mais uma vez.
Sua Vez
O loop FOR ... NEXT e os argumentos EndValue nas rotinas Back_Right e
Back-Left podem ser ajustados para mais ou menos e a rotina Back_Up pode
ter seu EndValue ajustado para que o robô dê menos ré em passeios por
espaços mais apertados.
 Experimente com loop FOR...NEXT e argumentos EndValue na
navegação de rotinas em RoamingWithWhiskers.bs2.
Você também pode modificar suas declarações IF ... THEN para fazer os
indicadores LED das atividades anteriores que manobram o Boe-Bot
adicionarem comandos HIGH e LOW para controlar os circuitos de LED. Aqui
está um exemplo..
HIGH 10
HIGH 1
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
HIGH 10
GOSUB Back_Up
GOSUB Turn_Right
HIGH 1
GOSUB Back_Up
GOSUB Turn_Left
ELSE
LOW 10
LOW 1
GOSUB Forward_Pulse
ENDIF
 Modifique a instrução IF ... THEN em RoamingWithWhiskers.bs2
para fazer o Boe-Bot transmitir sua manobra utilizando os indicadores
de LED.
ATIVIDADE #4: INTELIGÊNCIA ARTIFICIAL E DECIDINDO
QUANDO VOCÊ ESTÁ PRESO
Você deve ter notado que o Boe-Bot fica preso em cantos. Quando o Boe-Bot
entra no canto, seu bigode toca a parede do lado esquerdo, então ele vira para
a direita. Quando o Boe-Bot avança novamente, o seu bigode direito bate na
parede à direita, fazendo-o virar para a esquerda. Em seguida, ele se vira e
bate na parede esquerda e direita novamente, e assim por diante, até que
alguém o resgate desta situação.
Programação para Escapar dos Cantos
RoamingWithWhiskers.bs2 pode ser modificado para detectar este problema e
resolvê-lo. O truque é contar o número de vezes que bigodes alternados são
contatados. Uma coisa importante sobre esse truque é que o programa tem que
se lembrar em que estado cada bigode estava durante o contato anterior. Tem
que comparar com o estado dos bigodes no contato atual. Se eles são opostos,
adicionar um para o mostrador. Se o contador vai acima do limite que você (o
programador) determinou, então, é hora de fazer a “curva em U” e redefinir
esse contador alternativo do bigode.
Este próximo programa também se baseia no fato de que você pode aninhar
as declarações IF...THEN. Em outras palavras, o programa verifica a
existência de uma condição, e se essa condição for verdadeira, ele verifica se
há outra condição dentro da primeira condição. Este é um exemplo de
pseudocódigo e como ele pode ser usado.
IF condition1 THEN
Commands for condition1
IF condition2 THEN
Commands for both condition2 and condition1
ELSE
Commands for condition1 but not condition2
ENDIF
ELSE
Commands for not condition1
ENDIF
Há um exemplo de declarações aninhadas IF…THEN na rotina que detecta
contatos alternativos de bigode, consecutivos, no próximo programa.
Programa de Exemplo: EscapingCorners.bs2
Este programa fará com que o Boe-Bot execute uma “curva em U” tanto no
quarto ou quinto canto alternativo, dependendo do bigode que foi pressionado
primeiro.
 Coloque, salve e execute o programa EscapingCorners.bs2.
 Teste este programa pressionando bigodes alternativos conforme o
Boe-Bot anda. Dependendo do bigode que você começou, o Boe-Bot
deve executar sua “curva em U” na quarta ou quinta pressão do bigode
consecutivo.
'
'
'
'
'
-----[ Title ]-------------------------------------------------------------Robótica com o Boe-Bot - EscapingCorners.bs2
Boe-Bot navigates out of corners by detecting alternating whisker presses.
{$STAMP BS2}
' Stamp directive.
{$PBASIC 2.5}
' PBASIC directive.
' -----[ Variables ]---------------------------------------------------------pulseCount
counter
old7
old5
VAR
VAR
VAR
VAR
Byte
Nib
Bit
Bit
'
'
'
'
FOR...NEXT loop counter.
Counts alternate contacts.
Stores previous IN7.
Stores previous IN5.
' -----[ Initialization ]----------------------------------------------------FREQOUT 4, 2000, 3000
counter = 1
old7 = 0
old5 = 1
' Signal program start/reset.
' Start alternate corner count.
' Make up old values.
' -----[ Rotina Principal ]--------------------------------------------------DO
' --- Detect Consecutive Alternate Corners -----------------------' See the "How EscapingCorners.bs2 Works" section that follows this program.
IF (IN7 <> IN5) THEN
' One or other is pressed.
IF (old7 <> IN7) AND (old5 <> IN5) THEN
' Different from previous.
counter = counter + 1
' Alternate whisker count + 1.
old7 = IN7
' Record this whisker press
old5 = IN5
' for next comparison.
IF (counter > 4) THEN
' If alternate whisker count = 4,
counter = 1
' reset whisker counter
GOSUB Back_Up
' and execute a U-turn.
GOSUB Turn_Left
GOSUB Turn_Left
ENDIF
' ENDIF counter > 4.
ELSE
' ELSE (old7=IN7) or (old5=IN5),
counter = 1
' not alternate, reset counter.
ENDIF
' ENDIF (old7<>IN7) and
' (old5<>IN5).
ENDIF
' ENDIF (IN7<>IN5).
' --- Same navigation routine from RoamingWithWhiskers.bs2 -----------------IF (IN5 = 0) AND (IN7 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
GOSUB Back_Up
GOSUB Turn_Right
GOSUB Back_Up
' Both whiskers detect obstacle
' Back up & U-turn (left twice)
' Left whisker contacts
' Back up & turn right
' Right whisker contacts
' Back up & turn left
GOSUB Turn_Left
ELSE
GOSUB Forward_Pulse
ENDIF
' Both whiskers 1, no contacts
' Apply a forward pulse
' and check again
LOOP
' -----[ Sub-Rotinas ]-------------------------------------------------------Forward_Pulse:
PULSOUT 13,850
PULSOUT 12,650
PAUSE 20
RETURN
' Send a single forward pulse.
Turn_Left:
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
' Left turn, about 90-degrees.
Turn_Right:
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
Back_Up:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
' Right turn, about 90-degrees.
' Back up.
Como Funciona EscapingCorners.bs2
Uma vez que este programa é uma versão modificada do
RoamingWithWhiskers.bs2, apenas os novos recursos relatados para detectar
e escapar dos cantos serão discutidos aqui.
Três variáveis extras são criadas para detectar um canto. Um pequeno
contador de variável pode armazenar um valor entre 0 e 15. Uma vez que o
nosso valor alvo para a detecção de um canto é 4, o tamanho da variável é
razoável. Lembre-se que uma pequena variável pode armazenar um único bit,
um 1 ou um 0. As duas variáveis próximas (old7 e old5) são variáveis
pequenas. Estes são também o tamanho certo para o trabalho, uma vez que são
usadas para armazenar valores antigos de IN7 e IN5, que também são
variáveis pequenas .
counter
old7
old5
VAR
VAR
VAR
Nib
Bit
Bit
Essas variáveis têm de ser inicializadas (dado os valores iniciais). Por uma
questão de tornar o programa mais fácil de ler, o contador é definido como 1,
e quando chega a 4 devido ao fato de que o Boe-Bot está preso em um canto, é
redefinido como 1. As variáveis old7 e old5 têm que ser definidas de modo
que pareça que um dos dois bigodes foi pressionado algum tempo antes do
programa começar. Isto tem de ser feito porque a rotina para detectar os
cantos alternados sempre compara um padrão alternante, quer (IN5 = 1 e IN7
= 0) ou (IN5 = 0 e IN7 = 1). Da mesma forma, old5 e old7 têm que ser
diferentes um do outro.
counter = 1
old7 = 0
old5 = 1
Agora chegamos à seção detectando os códigos alternativos consecutivos A
primeira coisa que queremos verificar é se um ou outro bigode é pressionado.
Uma maneira simples de fazer isso, é perguntar “IN7 é diferente de IN5?” Em
PBASIC, podemos usar o operador não-igual <> em uma instrução IF:
IF (IN7 <> IN5) THEN
Se ele é de fato um bigode que é pressionado, a próxima coisa a verificar é se
é ou não é o exato padrão oposto como na última vez. Em outras palavras, é
(old7 <> IN7) e é (old5 <> IN5)? Se isso for verdade, então, é hora de
adicionar um ao contador que rastreia contatos de bigode alternados. Também
é hora de lembrar o padrão de bigode atual, definindo old7 igual à corrente
IN7 e old5 igual à corrente IN5.
IF (old7 <> IN7) AND (old5 <> IN5) THEN
counter = counter + 1
old7 = IN7
old5 = IN5
Se verificar que este é o quarto contato consecutivo do bigode , então é hora
de zerar o contador para 1 e executar uma “curva em U”.
IF (counter > 4) THEN
counter = 1
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
Este ENDIF termina o bloco de código que é executado se o counter > 4.
ENDIF
Esta declaração ELSE está ligada as declarações IF (old7 <> IN7) e (old5
<> IN5) THEN. A declaração ELSE cobre o que acontece se o IF não é
verdadeiro. Em outras palavras, não deve ser um bigode alternativo que foi
pressionado, para zerar o contador porque o Boe-Bot não está preso em um
canto.
ELSE
counter = 1
Esta declaração ENDIF termina o processo de tomada de decisão IF (old7
<> IN7) e (old5 <> IN5) THEN.
ENDIF
ENDIF
O restante do programa é o mesmo que antes.
Sua Vez
Uma das declarações EscapingCorners.bs2 verifica se contador alcançou 4.
 Tente aumentar o valor para 5 e 6 e observe o efeito.
 Experimente também reduzir o valor e ver se ele tem algum efeito
sobre percursos normais
SUMÁRIO
Neste capítulo, em vez de navegar a partir de uma lista pré-programada, o
Boe-Bot foi programado para navegar com base em inputs sensoriais. As
entradas sensoriais utilizadas neste capítulo foram os “bigodes”, que serviram
como interruptores de contato normalmente abertos. Quandoos fios são
colocados corretamente, essas opções podem mostrar uma tensão (5 V) no
ponto de contato do interruptor quando é aberto e uma voltagem diferente (0
V) quando ele está fechado. O BASIC Stamp I / O de entrada do pino registra
o armazenamento "1", se detectar Vdd (5 V) e "0" se detectar Vss (0 V).
O BASIC Stamp foi programado para testar os sensores de bigode e exibir os
resultados dos testes utilizando dois meios diferentes, o DEBUG Terminal e
os LEDs. Os programas PBASIC foram desenvolvidos para fazer o BASIC
Stamp verificar os bigodes entre cada pulso do servo. Com base no estado dos
bigodes, as declarações IF.... THEN na seção Rotina Principal denominada
sub-rotina de navegação similares às desenvolvidas no capítulo anterior para
levar o Boe-Bot longe dos obstáculos. Como um exemplo simples de
inteligência artificial, uma rotina adicional foi desenvolvida, que permitiu o
Boe-Bot detectar quando ele ficou preso em um canto. Esta rotina envolveu a
armazenagem de antigas informações do bigode, comparando-os contra os
atuais informações do bigode, e contando o número de detecções de objetos
alternados.
Este capítulo introduziu navegação Boe-Bot baseada em sensor. Os próximos
três capítulos incidirão sobre o uso de diferentes tipos de sensores para dar a
visão Boe-Bot. Tanto a visão quanto o tato abrem muitas oportunidades para o
Boe-Bot navegar em ambientes cada vez mais complexos.
Questões
1. Que tipo de conexão elétrica é um bigode?
2. Quando um bigode é pressionado, qual é voltagem no pino de I / O
para monitorá-lo? Que valor binário ocorrerá no registro de entrada?
Se I / O pino P8 é usado para monitorar o pino de entrada, o que o
valor IN8 tem quando um bigode está pressionado, e qual o valor que
ele tem, quando um bigode não está pressionado?
3. Se IN7 = 1, o que significa isso? O que significa se IN7 = 0? Que
tal IN5 = 1 e IN5 = 0?
4. Qual comando é utilizado para saltar para diferentes sub-rotinas,
dependendo do valor de uma variável ? Qual comando é usado para
decidir para qual sub-rotina deve ir? Essas decisões são baseadas em
que?
Exercícios
1. Escreva um comando DEBUG para TestWhiskers.bs2 que atualize cada
estado bigode em uma nova linha. Ajuste o comando de PAUSE de
modo que seja de 250 em vez de 50.
2. Usando RoamingWithWhiskers.bs2 como referência, escreva uma
sub-rotina Turn_Away que chama a sub-rotina Back_Up uma vez, e a
sub-rotina Turn_Left duas vezes. Anote as modificações que você
terá que fazer para a seção Rotina Principal do
RoamingWithWhiskers.bs2.
Projetos
1. Modificar RoamingWithWhiskers.bs2 para que o Boe-Bot faça um
beep de 4 kHz, que dura 100 ms antes de executar a manobra evasiva.
Faça-o bipar duas vezes se os contatos bigodes são detectados durante
a mesma amostra.
2. Modificar RoamingWithWhiskers.bs2 para que o Boe-Bot vague em
um círculo de 1 yard ou metro de diâmetro. Quando você tocra em um
bigode, ele fará com que o Boe-Bot viaje em um círculo apertado
(diâmetro menor). Quando você tocar o outro bigode, ele fará com que
o Boe-Bot navegue em um círculo de diâmetro maior.
Soluções
Q1.Um interruptor tátil.
Q2.Zero (0) volt, o que resulta no binário zero (0) ao registo de entrada.
IN8 = 0 quando bigode é pressionado.
IN8 = 1 quando o bigode não está pressionado.
Q3.IN7 = 1 significa que o bigode de direito não está pressionado.
IN7 = 0 significa que o bigode de direito é pressionado.
IN5 = 1 significa que o bigode de esquerda não está pressionado.
IN5 = 0 significa que o bigode esquerdo é pressionado.
Q4.O comando GOSUB executa o salto real. O comando IF ... THEN é
usado para decidir qual sub-rotina saltar. Essa decisão é baseada em
condições, que são declarações lógicas que calculam se verdadeiro ou
falso.
Q5.O programa pode verificar se há uma condição, e se essa condição for
verdadeira, ele pode verificar se há outra condição dentro da primeira
condição.
E1. A chave para resolver este problema é usar um segundo comando
CRSRXY que colocará o estado bigode certo no lugar certo na tela. Para
alinhar com os títulos, o texto deve começar na coluna 9 de linha 3.
'
'
'
'
Robótica com o Boe-Bot - TestWhiskers_UpdateEaOnNewLine.bs2
Update each whisker state on a new line.
{$STAMP BS2}
' Stamp directive.
{$PBASIC 2.5}
' PBASIC directive.
DEBUG "WHISKER STATES", CR,
"Left
Right", CR,
"------ ------"
DO
DEBUG CRSRXY, 0, 3, "P5 = ", BIN1 IN5
' Print in Column 0,Row 3
DEBUG CRSRXY, 9, 3, "P7 = ", BIN1 IN7
' Print in Column 9,Row 3
PAUSE 250
' Change from 50 to 250
LOOP
E2. Sub-Rotina:
Turn_Away:
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
RETURN
Para modificar a rotina principal, substitua os três comandos GOSUB
sob a primeira condição IF com esta única linha:
GOSUB Turn_Away
P1. A chave para resolver este problema é escrever uma declaração que
faz um som com os parâmetros necessários:
FREQOUT 4, 100, 4000
'4 kHz beep para 100 ms
A chave para resolver este problema é escrever uma declaração que
faz um som com os parâmetros necessários:
FREQOUT 4, 100, 4000
' 4 kHz beep for 100 ms
Esta instrução deverá ser adicionada à Rotina Principal nos locais
apropriados, como mostrado abaixo. O resto do programa mantém-se
inalterado
' -----[ Rotina Principal ]---------------------------
DO
IF (IN5 = 0) AND (IN7 = 0) THEN ' Both whiskers
detect
FREQOUT 4, 100, 4000
FREQOUT 4, 100, 4000
' Repeat twice
GOSUB Back_Up
' Back up & U-turn
GOSUB Turn_Left
GOSUB Turn_Left
' Left whisker contacts
FREQOUT 4, 100, 4000
GOSUB Back_Up
' Back up & turn right
GOSUB Turn_Right
' Right whisker contacts
FREQOUT 4, 100, 4000
GOSUB Back_Up
' Back up & turn left
GOSUB Turn_Left
ELSE
' Both whiskers 1, no
GOSUB Forward_Pulse
' contacts
ENDIF
' Apply a forward pulse
LOOP
' and check again
P2. Encontramos a partir do capítulo 4 Projetos que um círculo de 1 yard
pode ser alcançado com PULSOUT 13, 850 e PULSOUT 12, 716.
Utilizando estes valores como 1 yard círculo, o raio pode ser ajustado,
aumentando ou diminuindo ligeiramente a largura de impulso a partir
do valor inicial de 716. Cada vez que um bigode é pressionado, o
programa irá adicionar ou subtrair um bit de largura de pulso da roda
direita.
'
'
'
'
'
Robótica com o Boe-Bot - CirclingWithWhiskerInput.bs2
Move in 1 yard circle, increase/decrease radius in response
to whisker presses, one whisker increases, one decreases.
{$STAMP BS2}
' Stamp directive.
{$PBASIC 2.5}
' PBASIC directive.
' -----[ Variables/Initialization ]-----------------------------------pulseWidth
VAR
Word
' Signal sent to servo
toneFreq
VAR
Word
' Frequency of beeping tone
pulseWidth = 716
' Found in Ch4 to make 1y circle
toneFreq = 4000
' Beginning tone is 4 kHz
' -----[ Rotina Principal ]-------------------------------------------DO
PULSOUT 13, 850
PAUSE 20
IF (IN5 = 0) THEN
IF (pulseWidth <= 845) THEN
pulseWidth = pulseWidth + 5
toneFreq = toneFreq + 100
FREQOUT 4, 100, toneFreq
ENDIF
IF (pulseWidth >= 655) THEN
pulseWidth = pulseWidth - 5
toneFreq = toneFreq - 100
FREQOUT 4, 100, toneFreq
ENDIF
ENDIF
LOOP
' Pulse servos in circular path
' 12 slower than 13 so it arcs
' Left whisker makes circle
' smaller, down to servo max
' pulseWidth of 850.
' Play tone as indicator.
' Right whisker makes circle
' larger, down to servo min
' pulseWidth of 650.
' Play tone as indicator.
Navegação Sensível à Luz com Fototransistores · Página 217
Capítulo 6: Navegação Sensível À Luz Com
Fototransistores
Devo guardar este capítulo para mais tarde? Muitas classes pulam para o
Capítulo 7 e 8, e depois voltam aqui, se o tempo permitir. O Capítulo 7 é o
melhor "próximo passo" depois de navegação com bigodes porque introduz
um sensor que o Boe-Bot pode usar para detectar obstáculos sem esbarrar
neles. Capítulo 8 usa o mesmo sensor para detecção de distância e seguintes
objetos que irão completar a sua introdução para a detecção e navegação.
Depois disso, volte aqui para fazer seu Boe-Bot detectar e responder a algo
completamente diferente e uma luz ambiente mais desafiadora.
Baixe códigos de exemplo selecionados: Alguns dos exemplos de programas
mais longos neste capítulo estão disponíveis para download a partir
www.parallax.com/go/Boe-Bot. Procure o arquivo LightSensorExamples.zip.
A luz tem muitas aplicações na área da robótica e controle industrial. Alguns
exemplos incluem a detecção da borda de um rolo de tecido na indústria
têxtil, determinando quando ativar postes em diferentes épocas do ano,
quando tirar uma foto, ou quando fornecer água para o cultivo de plantas.
Existem muitos sensores de luz diferentes que possuem funções únicas. Os
sensores de luz no seu kit Boe-Bot respondem à luz visível, juntamente com
um tipo de luz invisível chamada de “infravermelhos”. Estes sensores
podem ser incorporados em um par de circuitos diferentes, e o BASIC
Stamp pode ser programado para interagir com eles detectando variações no
nível de luz. Com esta informação, o programa pode ser expandido para
fazer o Boe-Bot reconhecer áreas com perímetros claros ou escuros,
informar brilho geral e níveis de escuridão, e buscar fontes de luz, tais como
vigas, lanternas e portas que estão deixando a luz entrar em quartos escuros.
APRESENTANDO O FOTOTRANSISTOR
Um transistor é como uma válvula que regula a quantidade de corrente
elétrica que passa 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.
A Figura 6-1 mostra um desenho esquemático e parcial do fototransistor no
seu kit de robô Boe-Bot. O brilho da luz que brilha na base do fototransistor
(B) do terminal determina a quantidade de corrente que irá permitir a
passagem em seu coletor (C) terminal, e para fora através de seu emissor (E)
terminal. Resultados brilhantes de luz resultam em mais corrente; resultados
menos brilhantes resultam em menos corrente.
Light
B
Collector
C
Base
Flat spot and shorter
pin indicate the
emitter (E) terminal
B
E
Current
Emitter
Figura 6-1
Esquema do
Fototransistor
Símbolos e parte do
desenho
E
C
Embora o fototransistor e LED sejam dispositivos diferentes, eles têm duas
semelhanças. Primeiro, se você conectar o fototransistor no circuito para
trás, não vai funcionar direito. Em segundo lugar, o fototransistor tem dois
pinos de comprimento diferentes e uma mancha plana em sua caixa de
plástico para a identificação de seus terminais. O maior dos dois pinos indica
o terminal coletor do fototransistor, e o pino curto indica o emissor. O
terminal emissor também se liga mais perto de um ponto liso na caixa de
plástico do fototransistor, que é útil para a identificação dos terminais se os
condutores forem cortados.
 Verifique a Figura 6-1 e encontre o ponto plano do terminal emissor
e o pino mais curto.
No oceano, você pode medir a distância entre os picos de duas ondas
adjacentes em pés ou metros. Com a luz, que também viaja em ondas, a
distância entre picos adjacentes é medida em nanômetros (nm) que são
bilionésimos de metros. A Figura 6-2 mostra comprimentos de ondas de
cores de luz que estamos familiarizados mas que o olho humano não
consegue detectar, tais como luz ultravioleta e infravermelha.
O fototransistor no kit Boe-Bot e peças tem a sua sensibilidade de pico a 850
nm, o que de acordo com a Figura 6-2, está na gama de infravermelhos. A
luz infravermelha não é visível ao olho humano, mas muitas fontes de luz
emitem diferentes quantidades consideráveis dela, incluindo halogeneo e as
lâmpadas incandescentes, e especialmente o Sol. O fototransistor responde
também a luz visível, um pouco menos sensível, especialmente para
comprimentos de onda abaixo de 450 nm, que estão em azul na figura.
Figura 6-2 Comprimentos de ondas correspondentes a cor
Para uma melhor
visualização, faça o
download de um PDF fullcolor do livro de
www.parallax.com / go /
Boe-Bot.
Wavelength (nm) 10…380
Color
Ultraviolet
450 495
Violet
Blue
570 590 620
Green Orang
Yellow
750…100,00
Infrared
Red
Projetos de circuitos que usam fototransistors para detecção de luz podem
ser ajustados para um melhor desempenho em determinados níveis de luz, e
os circuitos fototransistores neste capítulo são projetados para uso interno.
Então, se a sua área de robótica tem fluorescente, incandescente, ou a
iluminação interna indireta halógena, ele deve funcionar muito bem. Evite a
luz solar em streaming através de janelas próximas, porque ela vai inundar
os fototransistores com luz infravermelha. Se a sua área de trabalho é perto
de janelas que permitem a entrada de luz solar, é uma boa idéia fechar as
cortinas antes de começar. As lâmpadas de halógeno apontadas diretamente
também podem causar problemas. Elas só devem fornecer luz indireta, o
ideal é dirigi-las para cima a fim de que a luz seja refletida no teto. Para
melhores resultados, configure seu curso em uma área com iluminação
fluorescente.
Iluminação é um nome científico para a medição de luz incidente. Uma
maneira de entender a luz incidente é pensar em uma lanterna em uma parede. O
feixe concentrado que você vê é a luz incidente. A unidade de medida de
luminância é geralmente o "foot-candle" no sistema Inglês ou o "lux" no sistema
métrico. As medições com o fototransistor Boe-Bot não se preocupam com os
níveis de “lux”, apenas se a luz incidente proveniente de certas direções é clara
ou mais escura. O programa do Boe-Bot pode então usar as diferenças entre os
níveis de iluminação direita e esquerda para tomar decisões de navegação.
ATIVIDADE #1: UM SENSOR DE LUZ BINÁRIO SIMPLES
Imagine que o seu Boe-Bot está navegando e que há uma luz brilhante no
final do curso. Por exemplo, ela pode ser uma luz brilhante que aponta para
baixo, para um determinado local. A última tarefa do curso do seu Boe-Bot
poderia ser parar debaixo dessa luz brilhante. Lâmpadas incandescentes em
luminárias e lanternas são as melhores fontes de “luz brilhante”. Fontes de
luz fluorescentes e LED compactos não são tão fáceis para o circuito desta
atividade reconhecer. Se parar sob uma luz brilhante é a única tarefa de
“busca de luz” do seu Boe-Bot, há um circuito simples que você pode usar
que permite que o BASIC Stamp saiba que detectou luz brilhante com um
binário-1, ou luz ambiente com um binário 0.
Ambiente: de acordo com o dicionário Merriam Webster, a palavra ambiente
significa existência ou presença em todos os lados. Para o nível de luz em um
quarto, pense sobre a luz ambiente como o nível geral de brilho.
Lista de Peças:
(1) Fototransistor
(2) Fios de ligação em ponte
(1) Resistência, 220 Ω (vermelho-vermelho-marrom)
(1) Resistência, 470 Ω (amarelo-violeta-marrom)
(1) Resistência, 1 kW (marrom-preto-vermelho)
(1) Resistência, 2 kW (-preto-vermelho)
(1) Resistência, 4,7 kW (amarelo-vermelho-violeta)
(1) Resistência, 10 kW (marrom-preto-laranja)
USE
THIS
ONE!
Phototransistor
Infrared LED
Flatter on
top
More Rounded
Dome
Figura 6-3:
Fototransistors vs.
IR LEDs
Construindo o Detector de Luz Brilhante
A Figura 6-4 mostra o esquema e diagrama de fiação de um circuito
fototransistor que é a tensão de saída que o BASIC Stamp vai usar para
obter esse binário 0 ou 1 de valor. Após alguns testes, e dependendo das
condições de luz em sua área de robótica, você pode acabar substituindo o
resistor 2 kW com um dos outros resistores na lista de peças.
O circuito na Figura 6- 4 é semelhante ao que você encontra nas luzes que se
acendem automaticamente à noite e a certos detectores de esteiras rolantes.
 Construa o circuito mostrado na Figura 6-4.
 O diagrama de fiação aponta para o pino emissor fototransistor, que é
mais curto e está mais próximo do local plano na caixa de plástico.
Verifique sua fiação usando a figura como uma referência para se
certificar de que o coletor e emissor do fototransistor estão
conectados corretamente em seus circuitos sensíveis à luz.
Figura 6-4
Fototransistor Tensão
Circuito de Saída
Diagramas de Fiação
Board of Education (à
esquerda);
HomeWork Board (à
direita)
Flat Spot,
Shorter Pin
Flat Spot,
Shorter Pin
Programa de Exemplo: TestBinaryPhototransistor.bs2
Este programa deve fazer o DEBUG Terminal exibir um valor de 0 em uma
sala com luzes fluorescentes e sem luz solar direta. Quando você acender
uma luz brilhante no fototransistor, o programa deve exibir um valor de 1. A
Figura 6-5 mostra um exemplo.
Figura 6-5: DEBUG Terminal mostra mensagens do TestBinaryPhototransistor.bs2
Luz Brilhante Fluorescente
 Verifique
Luz brilhante
se as ligações do fototransistor não se tocam.
Opcionalmente, enrole as partes expostas dos fios com fita isolante.
Reconecte sua placa a energia.
 Coloque, salve e execute o programa TestBinaryPhototransistor.bs2.
 Veja o valor de IN6 no DEBUG Terminal e verifique se ele
armazena 0 quando não está sob a luz brilhante e 1 quando está sob
luz brilhante. Boas fontes de luz brilhante incluem lanternas
incandescentes (lanternas com lâmpadas, e não LED), lâmpadas
incandescentes de mesa e lâmpadas halógenas pequenas.
 Se a luz ambiente é mais brilhante do que as luzes fluorescentes, e
você tem uma lâmpada brilhante agradável, você pode precisar
substituir o resistor de 2 k Ω , com um de valor menor. Tente 470 Ω,
ou até mesmo 220 Ω para as luzes realmente brilhantes.
 Se a luz ambiente for fraca, e você estiver usando uma mesa de
lâmpada fluorescente ou uma lanterna de LED para a sua luz
brilhante, você pode precisar alterar o resistor de 2 kΩ para 4,7 kΩ ,
ou até 10 k Ω.
‘Robótica com o Boe-Bot - TestBinaryPhototransistor.bs2
'Mostrar um circuito quando o fototransistor aplica mais de 1,4 V para P6
'Ou 0 quando ele se aplica menos de 1,4 V.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DEBUG CLS
DO
DEBUG HOME, "IN6 = ", BIN IN6
PAUSE 100
LOOP
Sua Vez – Faça o Boe-Bot Parar Sobre a luz Brilhante
HaltUnderBrightLight.bs2 irá fazer o Boe-Bot ir para frente até o
fototransintor detectar a luz que será suficiente para fazer e IN6 armazenar
um binario-1.
 Tente reiniciar o programa com o Boe-Bot a poucos metros da luz
brilhante.
 Posicione o Boe-Bot para que ele ande em direção à luz brilhante.
Quão perto o Boe-Bot chegará a parar direto sobre a luz?
 Tente fazer ajustes para os códigos e valores do resitor para Boe-Bot
parar bem embaixo da luz brilhante.
' Robótica com o Boe-Bot - HaltUnderBrightLight.bs2
' Velocidade máxima para a frente até que a luz brilhante faz a tensão de
' saída do circuito do fototransistor exceder 1,4 V, resultando em IN6 = 1
' {$STAMP BS2}
' {$PBASIC 2.5}
FREQOUT 4, 2000, 3000
DEBUG "Programa funcionando... "
DO UNTIL IN6 = 1
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
LOOP
Tópico Avançado: Como a Tensão do Circuito de Saída do
Fototransistor Funciona
O circuito fototransistor que você construiu aplica uma voltagem de I/O pin
P6. A voltagem rotulada VP6 na figura 6-6 é a tensão de saída do circuito
que se aplica ao I/O pin. Esta tensão aumenta com mais luz e diminui com
menos luz. Desde que o P6 que esteja definido para entrada, a voltagem
causa IN6 t para armazenar um binário-1 ou binario-0. Se a voltagem for
acima de 1.4 V, IN6 armazena um binário-1; se for abaixo, IN6 armazena
um binário-0.
To P6
Figura 6-6
Fototransistor
Tensão
Circuito de
Saída e IN6
Resposta para
VP6
Uma resistência "resiste" ao fluxo de corrente. A voltagem em um circuito
com um resistor pode ser comparada a pressão da água. Para uma dada
quantidade de corrente elétrica, mais voltagem (sob pressão) é perdida
através de uma resistência maior do que a de uma resistência menor que tem
a mesma quantidade de corrente que passa através dele. Em vez de manter a
resistência constante e variar a corrente, você pode medir a tensão maior
(queda de pressão) através do mesmo resistor com mais corrente ou menos
voltagem com menos corrente.
Quando o BASIC Stamp I/O pin é uma entrada de energia, o circuito se
comporta como se nem o pino de I/O, nem o resistor 220 Ω captassem-na. A
figura 6-6 mostra um circuito que é equivalente ao que você acabou de
construir na breadboard quando o pin de I/O é definido como entrada. Com
VDD (5 V) no topo e no térreo (0 V), na parte inferior do circuito, 5 V de
tensão eléctrica (voltagem) faz com que o fornecimento de elétrons em
baterias de Boe-Bot queira fluir através dele.
Conectado em Série Quando dois ou mais elementos são ligados de ponta a
ponta, eles estão ligados “em série”. O fototransistor e a resistência na Figura
6, 6 estão ligados em série.
Um “limite lógico” é uma tensão que distingue um binário 1 de um binário 0.
Para um BASIC Stamp I / O pin é definido para entrada, e esse limite é de 1,4
V.
Se você substituir o resistor de 2 kΩ por um resistor de 1 kΩ , o VP6 será de
valores menores para as mesmas correntes. Na verdade, vai demorar o dobro
do atual para obter VP6 anterior da entrada do BASIC Stamp I/O pin 1.4 V, o
que significa que a luz terá que ser duas vezes mais brilhante para fazer IN6
armazenar um 1. Então, o menor resistor em série com o fototransistor fará
um circuito menos sensível a luz. Se você substituir o resitor a 2 kΩ por um
resistor de 10 kΩ, VP6 vai ser 5 vezes maior com a mesma corrente, e isso
só vai tomar 1/5 a 1/5 luz para gerar a corrente para obter aumento VP6 para
cima de 1,4 V e fazer IN6 armazenar 1. Assim, um resistor maior torna o
circuito mais sensível à luz.
Lei de Ohm para o Cálculo de Tensão, Corrente e Resistência
Duas propriedades afetam a tensão no VP6: corrente e resistência. A lei de
Ohm explica como isso funciona. A Lei de Ohm diz que a tensão (V) através
de um resistor é igual à corrente (I) que passa por ele multiplicada por sua
resistência (R). Então, se você souber dois desses valores, você poderá usálos na equação da Lei de Ohm para calcular o terceiro:
V=I×R
Em alguns livros, você encontrará E = I × R. E representa o potencial
elétrico.
Tensão V é medida em unidades de volts, que são abreviadas com a letra
maiúscula V. Corrente, I, é medida em ampéres, que são abreviados como
A, e R é a resistência medida em ohms, que é abreviada com a letra grega
ômega (Ω). Os níveis de corrente que, provavelmente, você vai ver através
deste circuito estão em miliamperes (mA). O m minúsculo indica que é uma
medida de milésimos de ampéres. Da mesma forma, o k minúsculo em kΩ
indica que a medição está em milhares de ohms.
Vamos usar a lei de Ohm para calcular VP6 com o fototransistor deixando
duas quantidades diferentes do fluxo de corrente através do circuito: 1,75
mA, o que poderia acontecer como resultado da luz relativamente brilhante,
e 0,25 mA, o que aconteceria com menos luz brilhante. A Figura 6-7 mostra
as condições e suas soluções. Quando você tenta esses cálculos, certifique-se
de lembrar que mili (m) é milésimos e quilo (k) é milhares quando você
substituir os números na Lei de Ohm.
Figura 6-7: Cálculos VP6 para duas correntes do fototransistor com resitores diferentes
VP6 = I × R
= 1.75 mA × 2 kΩ
1.75
A × 2000 Ω
1000
= 1.75 A × 2 Ω
= 3.5 AΩ
=
= 3.5V
VP6 = I × R
= 0.25 mA × 2 kΩ
0.25
A × 2000 Ω
1000
= 0.25 A × 2 Ω
= 0.5 AΩ
= 0.5V
=
Sua Vez –- A Lei de Ohm e Ajustes do Resistor
Vamos dizer que a luz no seu quarto, está duas vezes mais brilhante que a do
quarto que resultou em VP6 = 3,5 V para a luz brilhante e 0,5 V para a
sombra. zOutra situação que pode causar uma corrente superior é se a luz for
uma fonte mais forte de infravermelho. Em ambos os casos, o fototransistor
pode permitir o dobro para que a corrente flua através do circuito, o que
pode levar a dificuldades na medição.
Questão: O que você poderia fazer para trazer a resposta de tensão
do circuito de volta para 3,5 V para a luz brilhante e 0,5 V para dim?
Resposta: Diminua o valor do resistor pela metade, torne-o
1 kΩ no lugar de 2 kΩ.
Tente repetir os cálculos da Lei de Ohm com R = 1 kΩ, e corrente brilhante I
= 3.5 mA e uma corrente fraca I = 0.5 mA. Isso faz o VP6 voltar para 3.5 V
para a luz brilhante e 0.5 V para a luz fraca com o dobro de corrente? (Caso
não aconteça você deve checar seus cálculos)
ATIVIDADE #2: MEDINDO
FOTOTRANSISTORES
OS
NÍVEIS
DE
LUZ
COM
Esta atividade apresenta um circuito que o BASIC Stamp pode usar para
medir o brilho da luz incidente sobre a base do fototransistor. Os valores das
medições podem variar de pequenos números, indicando luz brilhante, para
números grandes, indicando pouca luz.
Binário vs Analógico e Digital
Um sensor de binário pode transmitir dois estados diferentes, normalmente para
indicar a presença ou ausência de algo. Por exemplo, um bigode envia um sinal
de alta se não for pressionado, ou um sinal de baixa se for pressionado.
Um sensor analógico envia uma faixa contínua de valores que correspondem a
uma gama contínua de medições. Os circuitos fototransistores desta atividade são
exemplos de sensores analógicos que fornecem faixas contínuas de valores que
correspondem aos intervalos de níveis de luz contínua.
Um valor digital é um número expresso por dígitos. Computadores e
microcontroladores armazenam medições analógicas como valores digitais. O
processo de medição de um sensor analógico e armazenamento dessa medida
como um valor digital e é chamado “conversão de analógico para digital”. A
medição é chamada de medição “digitalizada”. Analógico para conversão de
documentos digitais irão também chamá-los de medições “quantificadas”.
Lista de Peças:
Nesta atividade, você vai precisar de dois fototransistores e dois capacitores
0.1 μF. A Figura 6-8 mostra os desenhos de ambos.
 Olhe atentamente para a Figura 6-8 e anote a diferença entre um
fototransistor e um LED infravermelho.
Phototransistor
Liso no
topo
Capacitor 0.1 μF
Símbolo esquemático e
desenho da peça
Infrared LED
Dome mais
arredondada
Figura 6-8
Distinguindo
fototransistores
de LEDs
infravermelhos;
Identificando o
capacitor 0.1 μF
 Reuna as peças listadas abaixo usando a Figura 6-8 como um guia
para encontrar os fototransistores e capacitores de 0.1 μF em seu kit
de peças.
(2) Fototransistores
(2) Capacitores, 0.1 μF (104)
(2) Resistores, 1 kΩ ( marrom-preto-vermelho)
(2) Fios
Apresentando o Capacitador
Um capacitor é um dispositivo que armazena carga, e isto é um bloco de
construção fundamental de muitos circuitos. As baterias também são
dispositivos que armazenam carga e para essas atividades, será conveniente
pensar em capacitores como baterias pequenas que podem ser carregadas,
descarregadas e recarregadas.
A quantia de carga que o capacitador tende a armazenar, tende a ser medida
em “farads” (F). O farad é um valor muito grande que não é prático para o
uso com esses circuitos Boe-Bot. Os capacitores que você vai usar nesta
atividade são armazenados em frações de milionésimos de farads. Um
milionésimo de farad é chamado de “micro farad”, e é abreviado µF. O
capacitor que você vai usar neste exercício armazena um décimo de
milionésimo de farad. Isso é 0.1 μF.
Medições de capacitância comuns são:
Microfarads: (milionésimos de um farad), abreviado μF 1 μF = 1×10-6 F
Nanofarads: (bilionésimos de um farad), abreviado nF 1 nF = 1×10-9 F
Picofarads:
(trilionésimos de um farad), abreviado pF 1 pF = 1×10-12 F
O 104 de 0.1 μF no caso do capacitador é uma medida ou picofarads (pF).
Neste sistema de rotulagem, 104 é o número 10 com quatro zeros adicionados,
de modo que o condensador é de 100,000 pF, qual é 0.1 μF.
(100,000) × (1 × 10-12) F = (100 × 103) × (1 × 10-12) F
= 100 × 10-9 F
= 0.1 × 10-6 F
= 0.1 μF.
Construindo os Olhos Fotossensíveis
O BASIC Stamp pode utilizar os circuitos da figura 6-9 para medir a
quantidade de luz incidente sobre a base de cada fototransistor. Um
fototransistor vai estar apontando para a frente e para a esquerda, e o outro
vai estar apontando para a frente e para a direita. Ambos irão também
apontar para cima a cerca de 45°. Uma vez que eles estão apontando em
direções diferentes, o BASIC Stamp será capaz de usá-los para determinar se
a luz mais brilhante no Boe-Bot é a da esquerda ou da direita.
 Remova todas as peças do circuito de saída de tensão do
fototransistor da Figura 6- 4, incluindo o fio ligado a um terminal
coletor do fototransistor para Vdd.
 Construa os circuitos mostrados na Figura 6-9.
 Verifique seus circuitos utilizando o esquema de ligações para
garantir que seus fototransistores não estão conectados invertidos.
Use a perna mais curta e o indicadore plano como guias.
Figura 6-9: Esquemas de circuitos analógicos do fototransistor e Diagrama de fiação
Flat Spots,
pins
menores
Flat Spots,
pins
menores
Os exemplos de percurso neste capítulo dependerão dos fototransistores
sendo apontados para cima e para fora, para detectar diferenças de níveis
incidentes de luz de diferentes direções.
 Certifique-se de que os fototransistores estão apontando para cima e
para fora como mostrado na Figura 6-10.
Figura 6-10: Vire os Fototransistores para cima e para fora
Sobre Transferência de Carga e Circuito do Fototransistor
Cada circuito de fototransitor/capacitor é chamado
circuito de
“transferência de carga”. O BASIC Stamp vai medir a velocidade com que
cada capacitor perde sua carga através de seu fototransistor medindo o
tempo que leva a tensão do capacitor para decair. O tempo de decaimento
corresponde ao brilho da luz incidente sobre a base do fototransistor.
Decaimento mais rápido significa mais luz, mais lento significa menos luz.
Circuito QT: A abreviatura comum para transferência de carga é QT. A letra
Q refere-se a carga elétrica (um acúmulo de elétrons), e T é para transferência.
Pense nos circuitos capacitores da Figura 6-11 como pequenas baterias
recarregáveis, e nos fototransitores como válvulas controláveis de corrente
de luz. Cada capacitador pode ser carregado a 5 V e depois deixa-se escoar
através do fototransistor. A velocidade que o capacitador perde a carga
depende da quantidade de corrente que o fototransistor (válvula de corrente)
permite a passagem, o qual por sua vez depende da luminosidade do brilho
de luz na base do fototransistor. Novamente, luz mais brilhante resulta em
mais
corrente,
e
sombra
em
menos
corrente.
Conectados em Paralelo
O fototransistor e o capacitor, mostrados na Figura 6-11, estão ligados "em
paralelo". Para que dois componentes sejam ligados em paralelo, cada um dos
seus condutores deve ser ligado aos terminais comuns (também chamado de
"nodes"). O fototransistor e o capacitor, cada um deles tem um fio ligado ao
VSS. Além disso, cada um tem um fio condutor ligado a mesmo perna do
resistor de 1 kΩ. Então, eles estão ligados em paralelo.
Figura 6-11
Circuito QT conectado ao
I/O Pin P6
O BASIC Stamp executa estes passos para medir o nível de luz com o
circuito de transferência de carga do fototransistor na Figura 6- 11:
1. Use o comando HIGH para aplicar 5 V no circuito e carregar o
capacitor (bateria minúscula).
2. Use o comando PAUSE para esperar o capacitor carregar.
3. Use o comando RCTIME para definir o I/O pin de entrada e medir o
tempo que leva para a tensão do capacitor decair para 1,4 V, uma vez
que perde a carga através do fototransistor.
A medição do tempo de decaimento maior na etapa 3 significa menos luz,
um tempo de decaimento curto significa mais luz.
O comando RCTIME muda a direção Pin da saída para a entrada e, em
seguida, aguarda o estado do pino de I / O para mudar, é o que acontece
quando a tensão do circuito aplica-se ao pin e passa a 1.4 V limiar da lógica.
O comando RCTIME armazena o resultado da medição em tempo variável.
Com o BASIC Stamp 2, o resultado é um número de incrementos de 2 μs.
RCTIME Pin, State, Variable
Se o argumento STATE é definido como 1, RCTIME vai esperar por ele para
mudar para 0, indicando que a tensão decaiu até 1,4 V. Se o STATE é
definido como 0, RCTIME irá aguardar a tensão subir para 1,4 V. Em ambos
os casos, o comando armazena o resultado da medição em vez do argumento
variável, que é tipicamente uma palavra variável.
Quando o comando RCTIME altera a direcção do pino de saída para a
entrada, ele interrompe a carga do capacitador e se torna invisível ao circuito.
Assim que isso acontecer, a carga do capacitor começa a ir para o
fototransistor. Como uma entrada, o pino de I / O pode sentir se a voltagem do
circuito está acima ou abaixo de 1,4 V.
O RC em RCTIME significa resistor-capacitor, e o uso mais comum do
comando RCTIME é com sensores que variam de acordo com resistência ou
capacitância. Para um exemplo de como usar este comando para medir a
posição de um mostrador que controla a resistência, consulte O que é um
microcontrolador?, Capítulo 5. É um download gratuito a partir
www.parallax.com/go/WAM.
Teste o Circuito do Fototransistor
O programa de exemplo TestP6LightSense.bs2 realiza as três etapas no
circuito QT ligados a P6 na Figura 6 – 11 e exibe uma medida do tempo que
representa o nível da luz incidente no terminal base do fototransistor. O
circuito de QT P6 é ligado ao sensor de luz do lado esquerdo do Boe-Bot, e
o DEBUG Terminal irá apresentar o tempo de decaimento como tLeft, que
é o nome da variável que armazena o resultado e abreviatura de tempo
esquerdo. O valor que nele exibe é o tempo de decaimento, medido em 2 µs
incrementos de tempo. Este valor vai diminuir com a luz mais brilhante e vai
aumentar com luz menos brilhante, como na Figura 6-12.
Figura 6-12: Dois níveis diferentes de luz medidos pelo sensor de luz esquerdo do robô
Boe-Bot
Iluminação interna normal
Sombra sobre sensor
Está o tLeft preso entre 0 ou 1? 0 pode significar que está muito escuro e 1
pode significar que está muito claro. Ambos podem indicar erros de fiação, por
isso, verifique seus circuitos também.
 Estes circuitos sensores são projetados para a iluminação interna.
Certifique-se que nenhuma luz direta do sol está entrando através das
janelas. Se estiver, feche as cortinas.
 Coloque e execute o programa TestP6LightSense.bs2.
 Anote os valores exibidos no DEBUG Terminal.
 Use sua mão ou um livro para lançar uma sombra sobre o
fototransistor no circuito conectado a P6.
 Verifique a medição no DEBUG Terminal novamente. O valor deve
ser maior do que o primeiro. Anote isso também.
Mova o objeto que faz a sombra mais perto do topo do fototransistor.
Tente fazer com que a sombra fique duas vezes mais escura que a
primeira. Anote a medição.
 Experimente com sombras progressivamente mais escuras, mesmo se
for colocando a mão sobre o fototransistor. (Se o nível de luz tornarse suficientemente baixo, o comando RCTIME pode exceder o seu
valor máximo de resultado de 65535, em cujo caso, o comando irá
armazenar um 0 no tLeft variável, e o DEBUG Terminal irá exibir
"tLeft = 00000").
' Robótica com o Boe-Bot - TestP6LightSense.bs2
' Testando o circuito do fotoresistor esquerdo do Boe-Bot.
' {$STAMP BS2}
' {$PBASIC 2.5}
tLeft
VAR
Word
' Armazena o tempo de decaimento do sensor esquerdo
PAUSE 1000
' Espera 1 s antes de um DEBUG
DO
' Loop principal
HIGH 6
PAUSE 1
RCTIME 6, 1, tLeft
' 1 Começa a carregar
' 2 Espera o capacitor ser carregado
' 3 Mede o tempo de decaimento
DEBUG HOME, "tLeft = ", DEC5 tLeft
PAUSE 100
LOOP
' Exibe resultados
' Espera 0.1 segundo
' Repete o loop principal
Sua Vez – Teste o Outro Circuito Fototransistor
O outro circuito do fototransistor do Boe-Bot está conectado a P3. Antes de
modificar seu programa para testar o outro circuito, será melhor salvar o
programa que está funcionando como ele está.
 Salve
TestP6LightSense.bs2, e então salve uma cópia do
TestP3LightSense.bs2.
 Mude o argumento do Pin de 6 para 3 nos comandos HIGH e
RCTIME.
 Mude o nome das variáveis de tLeft para tRight na declaração
VAR, e os comandos de RCTIME e DEBUG.
 Teste e corrija eventuais erros de digitação ou outros erros.
 Atualize os comentários no início do programa.
 Salve o programa modificado e, em seguida, execute-o.
Também seria bom ter um terceiro programa que testa os circuitos
fototransistores. Como antes, salve um dos programas de trabalho e, em
seguida, salve uma cópia do mesmo sob um novo nome, como talvez
TestP6P3LightSense.bs2. Este programa vai precisar de duas declarações de
variáveis, e dois conjuntos de comandos de HIGH-PAUSE-RCTIME em seu
loop principal. Os comandos DEBUG podem ser condensados em um só.
Poderia ser algo como isto:
DEBUG HOME, "tLeft = ", DEC5 tLeft, " ", "tRight = ", DEC5 tRight
 Tente TestP6P3LightSense.bs2. Está em LightSensorExamples.zip,
no site www.parallax.com/go/Boe-Bot. Você pode fazer o download
gratuito.
 Veja se você pode girar o Boe-Bot e deixá-lo detectar qual lado está
apontando para a direção de fonte de luz mais brilhante no quarto
(menor valor) e de que lado está apontando para longe dele (maior
valor).
Tópico Avançado Opcional: Gráficos do Decaimento da Voltagem
A Figura 6-13 mostra as respostas dos circuitos de voltagem QT, tanto
direito quanto esquerdo, enquanto o programa TestP6P3LightSense.bs2 está
sendo executado. O dispositivo que mede e representa por meio de um
gráfico e mostra essas respostas de tensão ao longo do tempo é chamado de
“osciloscópio”. As duas linhas do gráfico que mostram os dois sinais de
tensão são chamados de “traços”. A escala de tensão para o traço superior é
ao longo do lado esquerdo, e a escala de tensão para o traço inferior é ao
longo do lado direito. A escala de tempo para ambas as marcas é na parte
inferior. As etiquetas mostram quando cada comando em
TestP6P3LightSense.bs2 é executado, de modo que você pode ver como os
sinais de tensão respondem.
Figura 6-13: Gráfico do Osciloscópio de tempo de decaimento
HIGH 6
RCTIME 6, 1, tLeft
PAUSE 1
tLeft
≈5V
1.4 V
0V
PAUSE 1
HIGH 3
tRight
RCTIME 3, 1, tRight
≈5V
1.4 V
0V
O traço superior na Figura 6-13 mostra o capacitador de voltagem no
circuito QT ligado a P6, que é o circuito sensor de luz esquerda do Boe-Bot.
Em resposta à HIGH 6, a tensão sobe de 0 V a quase 5 V entre cerca de 0,5
ms e 1 ms. O sinal permanece em cerca de 5 V, para o período de PAUSE 1.
Então, RCTIME causou uma queda para começar em 2 ms dentro do gráfico.
O comando RCTIME mede o tempo que leva a tensão a decair para 1,4 V e
armazena-o na variável tLeft. No gráfico, parece que a queda levou cerca
de 1,5 ms, então a variável tLeft deve armazenar algo em torno de750
desde 750 × 2 μs = 1.5 ms.
O traço menor na Figura 6-13 mostra outro capacitor de tensão do circuito
QT sensor de voltagem P3 está no lado direito do Boe-Bot. Esta medição é
iniciada após a medição do lado esquerdo P6 for feita. A tensão varia de
forma semelhante ao traço superior, exceto o tempo de queda que leva um
pouco mais, cerca de 5 ms, e nós esperaríamos ver tRight armazenar um
valor próximo a 2500.,
Tire suas próprias medições do osciloscópio. Você pode medir e aprender
mais sobre todos os sinais neste capítulo e os sinais de Entendimento com o
livro
PropScope
e
kit.
Para
saber
mais,
acesse
www.parallax.com/go/PropScope.
ATIVIDADE #3: AJUSTANDO A SENSIBILIDADE À LUZ
Se estas medições de luz RCTIME vão ser usadas enquanto o Boe-Bot está
vagando, elas vão ter que dividir o tempo de processamento do BASIC
Stamp PULSOUT com os comandos para controle de servo. Há uma janela de
tempo de 20 ms entre cada par de comandos PULSOUT para comandos
RCTIME. Embora 25 ou 30 ms entre os pulsos do servo não possa causar
problemas visíveis, os atrasos maiores que 50 ms farão com que os servos
apenas se mexam periodicamente em vez de girar.
Um par de medições do fototransistor em uma área muito escura pode medir
50.000 cada. Para ambas as medidas, seria 100,000 × 2 μs = 400 ms. Em
todos os servos do Boe-Bot esse atraso entre os pulsos de controle do servo
faria com que ele se contorcesse a cada 0,4 segundos.
Nesta atividade, você vai experimentar uma técnica que pode ser usada para
reduzir medidas de tempo de queda em salas escuras. Você também vai
testar os efeitos de luz reduzida no desempenho do servo usando ambas as
técnicas de medição.
Corrigir o Problema Carregando o Capacitor a Uma Tensão Mais
Baixa, com PWM
Como pode um programa fazer as medições levarem menos tempo? Ao
carregar os capacitores para tensões mais baixas antes de iniciar as medições
de queda, o programa pode reduzir o tempo das quedas e poderá demorar
mais para chegar a 1,4 V. A linguagem PBASIC tem um comando chamado
PWM que você pode usar para fazer o BASIC Stamp definir a tensão de
partida em todo capacitor para um valor inferior. Esse comando oferece 256
níveis de tensão para escolher numa variação de 0-4,98 V. Sintaxe do
comando PWM é:
PWM Pin, Duty, Duration
O comando PWM aplica uma sequência rápida de sinais de alta / baixa para o
Pin I/O para um determinado período de tempo em ms. O Duty é o número
de 256ª vez em que o sinal é elevado, e que determina o número da 256ª de 5
V, que o capacitor fica é carregado. Por exemplo, o comando PWM 6, 128,
1 envia uma rápida seqüência de sinais de alta / baixa para 1 ms. Eles são
altos na 128/256ª vez que é a metade do tempo. Então, ele carrega o
capacitor na 128/256ª de 5 V. Isso é metade de 5 V, que é de 2,5 V.
PWM significa Modulação por Largura de Pulso. No Capítulo 2, você
estudou modulação por largura de pulso para o controle servo usando
PULSOUT. O comando PWM faz com que o BASIC Stamp crie uma outra
forma de modulação de largura de pulso. Este sinal é uma sequência mais
rápida de impulsos que é especialmente útil para a criação de tensão através de
um capacitor de uma resistência. A proporção de hora de tempo de ciclo (alto
+ baixo tempo) é o que controla a tensão do capacitor, e é chamado de "ciclo".
Argumento Duty do comando PWM controla o ciclo de trabalho do sinal
PWM.
Dado um comando PWM, é possível calcular a tensão que se estabelece
através do capacitor o Vcap, multiplicando 5 V vezes para o argumento
Duty, em seguida, dividir por 256:
Vcap = 5 V × Duty ÷ 256
Aqui estão dois exemplos:
PWM 6, 128, 1
PWM 6, 96, 1
' 5 V × 128 ÷ 256 = 2.5 V.
' 5 V × 96 ÷ 256 = 1.875 V.
Vamos dizer que você quer saber qual o valor que Duty deve ser usado para
uma tensão particular. Basta dividir ambos os lados da equação por 5 V, e
multiplicar os dois lados por 256, e o resultado é:
Duty = Vcap × 256 ÷ 5 V
Um valor útil de Duty pode ser Vcap = 1.4 V. Valores abaixo
poderiam ser bons para a medida de voltagem de queda de tempo.
não
Duty = 1.4 V × 256 ÷ 5 V = 71.68
Então, o valor de 72 seria um argumento menor e útil de Duty em PWM 6,
72, 1.
Por que o argumento Duração do comando PWM sempre é 1 nesses
exemplos?
Porque 1 ms é o tempo suficiente para carregar um capacitor de 0.1 μF através
de um resitor de 1 kΩ. A regra geral é que você precisa de pelo menos 5 × R ×
C segundos para carregar um capacitor. Com um resistor de 1 kΩ e um
capacitor de 0.1 μF, o mínimo seria 5 × 1000 × 0,0000001 = 0,0005 s = 0,5 ms.
Assim, um tempo de 1 ms de carga é mais do que suficiente.
Se o resistor ou capacitor eram maiores, o argumento Duration do comando
PWM pode ter que ser maior. Por exemplo se um capacitor 1 μF for usado, o
argumento Duration teria de ser de pelo menos 5 por 5 ms de tempo de
carga porque R × 5 × 5 × C = 1,000 × 0,000001 = 0,005 s = 5 ms. R × C é
chamado de “constante de tempo RC”, e é muitas vezes abreviado com a letra
grega tau (τ).
Vamos começar a reduzir os tempos de queda pela metade dos valores
medidos na atividade anterior. Na prática, o programa terá de reduzir mais
para navegar em níveis mais baixos de luz, mas isso mostra o primeiro passo
para chegar lá. Para reduzir o tempo de decaimento pela metade, você terá
que usar o comando PWM para carregar os capacitores a meio caminho
entre 1,4 V e 5 V. Isso corresponde a um PWM Duty valor a meio caminho
entre 72 e 256, que é (72 + 256 ) ÷ 2 = 184. Assim, você pode substituir
HIGH 6 and PAUSE 1 with PWM 6, 184, 1 para reduzir o tempo de
queda para metade dos valores. Uma outra maneira para reduzir o tempo de
queda sobre isso é quando são usados os comandos PWM para fazer com que
metade dos sensores fiquem sensíveis a luz porque a queda na medição de
tempo vai levar a metade do tempo para metade dos valores medidos.
 Coloque, salve e execute o programa HalfLightSensitivity.bs2
 Tente se certificar se a luz ambiente é bastante próxima do mesmo
nível em que estava na atividade anterior.
 Verifique se as medições de luz são cerca de metade do que elas
estavam com TestP6LightSense.bs2 da atividade anterior. Precisão
não é importante aqui. Não se preocupe se suas medidas não estão
tão exatas quanto estavam; em geral uma aproximação da metade é
suficiente.
 Tente mudar o argumento de comando Duty para 128 e verifique que
a medida está agora próxima a um quarto dos valores de
TestP6LightSense.bs2. Novamente não se preocupe em ser preciso.
' Robótica com o Boe-Bot - HalfLightSensitivity.bs2
' Testando os circuitos do fotoresistor com comando que diminui a
' sensibilidade do fototransistor pela metade com comando PWM.
' {$STAMP BS2}
' {$PBASIC 2.5}
tLeft
tRight
VAR
VAR
Word
Word
' Armazena o tempo de decaimento do sensor esquerdo
' Armazena o tempo de decaimento do sensor direito
PAUSE 1000
' Espera de 1 s antes do DEBUG
DO
' Loop principal
PWM 6, 184, 1
RCTIME 6, 1,tLeft
' Carrega capacitor com 3.59 V
' Mede o tempo de decaimento
PWM 3, 184, 1
RCTIME 3, 1,tRight
' Carrega capacitor com 3.59 V
' Mede o tempo de decaimento
DEBUG HOME, "tLeft = ", DEC5 tLeft, CR, ' Mostra os resultados
"tRight = ", DEC5 tRight
PAUSE 100
' Espera 0.1 segundos
LOOP
Um Sensor de Luz, Duas Medidas Diferentes
O programa HighVsPwmInRctime.bs2 demonstra como as medições da
queda para o sensor levam menos tempo quando PWM carrega-o com um
valor inferior.
 Coloque e execute o programa HighVsPwmInRctime.bs2, e observe
as duas medidas do mesmo nível de luz no DEBUG Terminal.
 Tente variar o nível de luz. A medição tRight2 deve sempre ser
significativamente menor do que tRight1.
' Robótica com o Boe-Bot - HighVsPwmInRctime.bs2
' Duas medições de decaimento seguidas. A primeira usa abordagem HIGH, PAUSE,
' RCTIME e a segunda carrega o capacitor com 2.5V com PWM antes de RCTIME.
' {$STAMP BS2}
' {$PBASIC 2.5}
tRight1
tRight2
VAR
VAR
Word
Word
' Primeiro tempo de decaimento do sensor direito
' Segundo tempo de decaimento do sensor direito
PAUSE 1000
' Espera 1 s antes de um DEBUG
DO
' Loop principal
HIGH 3
PAUSE 1
RCTIME 3, 1, tRight1
' 1 P3 HIGH para começar a carregar
' 2 Espera o capacitor carregar
' 3 P3->entrada, mede o tempo de decaimento
PAUSE 1
' Medições separadas por 1 ms
PWM 3, 128, 1
' Carrega capacitor P3 com 2.5V
RCTIME 3, 1,tRight2
' P3->entrada, mede o tempo de decaimento
DEBUG HOME, "tRight1 = ", DEC5 tright1,
CR, "tRight2 = ", DEC5 tRight2
PAUSE 100
LOOP
' Exibe resultados
A Figura 6-14 mostra ambos um DEBUG Terminal e uma medição do
osciloscópio de duas quedas de HighVsPwmInRctime.bs2. No traço do
osciloscópio, a primeira queda começa a partir de 5 V devido à elevada
HIGH 3 e PAUSE 1 antes RCTIME 3, 1, tRight1. A segunda parte de
queda de 2,5 V por causa do PWM 3, 128, 1, antes RCTIME 3, 1,
tRight2.
Figura 6-14: Terminal de depuração e osciloscópio Visualizações de
HighVsPwmInRctime.bs2
tRight1 = 1345
tRight2 = 264
≈5V
≈ 2.5 V
1.4 V
0V
Por que é tRight2 é mais parecido 1/5 de tRight1? Não deveria ser 1/4? Na
primeira queda, o pino de I/O tem saída HIGH correta até o momento
RCTIME mudar para entrada. Na segunda queda, PWM muda o pino de I / O
para entrada quando isso for feito, haverá um pequeno atraso entre o fim do
comando PWM e o início do comando RCTIME. A voltagem começa a decair
no fim do comando de PWM, por isso, é um pouco inferior a 2,5 V quando a
RCTIME começa a medir o tempo de queda.
Esta redução no valor da medição pode ser corrigida com alguns testes, mas
não importa, porque ele vai ser o mesmo para ambos os sensores esquerdo e
direito. Quando os programas Boe-Bot compararem os dois valores do sensor
para determinar qual é o lado mais claro ou mais escuro, ambas as medições
serão menores por uma quantidade pequena, fixa. Assim, se um sensor detecta
menos luz do que o outro, sua medida ainda vai ser maior, e isso é o que o
programa precisa para decisões de navegação.
Sua Vez – Teste de Medição do Tempo de Impacto do Controle do
Servo
Você pode adicionar um par de comandos PULSOUT que fazem o Boe-Bot ir
a toda velocidade para a frente para testar o efeito do tempo de medição no
controle de servo. O primeiro passo seria um teste para descobrir o quão
baixo o nível de luz tem que começar antes que os servos parem de
funcionar corretamente com a abordagem de HIGH-PAUSE-RCTIME. Em
seguida, use os comandos PWM no lugar de alta e de pausa, com um Duty de
80, e teste para descobrir o quanto mais escuro ele pode chegar antes do
servo parar de funcionar corretamente.
 Execute o programa TestMaxDarkWithHighPause.bs2.
 Aumentar gradualmente a sombra até que os servos comecem a se
mexer. (Uma caixa de sapatos servirá bem para isso.)
 Repita com TestMaxDarkWithPwm.bs2.Os servos deverão começar
a contrair-se, em algum momento, mas devem estar mais escuros
antes que aconteça.
Figura 6-15 O programa à direta deve permitir que os servos funcionem na luz baixa
' TestMaxDarkWithHighPause.bs2
' TestMaxDarkWithPwm.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
' {$STAMP BS2}
' {$PBASIC 2.5}
tLeft
tRight
tLeft
tRight
VAR
VAR
Word
Word
VAR
VAR
Word
Word
PPAUSE 1000
DDEBUG "Programa funcionando... "
PAUSE 1000
DEBUG "Programa funcionando... "
DDO
DO
HIGH 6
PAUSE 1
RCTIME 6, 1,tLeft
HIGH 3
PAUSE 1
RCTIME 3, 1,tRight
PULSOUT 13, 850
PULSOUT 12, 650
PWM 6, 80, 1
RCTIME 6, 1,tLeft
PWM 3, 80, 1
RCTIME 3, 1,tRight
PULSOUT 13, 850
PULSOUT 12, 650
LOOP
LOOP
ATIVIDADE #4: MEDINDO A LUZ PARA ANDAR
Esta atividade apresenta um programa que se ajusta automaticamente às
condições de luz uma sala e fornece informações sobre:
•
•
•
Como está o brilho na sala
Qual dos dois sensores de luz vê mais sombra
Quão forte é o contraste claro/escuro entre os dois sensores
O Boe-Bot será capaz de usar essa informação para tarefas como navegar em
direção ou longe da luz.
O primeiro programa de exemplo parece ser bem longo, mas não se
preocupe.
Você irá fazer um download a partir www.parallax.com/go/Boe-Bot.
Teste o Programa LightSensorValues.bs2
LightSensorValues.bs2 utiliza várias sub-rotinas que condensam as
medições de luz em dois valores: light, e ndShade. A variável light
armazena o nível de luz ambiente detectada pelo Boe-Bot. A variável
ndShade armazena uma medição sombra normalizada, diferenciada.
"Normalizada", significa que as medições foram ajustadas a uma certa
escala, de -500 a 500, no caso de ndShade. "Diferencial" significa que o
número corresponde a uma diferença entre as duas medições do sensor. No
caso de ndShade, o valor indica a diferença entre o nível de cor que cada
sensor
detecta.
A variável de luz do programa é útil para detectar os níveis de luz em geral.
Escala da variável é 1-324, sendo 1 o estado mais escuro que o sistema pode
medir e reportar e 324 sendo o mais brilhante. Esta medida é útil se uma
meta ou ponto de passagem em uma competição de navegação envolve a
detecção quando o robô passa sob uma luz brilhante. Nessa situação, a
variável de luz pode armazenar um valor maior do que em outras partes do
curso do robô, e o programa poderia usar um IF ... THEN para detectar
essa
condição
e
tomar
uma
atitude.
A variável de programa ndShade indica a quantidade de mais sombra, um
sensor detecta a luz sobre o outro. Escala da variável é -500 (sombra muito
escura à esquerda) a 500 (sombra muito escura à direita). Se o valor da
ndShade é 0, isso significa que os níveis de luz são praticamente os mesmos
em ambos os fototransistores. A medição pode ser útil para o código que faz
com que o Boe-Bot vague para perto ou para longe de fontes de luz. Por
exemplo, para fazer o Boe-Bot andar em direção à luz, uma simples rotina
tem que fazer o Boe-Bot se afastar e detectar sombra de um lado ou do
outro.
A Figura 6-16 mostra exemplos de duas condições de luz/sombra diferentes
medidas com LightSensorsValues.bs2. O DEBUG Terminal da esquerda é
um exemplo do Boe-Bot de frente com a principal fonte de luz em uma sala.
Os relatórios de variáveis de luz 230/324, estão na faixa normal de
iluminação interna. Os relatórios ndShade variável 0, significam que ambos
os fototransistores detectam os níveis de luz que estão muito próximos uns
dos outros. O DEBUG Terminal no lado direito da figura mostra uma
medição com uma sombra sobre o sensor de luz a esquerda. O valor de
ndShade é -279, que indica sombra sobre o sensor esquerdo, e o valor de luz
caiu porque sombra sobre um sensor também reduziu a medição da luz total.
Figura 6-16: Exemplo de testes de sombra com LightSeekingDisplay.bs2
Diante de uma Fonte de Luz
Sombra sobre sensor de luz a esquerda do
Boe-Bot
 Download LightSensorExamples.zip de www.parallax.com/go/Boe




Bot.
Verifique se não há luz solar direta entrando pelas janelas.
Iluminação interna é boa, mas a luz solar direta cegará os sensores.
Descompacte para uma pasta e, em seguida, abra o programa
LightSensorValues.bs2
Abra o programa com o seu BASIC Stamp Editor e carregue-o para o
BASIC Stamp.
Para melhores resultados, ajustar a iluminação ambiente na sala para
que a variável de luz esteja na faixa de 125-275 sem sombra sobre os
sensores.
Verifique se quando você lançar sombra sobre o sensor esquerdo do
Boe-Bot, resulta em valores negativos, com o tom mais escuro,
resultando em valores negativos maiores
 Verifique se quando você lançar sombra sobre o sensor direito do
Boe-Bot, resulta em valores positivos, com tonalidade mais escura,
resultando em valores positivos maiores.
 Verifique se quando ambos os sensores estiverem sobre o mesmo
nível de luz ou sombra, que os relatórios de valores ndShade estejam
próximos a 0.
 Verifique se as gotas das variáveis de luz aumentaram na sombra e
subiram com mais luz.
'----- [Título] ----------------------------------------- ------------------' Robótica com o Boe-Bot - LightSensorValues.bs2
' Exibe o nível de luz ambiente e sombra diferencial em uma escala de -500 a
' 500.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
'-----[ Constantes/Variáveis ]----------------------------------------------Negative
CON
1
' Para números negativos
' Application Variables
light
VAR
Word
ndShade
VAR
Word
' Indicador de brilho/escuridão
' Sombra diferencial normalizada
' Sub-Rotina Variables
tLeft
VAR
Word
tRight
VAR
Word
n
VAR
Word
d
VAR
Word
q
VAR
Word
sumDiff
VAR
Word
duty
VAR
Byte
i
VAR
Nib
temp
VAR
Nib
sign
VAR
Bit
'
'
'
'
'
'
'
'
'
'
Armazena as medidas da esquerda de RCTIME
Armazena as medidas da direita de RCTIME
Numerador
Denominador
Quociente
Para soma e diferenca de cálculos
PWM duty argument da variável
Variável de contagem Index
Armazenamento temporário para cálculo
Var.BIT15 = 1 if neg, 0 if pos
'-----[ Inicializacão ]-----------------------------------------------------FREQOUT 4, 2000, 3000
DEBUG CLS
' Começa bip
' Limpa o DEBUG Terminal
'-----[ Rotina Principal ]--------------------------------------------------DO
GOSUB Light_Shade_Info
' Loop principal
' Obtém light & ndShade
DEBUG HOME, "light = ", DEC3 light,
"/324", CLREOL, CR,
"ndShade = ", SDEC3 ndShade, CLREOL
PAUSE 100
LOOP
' Exibe light & ndShade
' Atrasa 0.1 seconds
'-----[ Sub-Rotina - Light_Shade_Info ]-------------------------------------' Use tLeft and tRight (RCTIME medição) e pwm var para calcular:
' o light - Ambiente light level na escale de 0 para 324
' o ndShade - Normalizar differencial de sombra numa escala de -500 para +500
'
(-500 -> Sombra escura sobre a esquerda, 0 -> igual sombra
'
+500 -> sombra escura sobre a direita)
Light_Shade_Info:
'
GOSUB Light_Sensors
'
sumdiff = (tLeft + tRight) MAX 65535
IF duty <= 70 THEN
'
light=duty-(sumdiff/905) MIN 1
'
IF sumdiff = 0 THEN light = 0
'
ELSEIF duty = 255 THEN
'
light=duty+((1800-(sumdiff))/26)
'
ELSE
'
light = duty
'
ENDIF
'
GOSUB Duty_Auto_Adjust
'
n = tLeft
'
d = tLeft + tRight
GOSUB Fraction_Thousandths
'
ndShade = 500-q
'
RETURN
'
Sub-rotina de etiqueta
Obtem material RC light medidas
' começar o level de luz com soma
Se duty com o min
Achar o quanto escuro está
se o tempo de espera, max escuridão
Se duty acom o max
ache o quanto mais brilhante
Se duty na faixa
light = duty
Feito o lvel de luz
Ajuste PWM duty para o proximo loop
Estabelecer tLeft/(tLeft+tRight)
Divide (retorna milésimos)
Normalizar o differencial de sombra
Retorne para o Sub-Rotina
'-----[ Sub-Rotina - Light_Sensors ]----------------------------------------' Measure P6 and P3 light sensor circuits. Duty variable precisa estar em
70...255.
' Armazenar resultados in tLeft and tRight.
Light_Sensors:
PWM 6, duty, 1
RCTIME 6, 1, tLeft
PWM 3, duty, 1
RCTIME 3, 1, tRight
RETURN
'
'
'
'
'
'
Subrotina de etiqueta
Carga cap em P6 circuito
Meça decadência P6
meça cap em P3 circuito
Medir a queda
Retorne para subrotine
'-----[ Sub-Rotina - Duty_Auto_Ajuste ]-------------------------------------' Adjust duty variable to keep tLeft + tRight in the 1800 to 2200 range.
' Requires sumdiff word variable for calculations.
Duty_Auto_Adjust:
' Subrotine de etiquetal
sumDiff = (tLeft + tRight) MAX 4000 ' Limite max valor em ambiente
IF sumDiff = 0 THEN sumDiff = 4000 ' Se 0 (tempo limite) então 4000
IF (sumDiff<=1800) OR (sumDiff>=2200) THEN ' Se fora 1800 para 2200
sumDiff = 2000 - sumDiff
' Ache a excursão para o alvo val
sign = sumDiff.BIT15
' Pos/neg se .BIT15 = 0/1
sumDiff = ABS(sumDiff) / 10
' Max sumDiff will be +/- 10
sumDiff = sumDiff MAX ((duty-68)/2)
' Reduza os incrementos de ajuste
sumDiff = sumDiff MAX ((257-duty)/2) ' perto das extremidades do intervalo
IF sign=NEGATIVE THEN sumDiff=-sumDiff
' Restaurar a assinatura
duty = duty + sumDiff MIN 70 MAX 255
' Limite duty de 70 para 255
ENDIF
' fim de fora 1800 para 2200
RETURN
' Retorne ao Sub-Rotina
'-----[ Sub-rotina - Milésimos Fração]----------------------------------' Calcular q = n/d como um número de milésimos.
' n and d deve ser assinado e n <d. Requer tamanho Nib temperatura & i
variáveis..
Fraction_Thousandths:
' selo de subrotina
q = 0
' Limpar o quociente
IF n > 6500 THEN
' Se n > 6500
temp = n / 6500
' escala n em 0..6500
n = n / temp
d = d / temp
' escale d com n
ENDIF
FOR i = 0 TO 3
' Divisão longa milésimos
n = n // d * 10
' Multiplique restante em 10
q = q * 10 + (n/d)
' Adicione próximo dígito quociente
NEXT
IF q//10>=5 THEN q=q/10+1 ELSE q=q/10
' Rodada o mais próximo de milésima
RETURN
' Retorne para Sub-Rotina
Opcional: Como o Programa LightSensorValues.bs2 Funciona
O circuito fototransistor e as medidas RCTIME representam dois problemas
para a navegação Boe-Bot. Primeiro, uma medida RCTIME para uma sombra
em um ambiente mais escuro será um valor maior do que o mesmo objeto
lançando a mesma sombra em uma sala brilhante. Em segundo lugar, em
salas escuras, as medições RCTIME podem acabar levando muito mais tempo
do que os 20 ms de tempo livre, que um programa tem entre os pulsos do
servo.
A rotina principal em LightSensorValues.bs2 não tem que se preocupar com
qualquer um desses problemas, porque a rotina Light_Shade_Info
resolve-os. A rotina principal apenas faz uma única chamada para a sub-
rotina Light_Shade_Info, e depois verifica se os valores das variáveis de
luz e ndShade de dois valores são necessários para a navegação de um par
de sensores de luz. Novamente, a variável de luz indica o nível de luz global
numa escala de 0-324, e a variável ndShade indica a luz / sombra e a
diferença entre os sensores, numa escala de -500 a 500.
Mais detalhes sobre as sub-rotinas: Esta seção só se concentra sobre o que as
sub-rotinas fazem, não como elas fazem isso. Algumas atividades mais
avançadas que contam o desenvolvimento de sub-rotinas estão disponíveis
para download a partir www.parallax.com/go/Boe-Bot. Procure a seção
Advanced Light Sensing.
Light_Shade_Info sub-rotina começa sendo chamada de
Light_Sensors sub-rotina para obter as variáveis tLeft and tRight que
armazenam as medidas. Observe que os comandos na rotina PWM na
Light_Sensors contam com uma variável duty nomeada para definir sua
A
sensibilidade, que por sua vez controla quanto tempo os comandos
demoraram para chegar nas suas medições de luz. O programa tem uma subrotina chamada Duty_Auto_Adjust que ajusta automaticamente a variável
duty e ajuda a prevenir que salas que são muito escuras desativem os servos
do Boe-Bot e salas que são brilhantes ceguem os sensores de luz.
chamar a sub-rotina Light_Sensors, a rotina
Light_Shade_Info faz alguns cáculos em tLeft, tRight e a variável
duty calcula o valor da variável de luz, que por sua vez indica o nível de luz
em geral. Em seguida, chama a sub-rotina Duty_Auto_Adjust, que ajusta a
variável de duty para tentar manter a soma das medições RCTIME na gama
1800-2200. Salas muito escuras ainda farão com que os servos façam as
rodas apenas se mexam em vez de virar, e a luz direta do sol ainda vai cegar
o Boe-Bot, mas Duty_Auto_Adjust estende significativamente a gama de
condições de luz que o Bot Boe pode automaticamente ajustar e navegar
dentro.
Depois
de
Em seguida, a sub-rotina Light_Shade_Info normaliza a diferença entre
os dois sensores, calculando a quantidade total de luz (medida por ambos os
sensores) que um único sensor vê. Ela faz isso resolvendo esta equação:


tLeft

ndShade = 500 − 1000 ×
+
tLeft
tRight


Esta equação resolve o problema de sombra tendo valores diferentes em
ambientes com diferentes níveis de luz. Ela simplesmente divide uma
medição para a soma de ambas as medições para um resultado fracionado
que pode variar de 0 a 1. Em seguida, multiplica-o por 1000 para um
resultado que pode variar de 0 a 1000. Em seguida subtrai tudo o que é de
500, para o valor da variável ndShade, que varia de -500 a 500.
Digamos que tLeft é de 1500 e tRight é 500. Isso significa que há sombra
sobre sensor de luz a esquerda do Boe-Bot. Se você ligar os valores na
equação, o resultado será 250. Agora, em um ambiente mais escuro, a
mesma condição de sombra pode fazer o tLeft ser 3600 e tRight ser 1200.
Esses valores ainda resultarão em um valor ndShade de 250.
 Use a equação ndShade para calcular os dois pares de valores
discutidos no parágrafo acima.
Você também pode ter notado uma característica nova e diferente na seção
Constantes / Variáveis: negative CON1. Esta é uma declaração constante, e
permite que você use um nome no lugar de um número em seu programa.
Em vez de usar o número 1 em um determinado ponto no programa para
verificar ou para saber se um número é negativo, o programa usa a constante
negativa em seu lugar. Então, lá na sub-rotina Duty_Auto_Adjust, a sigla
IF sign=Negative, THEN sumDiff = -sumDiff verifica se a variável
contém um 1, indicando o valor testado como negativo no início da subrotina. Esta linha ainda pode funcionar se for reescrita IF sign=1 THEN
sumDiff =-sumDiff.
As Constantes podem ser úteis para ajudar os comandos com os números em
si serem mais auto-explicativos, e também são úteis se você tem um número
que é usado em vários lugares em um programa. Ao atualizar uma diretiva
CON, todo o código que usa o nome da constante usará o valor atualizado.
Capítulo 8 irá utilizar este recurso de constantes para calibrar um programa que
faz o Boe-Bot seguir objetos em um determinado intervalo de seus sensores de
infravermelho.
Medição de Luz em Uma Representação Gráfica
A Figura 6-17 mostra um exemplo de uma representação gráfica da variável
ndShade. O asterisco será no centro da escala de -500 a 500, se a luz ou
sombra é a mesma em ambas os sensores. Se a sombra é mais escura ao
longo do sensor esquerdo do Boe-Bot, o asterisco se posicionará à esquerda
na escala. Se ele é mais escuro sobre o direito, o asterisco irá posicionar para
a direita. Um maior contraste de sombra/luz (como sombra escura sobre um
dos sensores) irá resultar no posicionamento do asterisco mais longe do
centro.
Figura 6-17: Display gráfico da variável ndShade
Mesma luz/sombra em ambos os lados
Mais sombra no lado esquerdo
Asterisco indicador no centro da escala
Asterisco indicador a meio caminho entre
o centro e a extremo esquerdo.
Tudo o que você precisa para esta exibição são apenas algumas pequenas
modificações para inicialização LightSensorValues.bs2 e seções de rotina
principal. Abaixo está um exemplo. Ele faz uso de alguns novos
formatadores de depuração, como REP e CRSRX.
O formatador REP repete um caractere determinado número de vezes. Então
DEBUG CLS, REP CR\5 limpa a tela, e em seguida, imprime 5 retornos de
transporte, que envia o cursor para baixo de 5 linhas.
O formatador CRSRX posiciona o cursor a um certo número de espaços à
direita da margem e a esquerda do DEBUG Terminal. Por exemplo, DEBUG
HOME, CRSRX 8 envia o cursor para a posição do caractere superior esquerdo
do DEBUG Terminal, então ele move o cursor oito espaços para a direita.
CLREOL é outro novo formatador que apaga tudo para a direita do cursor em
uma determinada linha. Isto pode ser útil quando você não precisa
necessariamente saber quantos dígitos serão exibidos. Se a medição mostra
menos dígitos do que o anterior, o formatador CLREOL apaga os dígitos
fantasmas que podem ser deixados para a direita.
' Excerpt from LightSensorDisplay.bs2
'-----[ Inicialização ]-----------------------------------------------------FREQOUT 4, 2000, 3000
' Começa Bip
DEBUG CLS, REP CR\5,
"
-+---------+---------+-",
CR, "
-500
500"
' Nível de sombra visualização gráfica
'-----[ Rotina principal ]--------------------------------------------------DO
' Loop principal
'
'
DEBUG HOME, CRSRX, 8, "light = ",
'
DEC3 light, "/324",CR, CR,
'
CRSRX, 13, "ndShade", CR,
'
CRSRX,15, SDEC3 ndShade, CLREOL, CR, '
CLREOL, CRSRX,
'
6+((ndShade+500)/50), "*"
'
Obter light & ndShade
Exibir
Nome da variável light em x=8
Valor da variável de light
shade heading em x=13
Valor de ndShade em x=15
Exibir asterisco de ndShade
x-posição
PAUSE 100
LOOP
 O
programa LightSensorDisplay.bs2 foi outro exemplo em
LightSensorExamples.zip. Abra-o com o BASIC Stamp Editor.
 Se você preferir salvar o programa LightSensorValues.bs2 como
LightSensorDisplay.bs2 e inserir as alterações, certifique-se de
deixar cinco espaços entre as aspas e os primeiros caracteres em cada
escala. Por exemplo, existem 5 espaços entre as aspas e o primeiro
traço em CR, "
-500…
 Lembre-se, para obter melhores resultados, de se certificar de ajustar
a iluminação da área para que o DEBUG Terminal exiba os valores
de luz na faixa de 125-275 sem sombras sobre os fototransistores.
 Execute o programa e tente lançar diferentes níveis de sombreamento
sobre cada sensor de luz, e ver como o asterisco da Figura 6-17
responde. Lembre-se que se você jogar sombra igual sobre os dois
sensores, o asterisco ainda deve estar no meio, ele só indica que o
sensor vê mais sombra se há uma diferença entre eles.
ATIVIDADE #5: ROTINA PARA ANDAR EM DIREÇÃO À LUZ
Uma abordagem para fazer com que o Boe-Bot ande em direção as fontes de
luz é fazê-lo se afastar de sombras. Você ainda pode usar a variável
ndShade para fazer o Boe-Bot virar mais ou menos quando o contraste entre
a luz detectada de cada lado é maior ou menor. Em primeiro lugar,
precisamos de um par de variáveis para armazenar as variáveis de duração
do pulso para os servos.
' Variáveis de Aplicação
pulseLeft
VAR
Word
pulseRight
VAR
Word
Em seguida, precisamos de algum código para definir os valores de pulso. O
código abaixo define pulseLeft e pulseRight para manter a roda sob a
sombra indo a toda velocidade e retardar ou reverter a outra roda. Quando o
contraste entre luz e sombra de medições é pequeno, a roda que não está sob
sombra só retarda um pouco para uma volta gradual. Quando o contraste é
maior, a roda do outro lado da sombra pode diminuir, ou até mesmo
começar a girar para trás para que o Boe-Bot execute uma manobra mais
precisa para sair dessa sombra mais escura.
' Navigation Routine
IF (ndShade + 500) > 500 THEN
pulseLeft = 900 - ndShade MIN 650 MAX 850
pulseRight = 650
ELSE
pulseLeft = 850
pulseRight= 600 - ndShade MIN 650 MAX 850
ENDIF
A rotina que define os valores pulseLeft e pulseRight começa por
decidir se a sombra é mais escura no sensor da direita ou esquerda,
comparando os operadores (ndShade + 500) a 500. O > (maior que), > =
(maior ou igual a), <(inferior), e <= (menor ou igual) que somente
comparam dois números positivos. Desde que o menor ndShade seja -500, o
código da condição IF adiciona 500 a ndShade e depois compara com 500.
É o equivalente a PBASIC IF ndShade> 0.
Digamos que ndShade é de 125, o que significa que definitivamente há
alguma sombra de luz sobre o sensor direito. Se ndShade + 500> 500
THEN verifique então se 625 é superior a 500, e ele é. Figura 6-18 mostra o
que acontece em seguida se o código, desacelera a roda esquerda com
pulseLeft = 900 - ndShade MIN 650 MAX 850, e define a roda direita
a velocidade máxima para a frente com pulseRight = 650. Uma vez que
é de 125 ndShade neste exemplo, 90 - 125 = 775, o que causaria um
comando PULSOUT para diminuir a velocidade da roda esquerda.
Figura 6-18
A reação do
programa
LightSeekingBoeBot.bs2 's para
sobra do lado
direito
Neste exemplo,
uma medição
ndShade de 125
fica subtraído de
900, e o resultado
de 775 diminui a
velocidade do
servo esquerdo.
Se ndShade é maior, talvez 190, significa que a sombra sobre o sensor
direito é mais escura, pulseLeft termina com um valor de 710, o que faria
a roda esquerda girar para trás para uma volta muito mais precisa. Para
valores de ndShade que são maiores do que 250, a expressão de 900 ndShade pode resultar em valores menores do que 650. Do mesmo modo,
para os valores de ndShade entre 1 e 49, a expressão pode resultar em
valores acima de 850. Assim, o código utiliza operadores MIN e MAX para
manter o resultado na gama 650 - 850 embora 900 - ndShade pode ter
resultados intermediários fora desse intervalo.
O operador MIN tem um resultado inferior ao valor indicado e aumenta-o a
esse valor, mas deixa os resultados acima do valor de MIN sozinhos. Então,
se o resultado de 600 - ndShade é qualquer coisa abaixo de 650, o
operador MIN 650 armazena em pulseLeft.
Por exemplo, se ndShade for 350, o resultado intermediário de 900 ndShade seria 550, mas MIN 650, mudaria para 650. Do mesmo modo, o
operador da MAX tem um resultado acima do valor especificado e o diminui
para esse valor, mas deixa resultados abaixo do valor máximo sozinho.
Assim, mesmo que os valores de 0 até 49 intermediassem resultados na faixa
de 900 - ndShade para 851, o MAX 850 parte da expressão que define
qualquer resultado nesse intervalo a 850.
Valores ndShade de zero ou menos, significam que a sombra é sobre o
sensor de esquerda, e a roda direita precisa desacelerar. O código no bloco
ELSE faz com estabelecendo a roda esquerda para velocidade máxima com
pulseLeft = 850 faz com que a roda esquerda do Boe-Bot vá a toda
velocidade para a frente, e pulseRight = 600 - ndShade MIN 650 MAX
850 retarde ou até mesmo reverta a direção da roda direita do Boe-Bot,
dependendo de quão escura é a sombra no sensor de luz esquerdo.
Teste de Rotina de Navegação Com DEBUG Terminal
A Figura 6-19 mostra alguns exemplos de exibição de DEBUG Terminal a
partir do seguinte programa de exemplo, LightSeekingDisplay.bs2.
Instruções de checagem irão aconselhar você a executar o programa
seguinte, mas em primeiro lugar, basta dar uma olhada nas telas do DEBUG
Terminal mostrada na figura.
Estas capturas de tela demonstraram como a rotina de navegação ajusta as
variáveis pulseLeft e pulseRight em resposta a diferentes valores
ndShade. O programa faz com que o DEBUG Terminal exiba uma visão
superior do Boe-Bot com rótulos pulseLeft e pulseRight e seus valores
ao lado de cada roda. O programa também posiciona a esquerda > e direita <
indicadores de velocidade da roda para mostrar o quão rápido e em que
direção cada roda deve girar.
Por exemplo, no DEBUG Terminal superior esquerdo, ambos os indicadores
de velocidade das rodas tem o nível com o rótulo para frente, o que significa
que o Boe-Bot estaria indo a toda velocidade para a frente.
No canto superior direito do DEBUG Terminal, o indicador de velocidade
certo está a meio caminho, entre os rótulos para a frente e para trás, significa
que a roda iria parar.
No cantor inferior esquerdo do DEBUG Terminal, o indicador de velocidade
da roda esquerda está nivelado com o selo inverso, o que significa que a
roda esquerda estaria com a velocidade de rotação máxima no sentido
inverso.
No canto inferior direito, a variável light é menor. Desde que ndShade
esteja perto de zero, o nível de sombra é o mesmo, por isso deve haver
sombra sobre ambos os sensores. Desde que o Boe-Bot só responda às
diferenças de tonalidade, a mesma sombra sobre ambos os sensores significa
que ambas as rodas estariam girando a toda velocidade para a frente
novamente.
Figura 6-19: Exemplos de Sombra e indicador de roda
Igual luz - velocidade máxima para a frente.
Indicador de
velocidade
do lado
esquerdo
Escura sombra a esquerda - desacelerar
roda direita
Indicador de
velocida a direita
Roda direita
parado
Sombra escura sobre a direita - roda inversa
velocidade máxima esquerda.
Esquerda roda inversa
velocidade máxima
Igual sombra - de volta até a velocidade máxima
para a frente.
O programa LightSeekingDisplay.bs2 é outro exemplo do arquivo
LightSensorExamples.zip. Ele se expande em LightSensorDisplay.bs2 com
estas características:
•
•
•
•
•
Declarações de variáveis pulseLeft e pulseRight.
Um comando DEBUG que mostra uma vista superior do Boe-Bot.
O código de bloco IF ... THEN ... ELSE ... ENDIF para
rotina de busca de luz.
Comandos DEBUG que exibem os valores das variáveis pulseLeft e
pulseRight próximas de cada roda.
Comandos DEBUG que posicionam o indicador de velocidade da roda
esquerda > e da roda direita < que exibem a velocidade e direção de
cada roda.
O programa LightSeekingDisplay.bs2 é ótimo para a observação de
variáveis de respostas pulseLeft e pulseRight a sombrear cada sensor e
como esses valores influenciam a velocidade das rodas.
 Abra o programa LightSeekingDisplay.bs2 com o BASIC Stamp
Editor e transfira-o para o BASIC Stamp.
 Mais uma vez, para obter melhores resultados, ajuste a iluminação
ambiente na sala para que o DEBUG Terminal exiba um valor
variável de luz na faixa de 125-275 sem sombra sobre os sensores
 Experimente com mais e menos sombra sobre cada sensor, e preste
muita atenção à forma como isso afeta o valor ndShade, que por sua
vez afeta as variáveis pulseLeft e pulseRight e as velocidades
das rodas definidas se usadas em comandos PULSOUT.
' Excerpts from LightSeekingDisplay.bs2
'
... (três pontos indicam código omitido)
' Aplicação das Variáveis
pulseLeft
VAR
Word
pulseRight
VAR
Word
'
...
' Duração do pulso do servo esquerdo
' Duração do pulso do servo direito
'-----[ Inicialização ]-----------------------------------------------------FREQOUT 4, 2000, 3000
' Começa o bip
DEBUG CLS, REP CR\5,
"
-+---------+---------+-",
' Nível de sombra visualização gráfica
CR, "
-500
500",
CR, "
Boe-Bot
forward",
CR, "
--------",
' Boe-Bot vista de cima com rotulagem de
CR, "
|| |[] ---- | || ",
' pulso
CR, "
|| |[]| -- | | || ",
CR, "pulse ||=| ---- |=|| pulse ",
CR, "Left || | ==== | || Right ",
CR, "
|| ||| ___ | || ",
CR, "
||| |___| |
",
CR, "
|||
|
reverse",
CR, "
---\O/--"
'
0123456789 +10 0123456789 +30 ' Posições do cursor para ajudar se você
'
+0 0123456789 +20 01234567 ' estiver inserindo com o código.
'-----[ Rotina Principal ]--------------------------------------------------DO
' Loop principal
' exibir
DEBUG HOME, CRSRX, 8, "light = ",
' Variável light em x=8
DEC3 light, "/324",CR, CR,
' Valor da variável light
CRSRX, 13, "ndShade", CR,
' shade heading em x = 13
CRSRX,15, SDEC3 ndShade, CLREOL, CR, ' Valor de ndShade em x = 15
CLREOL, CRSRX,
' Exibir asterisco em ndShade
6+((ndShade+500)/50), "*"
' x-posição
' Navigation Routine
'
pulseLeft = 900 - ndShade MIN 650 MAX 850 '
pulseRight = 650
'
'
ELSE
'
pulseLeft = 850
'
'
pulseRight= 600 - ndShade MIN 650 MAX 850 '
ENDIF
DEBUG CRSRXY, 1, 10, DEC3 pulseLeft,
CRSRX, 29, DEC3 pulseRight
Se há mais sombra à direita...
Diminui roda esq com sombra dir
Roda direita velocidade máxima
para a frente
Se há mais sombra à esquerda...
Esquerda roda a toda velocidade
para a frente
Diminui roda dir com sombra esq
' Exibir os valores das variáveis
' de pulso
' Acima de nomes de variáveis
FOR i = 7 TO 15
' Áreas claras onde> e <
DEBUG CRSRXY, 6, i, " ", CRSRX, 26, " "
' velocidade da roda e direção
NEXT
' indicadores possam ser colocados
DEBUG CRSRXY,6,15-((pulseLeft-650)/25),">" ' Coloca nova velocidade da roda
DEBUG CRSRXY,26,7+((pulseRight-650)/25),"<"
LOOP
' ...
' e indica direção
O programa LightSeekingDisplay.bs2 utiliza outro formatador DEBUG,
CRSRXY, para posicionar o cursor para exibir cada indicador de velocidade
da roda. CRXRXY deve ser seguido por dois números. Por exemplo, DEBUG
CRXRXY, 6, 11, ">" iria mostrar o caractere> em seis espaços da margem
esquerda do DEBUG Terminal e 11 retornos de transporte a partir do topo.
O programa realmente usa uma expressão para definir o número de retornos
de transporte para posicionar o cursor. Por exemplo, o comando:
DEBUG CRSRXY,6,15-((pulseLeft-650)/25),">"
... posiciona o cursor a seis espaços do DEBUG Terminal que está mais à
esquerda, mas ele usa uma expressão para escolher o número de retornos de
transporte de linha superior do DEBUG Terminal. Digamos que pulseLeft
é de 750. Então, a posição y seria 11, pois 15 - ((750-650) / 25 = 15 -. 4 = 11
Então, nesse caso, CRSRXY posiciona o cursor em 6, 11, e, em seguida,
imprime o caractere '>'.
Sua Vez - Salve Grande Quantidade de RAM
Você pode querer adicionar outros recursos ao seu Boe-Bot além de buscar
por luz, mas isso pode ser difícil se seu aplicativo é executado fora de RAM
só porque você tentou declarar mais algumas variáveis. O lado esquerdo da
Figura 6-20 mostra o problema, o aplicativo tem um pouco menos de duas
palavras, à esquerda. O lado direito da figura mostra quanto espaço você
economizaria usando uma técnica simples chamada “variable aliasing”
(“apelido de variável”).
 Para ver o Mapa de RAM para LightSeekingDisplay.bs2, clique no
botão Memory Map, está à esquerda do botão Run. Você também
pode exibi-lo clicando em Executar → Mapa de memória, ou
pressionando as teclas CTRL + M. O seu mapa de RAM deve
assemelhar-se a um no lado esquerdo da figura 6-20.
De acordo com o BASIC Stamp Help, um pseudônimo é “um nome
alternativo para uma variável existente”.
 No BASIC Stamp Editor, clique em Ajuda e selecione BASIC Stamp
Help.
 Clique no PBASIC Language Reference e então em Variables para
exibir as páginas de Variáveis. Encontre a explicação para o apelido
e leia e examine um exemplo de declaração de variável que usa
apelido.
Nem todas as variáveis LightSeekingDisplay.bs2 são usadas o tempo todo.
Por exemplo, o programa é feito com tLeft tRight e somente depois a
sub-rotina Light_Shade_Info é feita. Além disso, nunca use essas duas
variáveis, ao mesmo tempo que se utiliza pulseLeft e pulseRight. Então
tLeft pode ser declarado como um apelido para pulseLeft e tRight pode
ser declarado como um apelido para pulseRight. Agora, pulseLeft e
tLeft usam o mesmo pedaço de memória, e também pulseRight e
tRight, a sua aplicação apenas recuperou duas palavras de RAM.
Com as modificações na LightSeekingDisplayBetterRAM.bs2, o programa
reduz o uso de memória RAM de "quase tudo" para "menos da metade".
Figura 6-20: Apelido de Variáveis economizam quase metade do RAM do BASIC
Stamp’s
 Salvar
o
programa
LightSeekingDisplay.bs2
como
LightSeekingDisplayBetterRAM.bs2
 Atualizar as declarações de variáveis em LightSeekingDisplay.bs2
para que elas coincidam com o lado direito da Figura 6-21.
 Verificar novamente o seu mapa de memória. Neste momento, deve
assemelhar-se ao lado direito da figura 6-20.
Figura 6-21 Economizando Espaço com Apelidos de Variáveis
pulseLeft
VAR
Word
pulseRight VAR
Word
light
VAR
Word
ndShade
VAR
Word
pulseLeft
VAR
Word
pulseRight VAR
Word
light
VAR
Word
ndShade
VAR
Word
tLeft
VAR
Word
tRight
VAR
Word
n
VAR
Word
d
VAR
Word
q
VAR
Word
sumDiff VAR
Word
duty
VAR
Byte
i
VAR
Nib
temp
VAR
Nib
sign
VAR
Bit
tLeft
VAR
pulseLeft
tRight
VAR
pulseRight
n
VAR
tLeft
d
VAR
Word
q
VAR
ndShade
sumDiff VAR
d
duty
VAR
Byte
i
VAR
Nib
temp
VAR
i
sign
VAR
Bit
CUIDADO: Tenha cuidado como você usa “variable aliases” (apelidos de
variáveis). Se o programa necessita de duas variáveis, ao mesmo tempo, uma
variável não pode ter um nome alternativo para a outra. Da mesma forma, que se
o programa precisar para verificar o valor anterior da variável na próxima
interação de um loop, dando-lhe um apelido e usá-lo para uma outra finalidade
apagaria um valor que seu programa iria precisar mais tarde.
Por exemplo, se você tentou fazer pulseLeft um apelido para
pulseRight, ambas as velocidades do servo seriam sempre as mesmas. Elas
não poderiam ser dois valores independentes que seu código precisa para
controle de servo.
ATIVIDADE #6: ROTINA DE TESTE DE NAVEGAÇÃO COM O
BOE-BOT
Esse trecho de código a partir de LightSeekingBoeBot.bs2 tem uma versão
de navegação somente da inicialização e rotinas principais de
LightSeekingDisplayBetterRAM.bs2. Todos os comandos de depuração,
foram removidos juntamente com o comando de pausa de 100 ms. Todos
eles foram substituídos por comandos PULSOUT que usam as variáveis
pulseLeft e pulseRight para controlar os servos.
'-----[ Inicialização ]----------------------------------------------------FREQOUT 4, 2000, 3000
' Começa o bip
DEBUG "Programa funcionando..."
' Exibe programa de mensagem funcionando
'-----[ Routine Principal ]------------------------------------------------DO
' Loop principal
' Rotina de Navegação
' Se houver mais sombra à direita...
pulseLeft = 900 - ndShade MIN 650 MAX 850' Diminui roda esq com sombra dir
pulseRight = 650
' Roda a direita para frente a
' velocidade máxima
ELSE
' Se houver mais sombra à
' esquerda...
pulseLeft = 850
' Roda esquerda a velocidade máxima
' devagar roda direita w/ sombra a esquerda
ENDIF
LOOP
' Controle de pulso do servo a esquerda
' controle de pulso de servo a direita
' Repita o loop principal
 Abra o programa LightSeekingBoeBot.bs2 com o BASIC Stamp




Editor e carregue-o em seu BASIC Stamp. Ou, salve
LightSeekingDisplayBetterRAM.bs2 como LightSeekingBoeBot.bs2
e atualize a Inicialização e a Rotina Principal para que elas
coincidam com o trecho de código acima.
Execute o programa.
Se você tem o Board of Education, coloque o interruptor de 3
posições na posição 2 depois de ter desligado o Boe-Bot de sua
programação por cabo e configurá-lo onde quer que ele inicie a
navegação.
O Boe-Bot agora pode andar em direção à luz.
Tente lançar sombras sobre sensores de luz de seu Boe-Bot,
conforme ele navega. Ele deve se afastar das sombras.
 Tente enviar seu Boe-Bot em direção a uma sombra escura feita por
uma mesa. Certifique-se de que sua abordagem está em um ângulo
em vez de fazê-lo se dirigir diretamente para dentro da sombra. Ele
deve desviar.
 Tente colocar o Boe-Bot em uma sala com poucas luzes fortes com
transmissão de luz apenas na porta. Ele consegue encontrar seu
caminho para fora?
Solução de problemas
Se o robô Boe-Bot parece um pouco menos sensível à luz de um lado, tente corrigi-lo,
seguindo as instruções na próxima seção (Sua Vez - Luz/Sombra Ajustes de
Sensibilidade). O mesmo se aplica se você quiser que o Boe-Bot, seja mais ou menos
sensível à sombra.
Se o Boe-Bot não responde às sombras girando para longe delas, ou se volta para o lugar
em vez de andar em frente, siga estes passos:

Se você não conseguiu entrar com seu código, tente o exemplo de código
LightSeekingBoeBot.bs2 em LightSensorExamples.zip, download gratuito a
partir de www.parallax.com/go/Boe-Bot. Isso vai excluir erros de codificação
antes de dar uma olhada em seu circuito.

Se o código do site da Parallax não corrigir o problema, você precisa verificar
o circuito seguinte. Comece por verificar cuidadosamente todas as suas
conexões de circuito usando o esquema e diagrama de fiação em Atividade #
2. Verifique os códigos de cores do resistor (marrom-preto-vermelho),
números de capacitores (104), os comprimentos de pino fototransistor, e
certifique-se que todos os cabos estejam conectados conforme mostrado no
diagrama de fiação. Também certifique-se de verificar se você selecionou
fototransistores e LEDs infravermelhos com a ajuda da Figura 6-8 na página
230. Verifique se os fototransistores estão apontando para cima e para fora,
como na Figura 6-10 na página 234. Às vezes, apontando-lhes um pouco mais
para fora, melhoram as respostas ao sombreamento. Ao ajustar as direções do
ponto fototransistor, certifique-se de que suas ligações não se tocam. Repita os
testes DEBUG Terminal, e certifique-se de fazê-los para ambos os sensores.
Cada um deve responder de maneira similar à luz e sombra.

Em seguida, repita os testes da Atividade #5. Utilize o terminal de depuração
para verificar se os níveis de luz estão no intervalo de 125-275. Além disso, a
sombra ao longo de um dado sensor deverá diminuir o servo do outro lado.
Sombras similares em relação ao outro sensor devem resultar num ajuste da
velocidade do motor semelhante da outra roda. Também verifique se a mesma
luz ou o nível de sombra sobre os sensores resultam em total velocidade.

Se o DEBUG Terminal exibe um valor de ndShade que está longe de zero,
mesmo quando os sensores vejam sobre o mesmo nível de luz, existem alguns
testes adicionais que você pode tentar na atividade Matching Phototransistor.
É parte das atividades avançadas de sensoriamento de luz, disponíveis a partir
de www.parallax.com/go/Boe-Bot. Se o Terminal de depuração em vez de
indicar que os sensores e servos estão ambos respondendo a sombra e luz
corretamente, tente LightSeekingBoeBot.bs2 novamente. Se ainda assim não
responder corretamente às sombras, é hora de verificar seus servos motores.
Repita o Capítulo 2, Atividade #6. Para um olhar mais atento, faça os gráficos
no Capítulo 3, Atividade #4 para os dois servos.
Para obter mais ajuda, experimente os recursos www.parallax.com/support.
Sua Vez – Ajustes de Sensibilidade de Luz/Sombra
Você pode alterar a 900 e 600 nestas linhas para fazer o Boe-Bot mais ou
menos sensível à sombra:
...e:
Por exemplo, você pode aumentar a sensibilidade da luz/sombra do BoeBot, alterando 900 para 875 e mudando 600 para 625. Você pode torná-lo
ainda mais sensível, alterando 900 para 850 e 600 para 650. Do mesmo
modo, pode fazer com que todo o sistema fique menos sensível mudando
900 para 925, 600 para 575, e assim por diante...
 Tente fazer isso.
Você também pode ajustar um dos valores para fazer o sensor esquerdo ou
direito ficar mais sensível. Mudando de 900 para outro valor seria alterar a
sensibilidade do Boe-Bot para sombrear à direita, e ao mudar de 600 para
outro valor iria alterar a sensibilidade do Boe-Bot para sombras à direita.
 Tente fazer isso também.
Outras coisas que você pode fazer com ajustes mínimos para a rotina
principal incluem:
•
•
Seguir a sombra em vez da luz com ndShade =-ndShade será
chamada de sub-rotina Light_Shade_Info da rotina principal.
Terminar a navegação sob uma luz intensa ou em um cubículo
escuro, detectando condições muito claras ou escuras com a variável
de luz com uma declaração IF ... THEN.
•
•
Funcionando como uma bússola de luz, permanecendo parado e
voltando-se para fontes de luz intensa.
Incorporar bigodes na rotina para navegação em direção à luz para
que o Boe-Bot possa detectar e navegar em torno de objetos em seu
caminho.
SUMÁRIO
O fototransistor é uma válvula de corrente de luz controlada. Isso permite
mais corrente com incidência de luz mais intensa e menos corrente com luz
menos intensa. Este capítulo utiliza dois circuitos fototransistores diferentes
para detectar a luz: um circuito de tensão de saída e um circuito de
transferência de carga.
O circuito de saída de tensão fototransistor neste capítulo foi conectado a um
pino de I/O configurado como entrada para um valor binário que indica luz
brilhante ou ambiente. Quando o fototransistor deixa mais corrente passar, a
tensão através da resistência é maior. Quando se permite que a corrente
atravesse menos, a tensão atravessada da resistência é menor. Ao escolher o
resistor certo para as condições de iluminação, o circuito pode ser
monitorado por um pino de I/O, pois sua tensão vai acima de 1,4 V à luz do
dia, e abaixo de 1,4 V em luz ambiente. Entrada de registro do pino I/O
armazena a 1 quando a tensão é acima de 1,4 V e a 0 quando está abaixo de
1,4 V.
Um par de circuitos de transferência de carga foi usado para medir as
diferenças de intensidade de luz entre o fototransistor da esquerda e para a
direita, e o Boe-Bot foi programado para detectar e agir sobre essas
diferenças. O circuito de transferência de carga consistia de um condensador
em paralelo e um fototransistor ligado ao pino de I/O com um resistor. Neste
circuito, o BASIC Stamp usou um pino de I/O para carregar o capacitor. Em
seguida, ele trocou o pino de I/O de entrada e mediu o tempo que levou para
a tensão do capacitor decair, uma vez que perdeu a sua carga através do
fototransistor. Esta medida de tempo de queda acaba por ser menor, com luz
intensa e maior na sombra.
Um comando HIGH seguido por PAUSE pode carregar o capacitor e, em
seguida, o comando RCTIME muda o pino de I/O para entrada e mede o
tempo que leva a voltagem do capacitor para a queda de 1,4 V, uma vez que
perde a carga através do fototransistor. O tempo da medição pode ser
reduzido usando o comando PWM no lugar de alta e pausa. O comando PWM
pode carregar o capacitor a valores inferiores a 5 V, para o comando
RCTIME, de modo que o capacitor tem menos volts para se decompor antes
de atingir 1,4 V, e isso leva menos tempo. A redução do tempo ajuda a
manter o atraso entre os comandos PULSOUT e impede de ficar tão grande
que fazem com que os servos se contorçam em vez de girarem.
Atividade #4 e a Atividade #6 utilizam um conjunto de sub-rotinas que
alimentam a rotina principal com valores de níveis de luz em geral,
juntamente com o contraste de luz/sombra entre os dois sensores. Este
contraste de luz/sombra entre os sensores de medição é chamado
“diferencial", e as sub-rotinas também normalizam a medição a uma escala
de -500 a 500. As medidas de queda reais podem variar de acordo com a luz
ambiente, de modo que os valores normalizados mantenham essas medidas
em uma escala que é útil para o controle de servo e navegação do Boe-Bot
para fontes de luz.
Questões
1. O que faz um transistor regular?
2. Quais terminais fototransistores “pernas”?
3. Como você pode usar a parte plana de plástico do fototransistor para
identificar seus terminais?
4. Que cor faria o fototransistor ser mais sensível a: vermelho ou verde?
5. Como é que VP6 na Figura 6-6 responde se a luz fica mais brilhante?
6. O que o fototransistor na Figura 6-6 causa no VP6 faz aumentar ou
diminuir?
7. Como o circuito da figura 6-6 pode ser modificado e torná-lo mais
sensível à luz?
8. O que acontece quando a tensão aplicada a um pino de I/O foi
definida para a entrada que está acima ou abaixo da tensão de limiar?
9. Se a quantidade de carga de um capacitor armazena diminui, o que
acontece com a tensão nos seus terminais?
Exercícios
1. Resolva VP6 se I = 1 mA na Figura 6- 6.
2. Calcular a corrente através do resistor de VP6 se na figura 6- 6 é de
4,5 V.
3. Suponha que o limiar entre a luz e a escuridão necessárias para a sua
aplicação ocorra quando VP6 = 2,8 V. Calcule o valor da resistência
que você precisa para o BASIC Stamp detectar esse limite.
4. Calcular o valor de um capacitor, que tem sido carimbado 105.
5. Escreva um comando RCTIME que mede o tempo de queda com I / O
pin P7 e armazena o resultado em uma variável tDecay nomeada.
6. Escrever um comando PWM que carrega o resistor, na Figura 6-11 a
cerca de 1,625 V para preparar o circuito de medição de queda.
7. Calcule como que a medição ndShade seria se o BASIC Stamp
medisse os valores de queda de 1001 em ambos os lados.
8. Escreva um comando DEBUG que exiba cinquenta caracteres de sinal
de igual.
9. Escreva um comando DEBUG que posiciona o caractere "#" oito
espaços à direita da margem esquerda do Terminal de depuração e 10
retornos de transporte a partir do topo.
Projetos
1. Na Atividade #1, o circuito junto com o código de exemplo na sua
seção de volta fez o Boe-Bot parar debaixo de uma luz no fim do
curso. E se você só tem um tempo limitado no campo antes da
competição, e você não souber as condições de iluminação de
antecedência? Talvez seja necessário calibrar o Boe-Bot no local.
Um programa que faz o “piezospeaker” emitir um som
repetidamente quando o Boe-Bot detecta a luz brilhante e a ficar
quieto quando detecta a luz ambiente pode ser útil para esta tarefa.
Escrever e testar o programa que funciona com o circuito na Figura
6-4 na página 222.
2. Desenvolver um aplicativo que faz com que o Boe-Bot ande e
procure a sombra em vez da luz. Esta aplicação deve utilizar os
circuitos de transferência de carga na Figura 6-9 na página 233.
3. Desenvolver um aplicativo que faz com que o Boe-Bot ande em
direção a uma lâmpada de mesa incandescente brilhante em uma sala
onde as únicas outras fontes de luz são luzes de teto fluorescentes. O
Boe-Bot deve ser capaz de andar em direção à lâmpada de mesa e
mudar um tom quando estiver sob ela. Esta aplicação deve utilizar os
circuitos de transferência de carga da Figura 6-9 na página 233.
Soluções
Q1. A quantidade de corrente que permite passar para o seu coletor e para
fora através da sua base.
Q2. Coletor do fototransistor e terminais de emissor são conectados aos
pinos.
Q3. O pino mais próximo do local plano é o emissor. O pino mais longe
do local plano é o coletor.
Q4. O comprimento de onda do vermelho está mais próximo do
comprimento de onda de infravermelhos, de modo que ele deve ser
mais sensível ao vermelho.
Q5. VP6 aumenta com mais luz.
Q6. Ela fornece a resistência com mais ou menos corrente.
Q7. Altere o resistor 2 kΩ para um valor maior.
Q8. Se a voltagem aplicada for superior ao limiar de tensão, o registro de
entrada de bits para um pino armazena 1. Se estiver abaixo de tensão
de limiar, a entrada registra bits a 0.
Q9. A tensão diminui.
E1. V = I × R = 0.001 A × 2000 Ω = 2 V.
E2. V = I × R → I = V ÷ R = 4.5 ÷ 2000 = 0.00225 A = 2.25 mA.
E3. Tensão de limiar do BASIC Stamp é de 1,4 V, mas o limite de luz
ocorre a 2,8 V. Portanto, o fototransistor fornece uma certa corrente
que resulta em uma medição de 2,8 V, em termos de V = I x R, que é
de 2,8 V = I × 2000 Ω. Precisamos descobrir a resistência para fazer
a tensão de 1,4 V para que a mesma corrente, que é 1,4 V = I × R.
Para descobrir R, reorganizar a primeira equação para determinar I,
que é I = 2,8 V ÷ 2000 Ω. Então, substitua 2,8 V ÷ 2000 Ω para I na
segunda equação e resolver para R. Isso é 1.4 V = I × R → 1.4 V =
(2,8 V ÷ 2000 Ω) × R → R = 1.4 V ÷ (2,8 V ÷ 2000 Ω) = 2000 Ω ×
(1,4 V ÷ 2,8 V) = 1.000 Ω = 1 kΩ.
E4. 105 → 10 com cinco zeros acrescentados e multiplicado por 1 PF.
1,000,000 × 1
E5. Seria RCTIME 7, 1, tDecay
E6. 1.625 × 256 ÷ 5 = 83,2, leve 83. Resposta: PWM 6, 83, 1
E7. ndShade = 500 - (1000 × tleft ÷ (tleft + tRight)) = 500 (1000 × 1001 ÷ (1001 + 1001)) = 500-1000 / 2 = 500-500 = 0.
E8. Seria DEBUG REP "=" \ 50
E9. Seria DEPURAR CRSRXY 8, 10, "#"
P1.
'
'
'
'
'
Robótica com o Boe-Bot - CH6P1.bs2
Emite som periodicamente se houver luz intensa. Caso contrário,
fica em silêncio.
{$STAMP BS2}
{$PBASIC 2.5}
PAUSE 1000
DEBUG "Programa funcionando..."
DO
IF IN6 = 1 THEN FREQOUT 4, 20, 4000
PAUSE 100
LOOP
P2. A solução para isso é fazer uma cópia de LightSeekingBoeBot.bs2, e
adicionar um comando para a rotina principal: ndShade =ndShade. Adicioná-lo logo após a chamada à sub-rotina
Light_Shade_Info. Então, em vez de indicar sombra para se
afastar, indica luz a afastar-se.
P3. Abaixo está uma rotina principal modificada a partir
LightSeekingBoeBot.bs2 que anda em direção à luz e pára quando
fica sob uma lâmpada incandescente. A chave para isso é muito
simples, porque LightSeekingBoeBot.bs2 tem uma variável de luz
que atinge valores mais elevados sob a luz brilhante. Com cada
repetição do DO ... LOOP, a instrução o IF ... THEN verifica
valores acima de 320. Para as áreas de baixa luminosidade e
lanternas mais fracas, você pode precisar de ajustar IF light> 320
THEN ... de modo que ele se compare a variável de luz para um
valor inferior, por exemplo: IF light > 250 THEN ...
Diminuindo o valor do IF ... THEN compara à variável light e
torna-se mais sensível, o aumento torna-se menos sensível. O valor
de 324 é o maior valor possível para não aumentar o seu valor de
comparação acima 323.
Dica: Use LightSensorValues.bs2 para testar e encontrar um valor
que está entre a luz ambiente e a luz da lanterna.
DO
IF light > 320 THEN
FREQOUT 4, 500, 3000
PAUSE 500
FREQOUT 4, 500, 3500
PAUSE 500
END
ENDIF
pulseRight = 650
ELSE
pulseLeft = 850
ENDIF
LOOP
Navegação com Faróis Infravermelhos · Página 283
Capítulo 7: Navegação com Faróis Infravermelhos
O Boe-Bot já pode usar bigodes para contornar objetos que ele detecta
quando ele bate neles, mas não seria melhor se o Boe-Bot pudesse apenas
"ver" objetos e então decidir o que fazer com eles? Bem, isso é exatamente o
que o Boe-Bot pode fazer com faróis infravermelhos e olhos como os da
Figura 7-1. O farol é um LED infravermelho dentro de um escudo de luz
infravermelha, que direciona a luz para a frente como uma lanterna. O olho
infravermelho é um receptor infravermelho que envia os sinais de alta /
baixa BASIC Stamp para indicar se ele detecta a luz do LED infravermelho
refletida por um objeto.
Figura 7-1: Detecção de objetos infravermelhos
Receptor
infravermelho
Receptor
infravermelho
Infrared LED
Infrared LED
Esquerda: infravermelho refletido, obstáculo detectado. Direita: infravermelho não
reflete, nenhum obstáculo detectado.
LUZ INFRAVERMELHA
A luz infravermelha é abreviada IV e você pode pensar nisso como uma
forma de luz que o olho humano não consegue detectar. Para a reciclagem,
dê uma olhada na Figura 6-2 na página 221. Dispositivos como o LED IV
introduzido neste capítulo emitem luz infravermelha, e dispositivos como o
fototransistor do capítulo anterior e o receptor infravermelho deste capítulo
detectam luz infravermelha. Figura 7-2 mostra como o LED infravermelho
do Boe-Bot é usado como uma pequena lanterna é realmente o mesmo que
você pode encontrar em praticamente qualquer controle remoto de TV. TV
com controle remoto envia mensagens de IV para a sua TV, e o
microcontrolador na sua TV pega essas mensagens com um receptor
infravermelho como o seu Boe-Bot usará para detectar IV refletida fora dos
objetos.
Figura 7-2: LED IV e receptor em sua casa
IR on/off at ≈38 kHz para
certos períodos de tempo
IR Receptor
LED IV
Note-se que o controle remoto da TV envia mensagens descrevendo qual o
botão que você pressionou seu LED IV on/off para rapidamente pisca a uma
taxa próxima a kHz 38. Isso é cerca de 38.000 vezes por segundo. O
receptor IV só responde ao infravermelho se ele está piscando on / off, a este
ritmo. Isso evita que infravermelho de fontes como as luzes do sol e
lâmpadas incandescentes sejam mal interpretadas como as mensagens de
controle remoto. Assim, para enviar sinais ao receptor IV possa detectar, o
BASIC Stamp terá de enviar sinais na faixa de 38 kHz também. A
linguagem PBASIC facilita o trabalho dessa tarefa, com apenas uma linha de
código para transmitir o sinal, e uma segunda linha para verificar o receptor
IV.
Algumas luzes fluorescentes geram sinais que podem ser detectados pelos
receptores de infravermelhos. Estas luzes podem causar problemas para os
faróis infravermelhos do seu Boe-Bot. Uma das coisas que você vai fazer neste
capítulo é desenvolver uma interferência no infravermelho "sniffer", que você
pode usar para testar as luzes fluorescentes perto de seus cursos de Boe-Bot.
Os sensores de cores claras no interior da maioria das câmeras digitais,
incluindo telefones celulares e webcams, podem detectar luz infravermelha,
o que nos dá uma maneira de "ver", mesmo que o olho não possa detectá-lo.
Figura 7-3 mostra um exemplo com uma câmera digital e um controle
remoto da TV. Quando você pressionar e segurar um botão no controle
remoto e apontar o diodo emissor de luz para a lente da câmera digital de
seu IV, apresenta o LED de infravermelho como um piscar de luz branca
brilhante.
Figura 7-3: LED IV em um controle remoto de TV visto através de uma câmera digital
Com um botão pressionado e mantido, o
LED IV não parece diferente.
Através de um visor da câmera digital, o LED
IV aparece como um piscar de luz branca e
brilhante.
Os sensores de pixel dentro da câmara digital detectam vermelho, verde, e os
níveis de luz azul, e o processador acrescenta esses níveis para determinar a
cor e o brilho de cada pixel. Independentemente de um pixel, o sensor
detecta vermelho, verde ou azul, ele detecta infravermelho. Uma vez que
todos os três sensores detectam infravermelhos, o visor da câmara digital
combina todas as cores em conjunto, o que resulta em branco.
Infra significa inferiores, para infravermelhos significa abaixo do
vermelho. O nome refere-se ao fato de a frequência das ondas de luz
infravermelha serem menores do que a frequência das ondas de luz vermelha.
Comprimentos de onda de infravermelho e seus usos: o comprimento de
onda nosso LED IV transmite LED IV é de 980 nm, e esse é o mesmo
comprimento de onda que nosso receptor IV detecta. Este comprimento de
onda está na gama do infravermelho próximo. A faixa do infravermelho
distante é de 2000 a 10000 nm, e certos comprimentos de onda nesta faixa são
usados para óculos de visão noturna e sensor de temperatura IV.
ATIVIDADE #1: CONTRUINDO E TESTANDO O DETECTOR DE
OBJETOS IR
Nesta atividade, você vai construir e testar detectores de infravermelho do
objeto para o robô Boe-Bot.
 Reunir as peças na lista de peças usando a Figura 7-4 para ajudar a
identificar os receptores de infravermelho, LEDs e peças de
reposição de montagem.
Lista de peças:
(2) receptores IV
(2) LEDs IV (caso claro)
(2) LED IV escudo
de montagem
(2) Resistores, 220 Ω
(Vermelho-vermelho
marrom)
Figura 7-4
Novas peças
usadas neste
capítulo
IV receptor
(topo)
LED IV
(meio)
LED IV
placas
montagem
(parte
inferior)
 Verifique Figura 7- 5 para certificar-se de que você selecionou LEDs
infravermelhos e não fototransistores. O diodo emissor de luz
infravermelha tem uma cúpula de plástico mais alto e mais
arredondada, e é mostrado no lado direito da Figura 7-5.
Mais aredondado
na ponta
Mais liso
na ponta
Phototransistor
Infrared LED
USE ESTE
Figura 7-5
Fototransistores
distintivos de LEDs
infravermelhos
Certifique-se de que
você tem dois LEDs
infravermelhos.
A Construção dos Faróis de IV
 Inserir o LED no isolador LED (o maior dos dois pedaços de
montagem de blindagem) como mostrado na Figura 7-6
infravermelhos.
 Verifique se o LED IV encaixa o impasse LED.
 Deslize o escudo LED (a metade menor do escudo de montagem
LED) sobre a caixa de plástico do LED IV. O anel em uma
extremidade da blindagem do LED deve se encaixar direito no
impasse LED.
 Use um pequeno pedaço de fita adesiva transparente para se
certificar de que as duas metades do escudo de montagem não se
separam
durante
o
uso.
IR LED will snap in.
+
-
Figura 7-6
Tirando o LED IV no escudo de
montagem
IV Circuito de Detecção de Objeto
A figura 7-7 mostra o IV objeto esquemático de um circuito de detecção e na
Figura 7-8 mostra um esquema de ligações do circuito. No diagrama da
fiação, um detector de objeto (LED IV e receptor) está montado em cada
canto da placa de montagem muito mais próxima da frente do Boe-Bot.
 Construir o circuito da figura 7-7 utilizando o esquema da Figura 7-8
do diagrama de fiação como uma referência para a colocação de
peças
Vdd
P2
1 kΩ
IR
LED
P9
220 Ω
Vss
Vss
Vdd
P8
1 kΩ
IR
LED
Figura 7-7
Esquerda e Direita
Detectores Objeto
IV
P0
220 Ω
Vss
Vss
Veja seus ânodos e cátodos LED IV!
O condutor de ânodo é o mais longo condutor em um LED por convenção IV. O
cátodo é mais curto e montado na caixa de plástico mais próxima do seu ponto
liso. As mesmas convenções aplicada à LEDs vermelhos no Capítulo 2.
Na Figura 7-8, o ânodo de cada LED IV conecta a um resistor de 1 kW. O
terminal cátodo está plugado na mesma linha breadboard como pino central de
um detector de IV, e a linha está ligada ao VSS com uma ponte.
Figura 7-8: Diagramas de fiação para emissor infravermelho e circuitos do receptor
To Servos
To Servos
15 14 Vdd 13 12
(916) 624-8333
Rev B
www.parallax.com
Red
Black
X4
Vdd
X5
Vin
Vdd
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
esquerdo
Leva
anódio
+
Board of Education
Rev C
Vin
Vss
X3
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
direito
© 2000-2003
esquerdo
Leva
anódio
+
HomeWork Board
direito
Código de Teste do Objeto Detectado
Os receptores de infravermelho do seu Boe-Bot são projetados para detectar
luz infravermelha com um comprimento de onda de 980 nm, que pisca on /
off ou variando no brilho a uma taxa próxima de 38 kHz. O LED
infravermelho emite 980 nm IV, se feito com cuidado. Tudo o que
precisamos é fazer com que o brilho do LED varie entre mais brilhante e
opaco a uma taxa de cerca de 38 kHz. Podemos fazer isso com o mesmo
comando que estamos usando para fazer o alto-falante do Boe-Bot lançar um
tom no início de cada programa, o comando FREQOUT.
Leve duas linhas de código para testar a presença ou ausência de um objeto
utilizando um circuito de detecção de objetos de IV. Aqui está um exemplo
de testes para descobrir se um objeto está na frente do circuito de detecção
IV da esquerda do robô Boe-Bot.
FREQOUT 8, 1, 38500
irDetectLeft = IN9
O comando FREQOUT 8, 1, 38500 faz com que o brilho do LED IV
varie, ficando mais brilhante e opaco 38.500 vezes por segundo. Ele faz isso
para 1 ms, e depois irDetectLeft = in9 armazena saída do receptor IV
em uma variável. A saída do detector será alta se não detectar 38,5 kHz IV
se refletida fora do objeto, ou baixa se nele. Portanto, o valor de IN9 que é
copiado para a variável irDetectLeft será 1 se nenhum objeto é detectado,
ou 0 se um objeto é detectado.
Sempre use irDetectLeft = IN9 logo após FREQOUT 8, 1, 38500.
O BASIC Stamp só tem uma janela de tempo breve para copiar o sinal binário
que ele recebe do receptor IV a uma variável. O receptor IV envia um sinal de
baixa, enquanto ele detecta 38,5 kHz IV refletida por um objeto, o que faz com
que IN9 armazene 0. Quando o BASIC Stamp termina de transmitir seu sinal
FREQOUT e se move para o próximo comando, ele para de enviar sinal de 38,5
kHz. Assim, o programa tem que usar irDetectLeft = IN9 para pegar
esse valor zero antes de o receptor IV perceber o sinal de 38,5 kHz parado. Leva
apenas uma fração de um milésimo de segundo para o receptor IV perceber o
sinal de parada, e depois disso, os seus rebotes de saída para alto, e IN9
armazena 1 novamente.
Exemplo de Programa: TestLeftIr.bs2
 Reconecte sua placa de energia.
 Coloque, salve e execute o programa TestLeftIr.bs2.
' Robótica com o Boe-Bot - TestLeftIr.bs2
' IV circuitos de detecção de objeto para teste, LED IV para P8 e detector de
' P9.
' {$STAMP BS2}
' {$PBASIC 2.5}
irDetectLeft
DO
VAR
Bit
FREQOUT 8, 1, 38500
irDetectLeft = IN9
DEBUG HOME, "irDetectLeft = ", BIN1 irDetectLeft
PAUSE 100
LOOP
 Deixe o Boe-Bot ligado à sua programação por cabo, porque você





estará usando o DEBUG Terminal para testar o seu detector de
objeto IV
Pl Coloque um objeto, como sua mão ou uma folha de papel,
aproximadamente uma polegada da esquerda do detector de objeto
IV, da maneira mostrada na Figura 7- 1 na página 283.
Verifique se o DEBUG Terminal exibe a 0 quando você coloca um
objeto alguns centímetros na frente do detector objeto IV.
Verifique se ele exibe 1 quando você remover o objeto.
Se o DEBUG Terminal exibir os valores esperados para o objeto não
detectado (1) e objeto detectado (0), passar para a sua seção sua vez.
Se o DEBUG Terminal não apresentar os valores esperados, tente as
etapas na seção Solução de problemas.
Solução de Problemas
Se o DEBUG Terminal não apresentar os valores esperados, tente esta lista:
 Verificar circuito e erros de entrada do programa. Um erro comum é
usar um resistor de 10 kW (marrom-preto-laranja), em vez de 1 kW
(marrom-preto-vermelho).
 Mantenha o Boe-Bot longe da luz solar direta
 Se você está sempre recebendo 0, mesmo quando um objeto não é
colocado na frente do Boe-Bot, pode haver um objeto próximo que
está refletindo o infravermelho.
 A superfície da mesa na frente do Boe-Bot é um culpado comum.
Mova o Boe-Bot para que o LED IV e o detector não estar refletindo
qualquer objeto próximo.
 Se a leitura é 1 na maior parte do tempo quando não há nenhum
objeto na frente do Boe-Bot, mas muda a 0, ocasionalmente, pode
significar que você tem a interferência de uma luz fluorescente
próxima. Desligue as luzes fluorescentes próximas e repita os testes.
Tente também fechar as cortinas se você estiver perto de uma janela.
Se a leitura é 1 o tempo todo, mesmo quando um objeto é colocado
na frente do Boe-Bot: Embora não seja um erro comum, os
fabricantes, ocasionalmente, fazem um lote de LEDs com os
condutores mais longo e mais curto revertidos. Se você já tiver
verificado duas vezes sua fiação e programa, tente desligar o LED IV
e inverter a sua polaridade, de modo que a liderança mais curta esteja
ligada ao resistor de 1 kW e o conector mais longo ligado a VSS.
 Um último teste que você pode fazer é ligar o circuito de LED IV
para um pino de E / S diferente e ajustar o seu programa de acordo
com. Comece com o ânodo correto / orientação de cátodo, e se não
funcionar, tente inverter novamente.
Sua Vez – Teste de Detector de Objeto de IV Direito
 Salve TestLeftIr.bs2 com TestRightIr.bs2.
 Altere o comando, o título e os comentários do programa DEBUG
para se referir ao detector direito de objeto IV
 Altere o nome da variável de irDetectLeft para irDetectRight.
Você terá que fazer isso em quatro lugares no programa.
 Altere argumento Pin do comando FREQOUT 8 para 2
 Altere o registo de entrada monitorada pela variável IRDetectRight
de IN9 para IN0.
 Repita os passos de teste nesta atividade para a direita do detector
objeto IV do Boe-Bot
Ondas senoidais sintetizadas por FREQOUT
O comando FREQOUT transmite uma sequência rápida de ligar / desligar que
sintetizam tensões digitalmente para criar um padrão de onda senoidal. Ondas
senoidais soam muito mais natural que as ondas quadradas quando tocadas por
um alto-falante
Onda senoidal
Onda quadrada
Um sinal FREQOUT contém dois componentes de onda senoidal com duas
frequências diferentes. Frequência é um componente do Freq1. Frequência do
segundo componente é 65536 - Freq1.
Quando o comando FREQOUT é usado para reproduzir os tons audíveis, o
segundo sinal de frequência é sempre bem acima dos 20 kHz, que normalmente é
o
tom
mais
alto
que
o
ouvido
humano
pode
detectar.
Exemplo 1: FREQOUT 4, 2000, 3000 desempenha uma onda sinusoidal
de 3 kHz no piezospeaker porque Freq1 é 3000. O sinal contém um segundo
componente com uma frequência de 65536 - 3000 = 62536 Hz, mas o ouvido
humano não consegue detectar. Desde 65536-62536 = 3000, você pode jogar o
mesmo tom com FREQOUT 4, 2000, 62536. Embora Freq1 agora
esteja bem fora do alcance do ouvido humano, o segundo sinal é de 3 kHz, então
você vai ter o mesmo tom de seu piezospeaker.
Exemplo 2: FREQOUT 8, 1, 38500 faz a luminosidade do LED IV variar a
uma velocidade de 38500 Hz assim que o receptor de infravermelhos detectar. O
sinal que cria também contém uma segunda onda sinusoidal com uma frequência
de 65.536-38.500 = 27036 Hz, mas o sinal não tem qualquer efeito sobre o
receptor IV.
ATIVIDADE #2: TESTANDO O DETECTOR DE OBJETOS IV EM
CAMPO E INTERFERÊNCIA INFRAVERMELHA
Nesta atividade, você vai construir e testar LEDs indicadores que vão dizer
se um objeto é detectado, sem a ajuda do DEBUG Terminal. Isso é útil se
você não está perto de um PC ou laptop, e você precisar solucionar seus
circuitos detectores de infravermelho. Você também vai escrever um
programa para "FAREJAR" a interferência de infravermelho das luzes
fluorescentes. Algumas luzes fluorescentes emitem sinais que lembram o
sinal enviado por seus LEDs infravermelhos. O dispositivo de fixação no
interior de uma luz fluorescente, que controla a tensão para a lâmpada é
chamado de "lastro". Alguns balastros operaram na mesma gama do seu
detector de IV, 38,5 kHz, a qual por sua vez faz com que a lâmpada emita
um sinal de frequência. Ao integrar a detecção de objetos IV com a
navegação, esta interferência pode causar algum comportamento bizarro
para o Boe-Bot!
Reconstruindo os Circuitos Indicador LED
Estes são os mesmos circuitos de LED indicadores que você usou com os
bigodes.
Lista de Peças:
(2) LEDs vermelhos
(2) Resistores, 220 Ω (vermelho-vermelho-marrom)
 Desligue a alimentação de sua placa e servos
 Construir o circuito mostrado na figura 7-9, usando a Figura 7-10
como uma referência
P10
P1
220 Ω
220 Ω
Red
LED
Figura 7-9
LEDs indicadores
de Esquerda e
Direita
Red
LED
Vss
Vss
Figura 7-10: Diagramas de fiação para emissor infravermelho e circuitos do receptor
To Servos
To Servos
15 14 Vdd 13 12
anode
lead
X4
Vdd
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
X5
Vin
Vin
Vss
X3
Vss
X3
anode
lead
(916) 624-8333
Rev B
www.parallax.com
Red
Black
P15
P14
anode P13
P12
lead
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Board of Education
Rev C
anode
lead
+
HomeWork Board
© 2000-2003
Board of Education (à esquerda) e HomeWork Board (à direita)
Testando o Sistema
Existem muito poucos componentes envolvidos neste sistema, o que
aumenta a probabilidade de um erro de fiação. É por isso que é importante
ter um programa de teste que mostra o que os detectores de infravermelho
estão sentindo. Você pode usar este programa para verificar se todos os
circuitos estão funcionando antes de desconectar o Boe-Bot de sua
programação por cabo e testar outros objetos.
Exemplo de Programa – TestBothIrAndIndicators.bs2
 Reconecte sua placa a energia
 Coloque, salve e execute o programa TestBothIrAndIndicators.bs2.
 Verifique se o alto-falante está claro, audível enquanto o DEBUG
Terminal exibe "piezospeaker Testing ..."
 Use o DEBUG Terminal para verificar se o BASIC Stamp ainda
recebe um zero de cada detector IV quando um objeto é colocado na
frente dele
 Verifique se o LED ao lado de cada detector emite luz quando o
detector detecta um objeto. Se um ou ambos os LEDs parecem não
funcionar,
verifique
a
fiação
e
seu
programa.
' Robótica com o Boe-Bot - TestBothIrAndIndicators.bs2
' IV circuitos de detecção de objeto de teste.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Variáveis ]--------------------------------------------------------irDetectLeft VAR
irDetectRight VAR
Bit
Bit
' -----[ Inicialização ]----------------------------------------------------DEBUG "Testing piezospeaker..."
FREQOUT 4, 2000, 3000
DEBUG CLS,
"IV DETECTORS", CR,
"Left Right", CR,
"----- -----"
' -----[ Rotina principal ]-------------------------------------------------DO
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
IF (irDetectLeft = 0) THEN
HIGH 10
ELSE
LOW 10
ENDIF
IF (irDetectRight = 0) THEN
HIGH 1
ELSE
LOW 1
ENDIF
DEBUG CRSRXY, 2, 3, BIN1 irDetectLeft,
CRSRXY, 9, 3, BIN1 irDetectRight
PAUSE 100
LOOP
Sua Vez – Teste Remoto e Área de Testes
Agora você pode usar os detectores de LED para o Boe-Bot e testar os
detectores de IV sobre os objetos que não poderiam estar de outra forma ao
alcance do cabo de programação do seu computador.
 Desligue o Boe-Bot do cabo de programação, e faça o seu Boe-Bot
testar a gama de detectores de infravermelho.
 Experimente o alcance de detecção de diferentes objetos coloridos.
Que cor é detectada na faixa mais distante? Que cor é detectada na
faixa mais próxima?
Farejamento para Interferencia IV
Se você passou a perceber que seu Boe-Bot detectou algo, mesmo não
estando no intervalo, isso pode significar que a luz próxima está a gerar
alguma luz IV em uma freqüência perto de 38,5 kHz. Se você for fizer uma
competição com Boe-Bot ou demonstração em uma dessas luzes, seus
sistemas de infravermelhos podem acabar funcionando muito mal. A última
coisa que alguém quer é ter um robô que não funcione durante uma
apresentação pública, por isso certifique-se de verificar qualquer área de
demonstração prospectiva com esta interferência do programa "sniffer" IV
com antecedência.
O conceito por trás deste programa é simples: não transmitir qualquer IV
através da LEDs IV, apenas monitorar para ver se algum IV é detectado. Se
for detectado IV, o alarme soará usando o piezospeaker.
Você pode usar um controle remoto de mão para praticamente qualquer peça
de equipamento gerar interferência IV. TVs, videocassetes, CD / DVD players e
projetores todos usam o mesmo tipo de detectores de infravermelho que têm no
seu Boe-Bot de agora em diante. Da mesma forma, os controles remotos que
você usa para controlar estes dispositivos usam o mesmo tipo de LED IV que
está em seu Boe-Bot que transmite mensagens para o detector IV na sua TV,
VCR, CD / DVD player, etc.
Exemplo de Programa – IrInterferenceSniffer.bs2
 Coloque, salve e execute o programa IrInterferenceSniffer.bs2.
Teste para certificar se o Boe-Bot toca o alarme quando detecta
interferências IV. Se você estiver em uma sala de aula, você pode
fazer isso com um Boe-Bot separado do que o que está executando
TestBothIrAndIndicators.bs2. Se você não tem um segundo Boe-Bot,
basta usar um controle remoto de mão para a TV, VCR, CD / DVD
player, ou projetor. Basta apontar o telecomando para o Boe-Bot e
pressionar um botão. Se o Boe-Bot responder irá soar o alarme, e
você saberá que sua interferência IV sniffer está funcionando.
' Robótica com o Boe-Bot - IrInterferenceSniffer.bs2
' Luzes fluorescentes de teste, controles remotos infravermelhos, e de outras
' fontes De 38,5 kHz interferência de IV.
' {$STAMP BS2}
' {$PBASIC 2.5}
counter
VAR
' Stamp diretiva.
' PBASIC diretiva.
Nib
DEBUG "IV interference not detected, yet...", CR
DO
IF (IN0 = 0) OR (IN9 = 0) THEN
DEBUG "IV Interference detected!!!", CR
HIGH 1
HIGH 10
FREQOUT 4, 50, 4000
LOW 1
LOW 10
PAUSE 20
NEXT
ENDIF
LOOP
Sua Vez – Teste de Luzes Fluorescentes que Interferem
 Desligue o Boe-Bot de seu cabo de programação, e aponte-o em
qualquer luz fluorescente perto de onde você pretende operá-lo.
Especialmente se você tem alarmes frequentes, desligue a luz
fluorescente, antes de tentar usar a detecção de objetos IV sob ele.
Utilize sempre este IrInterferenceSniffer.bs2 para ter certeza de que qualquer
área onde você estiver usando o Boe-Bot é livre de interferência de
infravermelho.
ATIVIDADE #3: AJUSTANDO O ALCANCE DA DETECÇÃO DE
INFRAVERMELHO
Você deve ter notado que os faróis de carros são mais brilhantes (ou uma
lanterna brilhante) e podem ser usados para ver objetos que estão mais longe
quando está escuro. Ao fazer a luz do LED infravermelho mais brilhante do
Boe-Bot, você também pode aumentar seu alcance de detecção. Ao resistir à
corrente eléctrica menor, um resistor mais pequeno permite que a corrente
flua através de um LED. Mais corrente através de um LED é o que faz com
que ela brilhe mais intensamente. Nesta atividade, você vai examinar o
efeito de diferentes valores de resistência com os LEDs vermelho e
infravermelho.
Lista de Peças:
Você vai precisar de algumas peças extras para esta atividade.
(2) Resistores, 470 Ω (amarelo- violeta-marrom)
(2) Resistores, 220 Ω (vermelho-vermelho-marrom)
(2) Resistores, 2 kΩ (vermelho- preto- vermelho)
(2) Resistores, 4.7 kΩ (amarelo-violeta - vermelho)
Resistência em Série e Brilho LED
Primeiro, vamos usar um dos LEDs vermelhos para "ver" a diferença que
faz um resistor na forma como brilhantemente um LED acende. Tudo o que
precisa para testar o LED é um programa que envia um sinal de alta para o
LED.
Exemplo de Programa – P1LedHigh.bs2
 Coloque, salve e execute o programa P1LedHigh.bs2.
 Execute o programa e verifique se o LED no circuito está ligado a P1
emite luz
'
'
'
'
'
Robótica com o Boe-Bot - P1LedHigh.bs2
Set P1 Hight para testar para o teste de brilho LED com cada um dos
desses valores de resistência, por sua vez: 220 ohm, 470 ohm, 1 k ohm.
{$STAMP BS2}
{$PBASIC 2.5}
HIGH 1
STOP
O comando STOP é usado aqui ao invés de END, desde que o END iria
colocar o BASIC Stamp em modo de baixa energia.
Sua Vez – Testando LED Brilhante
Lembre-se de desligar a alimentação antes de fazer alterações em um
circuito. Lembre-se também que o mesmo programa será executado
novamente quando você reconectar a energia, assim você pode saber
exatamente onde você parou com cada teste.






Observe como intensamente um circuito LED a P1 está brilhando
com o resistor de 220 Ω.
Substituir o resistor de 220 Ω ligado a P1 e cátodo do LED da direita
com um resistor de 470 Ω. Observe agora como intensamente os
LED brilham.
Repita o procedimento para um resistor de 2 kΩ.
Repita mais uma vez, com uma resistência de 4,7 kΩ.
Substituir o resistor de 4,7 kW com o resistor de 220 Ω antes de
passar para a próxima parte desta atividade.
Explique com suas próprias palavras, a relação entre o brilho de LED
e resistência em série.
Resistência em Série e Faixa de Detecção IV
Sabemos agora que uma menor resistência em série farão um brilho LED
mais brilhante. Uma hipótese razoável seria que LED IV mais brilhantes
possibilitam a detecção de objetos que estão mais longe.
 Abra e execute TestBothIRAndIndicators.bs2 (Da página 297).
 Verifique se os dois detectores estão funcionando corretamente.
Sua Vez – Teste LED IV Gama
 Com uma régua, meça a maior distância do LED IV que uma folha
de papel pode ser detectada, usando 1 kΩ resistor, e registre seus
dados na Tabela 7-1.
 Repita o resistor 1 kΩ que está conectado a P2 e P8 para o LED IV
ânodos com resistores 4.7 kΩ.
 Determinar o mais longe possível em que é detectada a mesma folha
de papel, e registrar seus dados
 Repita com 2 kΩ resistores, 470 Ω resistores, e 220 Ω resistores.
Tabela 7-1: Detenção de distância vs. Resistencia
IRELD Series Resistências
Máxima detenção de distância
(Ω)
4700
2000
1000
470
220
 Antes de passar para a próxima atividade, restaurar os detectores de
infravermelho do objeto para sua configuração original (com 1 kΩ
resistor em series com cada LED IV).
 Além disso, antes de prosseguir, certifique-se de testar essa última
alteração com TestBothIrAndIndicators.bs2 para verificar que ambos
os detectores de infravermelho do objeto estão funcionando
corretamente.
ATIVIDADE #4: DETECTANDO E EVITANDO OBJETOS
Uma coisa interessante sobre os detectores de infravermelho é que as suas
saídas são apenas como os bigodes. Quando não é detectado um objeto, a
saída é elevada, quando um objeto é detectado, o rendimento é baixo.
Nesta atividade, RoamingWithWhiskers.bs2 da página 305 é modificado
para que ele funcione com os detectores de infravermelho.
Convertendo o Programa de Bigodes para IV Detecção / Prevenção de
Objeto
Este programa seguinte é um exemplo que começou como
RoamingWithWhiskers.bs2. Além de ajustar o nome e descrição, as
variáveis de dois bits foram adicionadas para armazenar os estados dos
detectores de infravermelho.
irDetectLeft VAR
irDetectRight VAR
Bit
Bit
A rotina também foi adicionada para ler os detectores de infravermelho do
objeto.
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
As declarações IF ... THEN foram modificadas de modo que elas olham
para as variáveis que armazenam os IV detecções de objetos, em vez das
entradas bigode.
IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
ELSEIF (irDetectLeft = 0) THEN
GOSUB Back_Up
GOSUB Turn_Right
ELSEIF (irDetectRight = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
ELSE
GOSUB Forward_Pulse
ENDIF
Exemplo de Programa – RoamingWithIr.bs2
 Abrir RoamingWithWhiskers.bs2
 Modificá-lo para que ele corresponda ao programa abaixo
 Volte a ligar a sua placa e servos
 Salve e execute-o
 Verifique se, além do fato de que não há nenhum contato necessário,
ele se comporta como RoamingWithWhiskers.bs2
'
'
'
'
'
-----[ Título ]-----------------------------------------------------------Robótica com o Boe-Bot - RoamingWithIr.bs2
Adaptar RoamingWithWhiskers.bs2 para uso com o IV detector de objetos.
{$STAMP BS2}
' Stamp diretiva.
{$PBASIC 2.5}
' PBASIC diretiva.
' -----[ Variavéis ]--------------------------------------------------------irDetectLeft VAR
irDetectRight VAR
pulseCount
VAR
Bit
Bit
Byte
' Sinal do programa start/reset.
' -----[ rotina principal ]-------------------------------------------------DO
FREQOUT 8, 1, 38500
irDetectLeft = IN9
' Store IV detector de valores em
' bit variaveis.
FREQOUT 2, 1, 38500
irDetectRight = IN0
GOSUB Back_Up
' ambos detectam obstáculo
GOSUB Turn_Left
' Back up & U-turn (esquerda duas vezes)
GOSUB Turn_Left
' detector a esquerda
GOSUB Back_Up
' Back up & turn direita
GOSUB Turn_Right
' detector a direita
GOSUB Back_Up
' Back up & turn esquerda
GOSUB Turn_Left
ELSE
' Não deletar
GOSUB Forward_Pulse
' Aplicar um pulso para a frente
ENDIF
' e checar novamente
LOOP
' -----[ Subrotinas ]-------------------------------------------------------Forward_Pulse:
PULSOUT 13,850
PULSOUT 12,650
' Enviar um único pulso para a frente.
PAUSE 20
RETURN
Turn_Left:
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
Turn_Right:
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
Back_Up:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
' Vire à esquerda, a cerca de 90 graus.
' Vire à direita, cerca de 90 graus.
' Volte a fazer
Sua Vez

Modificar RoamingWithIr.bs2 para que os detectores de objetos IV
sejam verificados em uma sub-rotina.
ATIVIDADE #5: NAVEGAÇÃO INFRAVERMELHA DE ALTA
PERFORMANCE
O estilo de manobras pré-programadas que foram usados na atividade
anterior foram excelentes para bigodes, mas são desnecessariamente lentos
quando usando o LEDs IV e detectores. Você pode melhorar muito o
desempenho de navegação do Boe-Bot, verificando obstáculos antes de
entregar cada conjunto de pulsos para os servos. O programa pode usar as
entradas de sensor para selecionar a melhor manobra de cada momento da
navegação. Dessa forma, o Boe-Bot nunca vira mais do que ele tem de virar,
e pode perfeitamente encontrar o seu caminho em torno de obstáculos e
navegar com sucesso em cursos mais complexos.
Amostragem Entre Cada Pulso para Evitar Colisões
A grande coisa sobre a detecção de um obstáculo antes de esbarrar em um é
dar ao Boe-Bot algum espaço para navegar em torno dele. O Boe-Bot pode
aplicar um pulso e afastar-se de um objeto, verifique novamente e se o
objeto ainda existir, aplique outro pulso para evitar isto. O Boe-Bot pode
continuar aplicando pulsos e verificando até que ele fique longe do
obstáculo. Em seguida, pode continuar a apresentar os pulsos. Depois de
experimentar este programa seguinte como exemplo, você provavelmente
vai concordar que é uma maneira muito melhor do Boe-Bot andar.
Exemplo de Programa – FastIrRoaming.bs2
 Coloque, salve e execute o programa FastIrRoaming.bs2.
' Robótica com o Boe-Bot - FastIrRoaming.bs2
'Maior desempenho de detecção de objetos IV assistida navegação
' {$STAMP BS2}
' {$PBASIC 2.5}
irDetectLeft
irDetectRight
pulseLeft
pulseRight
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
' Declarações de variáveis
FREQOUT 4, 2000, 3000
DO
' Rotina principal
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
' Checar o IV Detectores
' Decida como navegar
pulseLeft = 650
pulseRight = 850
pulseLeft = 850
pulseRight = 850
pulseLeft = 650
pulseRight = 650
ELSE
pulseLeft = 850
pulseRight = 650
ENDIF
PULSOUT 13,pulseLeft
PULSOUT 12,pulseRight
PAUSE 15
' Aplicar o pulso
LOOP
' Repita o menu principal de rotina
Como Funciona FastIrRoaming.bs2
Este programa tem uma abordagem ligeiramente diferente para aplicar
pulsos. Além dos dois bits usados para armazenar as saídas do detector de
IV, utiliza duas variáveis de palavras para definir as durações de pulso
emitidas pelo comando PULSOUT.
irDetectLeft
irDetectRight
pulseLeft
pulseRight
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
Dentro do DO ... LOOP, os comandos FREQOUT são usados para enviar um
sinal de IV de 38,5 kHz para cada LED IV. Imediatamente após a explosão
de 1 ms de IV é enviado um bit variável que armazena o estado da saída do
detector de IV. Isto é necessário, porque se você esperar mais do que o valor
do tempo de um comando, o detector IV voltará ao não detectado (1 estado),
independentemente de ter ou não ter detectado um objeto.
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
Nas declarações IF…THEN, ao invés de entregar pulsos ou chamar rotinas de
navegação, este programa estabelece os valores das variáveis que serão
utilizadas
nos
argumentos
Duração
comandos
PULSOUT.
pulseLeft = 650
pulseRight = 850
pulseLeft = 850
pulseRight = 850
pulseLeft = 650
pulseRight = 650
ELSE
pulseLeft = 850
pulseRight = 650
ENDIF
Antes DO…LOOP repetir, a última coisa a fazer é entregar pulsos para os
servos. Note-se que o comando de PAUSE é não mais de 20. Em vez disso,
ele é 15 desde cerca de 5 ms é levado a verificação dos LEDs IV.
PAUSE 15
' Aplicar o pulso.
Sua Vez
 Salve FastIrRoaming.bs2 as FastIrRoamingYourTurn.bs2.
 Use os LEDs para transmitir que o Boe-Bot detectou um objeto
 Tente modificar os valores que pulseLeft e pulseRight estão
definidos para que o Boe-Bot faça tudo com metade da velocidade
ATIVIDADE #6: DETECTOR DE DEGRAU
Até agora, o Boe-Bot tem principalmente sido programado para ter
manobras evasivas quando um objeto é detectado. Há também aplicações
onde o Boe-Bot deve tomar uma ação evasiva quando um objeto não é
detectado. Por exemplo, se o Boe-Bot estiver caminhando sobre uma mesa,
os seus detectores de IV podem estar voltados para a superfície da mesa,
como mostrado na Figura 7-11. O programa deverá continuar para a frente,
desde que ambos os detectores de IV possam "ver" a superfície da mesa.
To Servos
15 14 Vdd 13 12
Red
Black
X4
Vdd
X5
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 7-11
Detectores
de objetos IV
dirigido para
baixo para
verificar se
há uma
queda
+
Board of Education
Rev C
© 2000-2003
 Desligue a alimentação de sua placa e servos
 Aponte os detectores de IV objeto para baixo e para fora como
mostrado na Figura 7-11.
Materiais Recomendados:
(1) rolo de fita isolante de vinil preto, ¾ "(19 mm) de largura
(1) folha de cartolina branca, 22 x 28 em (56 x 71 cm)
Simulando Uma Queda com Fita Isolante
Uma folha de cartolina branca com uma borda feita de fita isolante é uma
maneira útil para simular uma queda apresentada pela borda de uma mesa,
com muito menos risco para o seu Boe-Bot.





Construir um caminho semelhante ao delimitado com a fita isolante
mostrado na Figura 12 -7. Use pelo menos três tiras de fita isolante,
borda a borda, sem papel visível entre as tiras.
Substituir as resistências de 1 kΩ com resistor 2 kΩ (vermelho-pretovermelho) para conectar P2 para seu LED IV e P8 para LED de IV.
Queremos que o Boe-Bot seja míope para essa atividade.
Reconecte a energia de sua placa
Execute o programa IrInterferenceSniffer.bs2 (pagina 299) para
certificar-se de que a iluminação fluorescente próxima não irá
interferir nos detectores infravermelhos do seu Boe-Bot.
Use o TestBothIrAndIndicators.bs2 (página 297) para certificar-se de
que o Boe-Bot detecta a placa de cartolina, mas não detecta a fita
isolante.
Se o Boe-Bot ainda "detecta" a fita isolante muito claramente, aqui estão
algumas soluções:




Tente ajustar os detectores infravermelhos e LEDs para baixo em
vários ângulos.
Tente uma marca diferente de fita isolante de vinil.
Tente substituir as duas resistências 2 kΩ com 4.7 kΩ (amarelovermelho-violeta) dos resistores para fazer o Boe-Bot mais míope.
Ajuste o comando FREQOUT Freq1 com diferentes argumentos.
Aqui estão alguns argumentos que farão o Boe-Bot mais míope:
38250, 39500, 40500
Se você estiver usando LEDs IV mais antigos, o Boe-Bot pode realmente estar
tendo problemas estando muito míope. Aqui estão alguns remédios que
aumentam a sensibilidade do Boe-Bot aos objetos e fazê-los visto mais de
longe
 Tente 1 kΩ (marrom-preto-vermelho) ou 470 Ω (amarelo-violetamarrom) ou até 220 Ω (vermelho-vermelho-marrom) resistores em
série com os LEDs IV em vez de 2 kΩ.
22” (56 cm)
22” (56 cm)
Figura 7-12
Fita de contorno
elétrico simulando a
ponta da mesa
Você pode tentar sobre uma mesa, depois que tiver sucesso com o curso da
fita isolante

Lembre-se de seguir as mesmas etapas seguidas antes de executar o
Boe-Bot no curso delimitado da fita isolante!
Certifique-se de observar o seu Boe-Bot. Observe como seu Boe-Bot percorre
a mesa:


Esteja sempre pronto para agarrar o seu Boe-Bot de cima da mesa,
uma vez que se aproxima da borda da mesa. Se o Boe-Bot tenta
conduzir para fora da borda, pegá-lo antes dele cair.
O Boe-Bot pode detectar se você está em pé na sua linha de visão.
Seu programa atual não tem como diferenciar entre você e a mesa,
ele pode tentar continuar para a frente e para fora da borda da mesa.
Então, fique fora da linha de seu detector de visão do local.
Programa de Detecção de Queda
Para a maior parte, programar seu Boe-Bot para andar em torno de uma
mesa, sem chegar perto da borda é uma questão de ajustà-lo IF...THEN
uma declarações de FastIrNavigation.bs2. O ajuste principal é que os servos
devem ser encaminhados para fazer o Boe-Bot rolar para a frente quando
irDetectLeft e irDetectRight são ambos 0, indicando que um objeto
(na superfície da mesa) foi detectado. O Boe-Bot tem também que se afastar
de um detector que indica que ele não detectou um objeto. Por exemplo, se
irDetectLeft é 1, o Boe-Bot tende a virar melhor à direita.
A segunda característica de um programa para afastar-se de quedas é a
distância ajustável. Você pode querer que o seu Boe-Bot tenha apenas um
pulso para a frente entre a verificação dos detectores, mas quando uma
queda é detectada, você pode querer que o seu Boe-Bot tenha vários pulsos
de uma vez antes de verificar os detectores de novo.
Só porque você está comandando vários pulsos em uma manobra evasiva,
isso não significa que você tem que voltar para o estilo de navegação com
bigodes. Em vez disso, você pode adicionar uma variável pulseCount que
você pode usar para definir o número de pulsos de uma manobra. O
comando PULSOUT pode ser colocado dentro de um FOR ... NEXT Loop
que executa FOR 1 a pulseCount pulsos. Para um impulso para frente,
pulseCount pode ser 1, durante dez impulsos restantes, pulseCount pode
ser ajustado para 10, e assim por diante.
Exemplo de Programa – AvoidTableEdge.bs2
 Abra FastIrNavigation.bs2 e salve como AvoidTableEdge.bs2.
 Modifique o programa para que ele corresponda ao programa de
exemplo. Isso vai envolver a adição de variáveis, modificando as
declarações IF…THEN, e a abrigo do comando PULSOUT dentro do
FOR…NEXT loop. Tenha o cuidado de certificar-se sobre todos os
valores das variáveis pulseLeft e pulseRight dentro do IF ...
THEN estão ajustadas corretamente. Seus valores são diferentes do
FastIrNavigation.bs2 porque as regras do curso são diferentes.
 Reconecte sua placa e servos.
 Teste o programa em seu curso delimitado por fita isolante
 Se você decidir tentar sobre uma mesa, lembre-se de seguir os testes
e dicas discutidos anteriormente.
' Robótica com o Boe-Bot - AvoidTableEdge.bs2
' IV detecta o objeto na borda e navega para evitar o drop-off.
' {$STAMP BS2}
' {$PBASIC 2.5}
irDetectLeft
irDetectRight
pulseLeft
pulseRight
loopCount
pulseCount
VAR
VAR
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
Byte
Byte
FREQOUT 4, 2000, 3000
' Declaração de variáveis.
DO
' Rotina principal.
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
' Checar o IV detectores.
' Decidir navegação.
IF (irDetectLeft = 0) AND (irDetectRight = 0) então
pulseCount = 1
' ambos detectados,
pulseLeft = 850
' um pulso para frente.
pulseRight = 650
ELSEIF (irDetectLeft = 1) AND (irDetectRight = 1) em seguida 'não detectad
pulseCount = 15
' volte para cima e tente novamente.
pulseLeft = 650
pulseRight = 850
' direita não detectada,
pulseCount = 10
' 10 pulsos a esquerda.
pulseLeft = 650
pulseRight = 650
ELSE
' Esquerda não detectado,
pulseCount = 10
' 10 pulsos a direita.
pulseLeft = 850
pulseRight = 850
ENDIF
FOR loopCount = 1 TO pulseCount
PAUSE 20
NEXT
' Enviar pulseCount pulsos
LOOP
Como Funciona AvoidTableEdge.bs2
Uma vez que este programa é uma versão modificada do
FastIrRoaming.bs2, apenas mudanças no programa são discutidas aqui.
Um FOR ... NEXT Loop é adicionado ao programa para controlar quantos
pulsos são entregues a cada momento através da rotina principal (DO ...
LOOP). Duas variáveis são adicionadas; funções LoopCount como um índice
para um FOR ... NEXT Loop e pulseCount para o argumento EndValue.
loopCount
VAR
Byte
pulseCount
VAR
Byte
O argumento IF…THEN agora define o valor da pulseCount bem como
pulseRight e pulseLeft. Se ambos os detectores podem ver a mesa,
tomar um pulso cauteloso para a frente.
Se (irDetectLeft = 0) e (irDetectRight = 0) em
seguida
pulseCount = 1
pulseLeft = 850
pulseRight = 650
Outra coisa, se nem o detector IV ver a mesa, volta-se a 15 pulsos e tente de
novo, na esperança de que um dos detectores vejam a queda antes do outro.
ELSEIF (irDetectLeft = 1) AND (irDetectRight = 1)
THEN
pulseCount = 15
pulseLeft = 650
pulseRight = 850
Caso contrário, se apenas o detector IV direito não vê a mesa, girar para a
esquerda 10 pulsos.
pulseCount = 10
pulseLeft = 650
pulseRight = 650
Caso contrário, se apenas o detector IV esquerda não vê a mesa, então girar
para a direita de 10 pulsos.
ELSE
pulseCount = 10
pulseLeft = 850
pulseRight = 850
ENDIF
Agora que o valor de pulseCount, pulseLeft e pulseRight foram
definidos, neste FOR ... NEXT LOOP, distribua o número especificado de
impulsos para a manobra determinada pela pulseLeft, pulseRight e
variáveis.
FOR loopCount = 1 TO pulseCount
PAUSE 20
NEXT
Sua Vez
Você pode experimentar uma criação diferente de valores de pulseLeft,
pulseRight, dentro da declaração IF…THEN. Por exemplo, se o Boe-Bot
não anda tão longe, pode efetivamente controlar a extremidade na borda do
curso delimitado da fita isolante. Girando para trás ao invés de girar no
lugar, isto também pode levar a alguns comportamentos interessantes.
 Modifique AvoidTableEdge.bs2 então ele seguirá a borda do curso
delimitado da fita isolante. Curso delimitado ajustando os valores
pulseCount para que o Boe-Bot não ande muito longe em direção a
borda.
 Experiência com giro de uma forma a fazer com que o Boe-Bot
percorra dentro do perímetro em vez de seguir para borda.
SUMÁRIO
Este capítulo abordou uma técnica única para detecção de objetos
infravermelho que utiliza o LED infravermelho encontrados em controles
remotos portáteis comuns, e o detector infravermelho encontrado em TVs,
CD / DVD players, e outros aparelhos que são controlados por esses
controles remotos. Brilhando em infravermelho a caminho do Boe-Bot e
olhando para a sua reflexão, a detecção de objetos pode ser realizada sem
tocar o objeto. Circuitos de LED de infravermelhos são utilizados para
enviar um sinal de 38,5 KHz, com a ajuda de uma propriedade do comando
FREQOUT chamado 'harmônica', que é inerente à sinais digitais sintetizados.
Um programa indicador de detecção de infravermelho foi introduzido para
testes remotos (não ligado ao PC) do LED IR / detector de pares. Um
programa que fareja interferência de infravermelho também foi introduzido
para ajudar a detectar interferências que podem ser geradas por algumas
luminárias fluorescentes. Uma vez que os sinais emitidos pelos detectores de
IV são tão semelhantes aos sinais enviados pelos bigodes, o
RoamingWithWhiskers.bs2 foi adaptado para os detectores de
infravermelhos. Um programa que verifica os detectores de infravermelho
entre cada pulso do servo foi introduzido para demonstrar uma forma de
maior desempenho de navegação sem colidir em objetos. Este programa foi
então modificado para evitar que a extremidade de uma área seja delimitada
por fita isolante. Desde que a fita isolante absorva o infravermelho,
emoldurando uma grande folha de papel de construção simula a queda que é
vista na borda de uma mesa, sem perigo real para o Boe-Bot.
Questões
1. Qual é a frequência do sinal enviado por FREQOUT 2, 1, 38500?
Qual é o valor da segunda frequência de comando enviada por ele?
Quanto tempo duram esses sinais enviados? Qual o pino I / O que o
circuito LED IV tem que ser ligado para transmitir este sinal?
2. O comando tem que seguir imediatamente para o comando FREQOUT,
a fim de determinar com precisão se foi ou não detectado um objeto?
3. O que significa se o detector IV enviar um sinal de baixa? O que
significa quando o detector emite um sinal de alta?
4. O que acontece se você alterar o valor de um resistor em série com
um LED vermelho? O que acontece se você alterar o valor de um
resistor em série com um LED infravermelho?
Exercícios
1. Modificar uma linha de código em IrInterferenceSniffer.bs2 para que
ele monitore apenas um dos detectores de infravermelho.
2. Explicar a função de pulseCount em AvoidTableEdge.bs2.
Projetos
1. Projetar um aplicativo para que o Boe-Bot fique parado até que você
acene com a mão na frente dele, então ele começa a andar.
2. Projetar um aplicativo para que o Boe-Bot gire lentamente no local
até que ele detecte um objeto. Assim que detectar um objeto, ele
bloqueia a entrada e persegue o objeto. Este é um comportamento
'SUMOBOT' clássico.
3. Projetar um aplicativo para que o Boe-Bot ande, mas se detectar
interferência de infravermelho, soa um alarme rapidamente e, em
seguida, continua andando. Este alarme deve ser diferente do alarme
da bateria fraca.
Soluções
Q1. 38,5 kHz é a frequência do sinal. A segunda frequência = 65536-
38500 = 27.036 Hz. Os sinais são enviados por um milissegundo, e o
LED de IV deve ser ligado à I / O pino P2.
Q2. O comando que armazena a saída do sensor em uma variável. Por
exemplo, irDetectLeft = IN9.
Q3. Um sinal de baixa significa que RI a 38,5 kHz foi detectado, assim,
um objeto foi detectado. Um sinal de alta significa que não há IV em
38.5kHz e nada foi detectado, por isso, não há nenhum objeto.
Q4. Eletricamente falando, tanto para os LEDs vermelho e
infravermelho, um resistor menor fará com que o diodo emissor de
luz brilhe mais intensamente. Um grande resistor resulta em dimmer
LEDs.
Q5. Em termos de resultados, os brilhantes LEDs infravermelhos
permitem detectar objetos que estão mais longe.
E1. Altere o IF ... THEN para ler:
IF (IN0 = 0) THEN
E2. O programa define esta variável para 1 quando ele está tomando um
impulso para a frente. Dessa forma, como o Boe-Bot avança, ele
verifica se há uma queda entre cada pulsação. Quando ele detecta
uma queda, executa uma volta para um determinado número de
impulsos, que é também determinada pelo valor da variável de
pulseCount.
P1. O programa FastIrRoaming.bs2 pode ser combinado com um DO
... LOOP UNTIL loop que não faz nada, até detectar um objeto.
Uma solução de amostra é mostrada abaixo.
'
'
'
'
-----[ Titulo ]---------------------------------------------------Robótica com o Boe-Bot - MotionActivatedBoeBot.bs2
Boe-Bot começa a andar quando a mão é acenou na frente dos detectores
de infravermelho.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Variaveis ]--------------------------------------------------irDetectLeft
irDetectRight
pulseLeft
pulseRight
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
' declarações de variáveis
' -----[ Inicialização ]---------------------------------------------DEBUG "Program Running!"
FREQOUT 4, 2000, 3000
start/reset.
' Sinal de programa
' -----[ rotina principal ]--------------------------------------------Main:
' Loop until something is detected
DO
GOSUB Check_IRs
LOOP UNTIL (irDetectLeft = 0) OR (irDetectRight = 0)
' Now start roaming -- this code from FastIrRoaming.bs2
DO
IF (irDetectLeft = 0) AND (irDetectRight = 0) Então
pulseLeft = 650
' Ambos detectam
pulseRight = 850
' de volta para cima
' detetar esquerda
pulseLeft = 850
' voltar a direita
pulseRight = 850
' deletar a direita
pulseLeft = 650
' voltar a esquerda
pulseRight = 650
ELSE
' nada deletado
pulseLeft = 850
' ir para frente
pulseRight = 650
ENDIF
PAUSE 15
GOSUB Check_IRs
LOOP
' Aplicar o pulso
' Cheque IVs novamente
' -----[ Sub-Rotinas ] -----------------------------------------------Check_IRs:
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
IrDetectRight = IN0
RETURN
' Cheque IV Detectores
P1. Este comportamento é, em muitos aspectos, o oposto do
comportamento de caminhada abordado neste capítulo. Em vez de
evitar objetos, o Boe-Bot tenta ir em direção aos objetos. Por esta
razão, o código principal pode ser derivado a partir de
FastIrRoaming.bs2, com um bit adicional, que gira o Boe-Bot
lentamente até que seja detectado um objeto. Na solução a seguir,
uma vez que o Boe-Bot tem espiado um objeto, ele vai continuar em
frente, mesmo que os detectores leiam "nenhum objeto" (1) por
alguns loops. Isto porque, como o Boe-Bot está manobrando em
direção ao objeto, às vezes, os detectores lêem "nenhum objeto" por
breves momentos, mas isso não é motivo suficiente para desistir da
perseguição.
'
'
'
'
Robotica com o Boe-Bot - SumoBoeBot.bs2
Procurando objeto, mirando e empurrando
{$STAMP BS2}
{$PBASIC 2.5}
irDetectLeft
irDetectRight
pulseLeft
pulseRight
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
' esquerda IV lendo
' direita IV lendo
' valores de pulsos para servos
' -----[ Inicialização ]---------------------------------------------DEBUG "Programa funcionando!"
FREQOUT 4, 2000, 3000
' Sinal start/reset.
' -----[ Rotina principal ]--------------------------------------------Main:
' Girar lentamente, até que um objeto seja visto
DO
PULSOUT 13, 790
'gire lentamente
PULSOUT 12, 790
PAUSE 15
' 5 ms para detectores
GOSUB Check_IRs
' Ao olhar para o objeto
LOOP UNTIL (irDetectLeft = 0) OR (irDetectRight = 0)
' Agora descobrir exatamente onde o objeto está e ir em direção a ele
DO
' Object in both detectors -- go forward
pulseLeft = 850
' para frente
pulseRight = 650
' Object on left - go left
pulseLeft = 650
' a esquerda em direção ao objeto
pulseRight = 650
' Object on right - go right
pulseLeft = 850
' a direita em direção ao objeto
pulseRight = 850
' Nenhum objeto - ir para a frente de qualquer maneira, porque os
detectores vão:
ELSE
' mostrar momentaneamente
pulseLeft = 850
' "enhum objeto”
pulseRight = 650
' Boe-Bot esta ajustando
ENDIF
' sua posição
' Aplicar os pulsos
PAUSE 15
' 5 ms para detectores
' Check IRs again in case object is moving
GOSUB Check_IRs
LOOP
' -----[ Subrotinas ] -----------------------------------------------Check_IRs:
FREQOUT 8, 1, 38500
FREQOUT 2, 1, 38500
IrDetectRight = IN0
RETURN
' Cheque IV Detectores irDetectLeft = IN9
P2. A chave para resolver este problema é combinar FastIrRoaming.bs2
e IrInterferenceSniffer.bs2 em um único programa.
' -----[ Title ]------------------------------------------------------' Robotica com o Boe-Bot - RoamAndSniffBoeBot.bs2
' Boe-Bot anda por aí e soa o alarme quando IV detectado.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Variaveis ]--------------------------------------------------irDetectLeft
irDetectRight
pulseLeft
pulseRight
counter
VAR
VAR
VAR
VAR
VAR
Bit
Bit
Word
Word
Nib
' esquerda IV sensorlendo
' direita IV sensor lendo
' Pulsos mandados para os servos
' contador de loop
' -----[ Inicialização ]---------------------------------------------DEBUG "Program Running!"
FREQOUT 4, 2000, 3000
' -----[ Rotina principal ]--------------------------------------------Main:
DO
GOSUB Roam
GOSUB Sniff
LOOP
' -----[ Subrotinas ] -----------------------------------------------Sniff:
' de IrInterferenceSniffer.bs2
IF (IN0 = 0) OR (IN9 = 0) THEN
HIGH 1
HIGH 10
FREQOUT 4, 50, 4000
LOW 1
LOW 10
PAUSE 20
NEXT
ENDIF
RETURN
Roam:
FREQOUT 8, 1, 38500
irDetectLeft = IN9
FREQOUT 2, 1, 38500
irDetectRight = IN0
'Bip 5 vezes
' e flashs LEDs
' de FastIrRoaming.bs2
' Cheque IV Detectores
' Decida como navegar.
pulseLeft = 650
pulseRight = 850
pulseLeft = 850
pulseRight = 850
pulseLeft = 650
pulseRight = 650
ELSE
pulseLeft = 850
pulseRight = 650
ENDIF
PAUSE 15
RETURN
' Aplicar o pulso.
Controle do Robô de Detecção de Distância · Página 325
Capítulo 8: Controle do Robô de Detecção de Distância
No Capítulo 7, foram utilizados os LEDs infravermelhos e receptores para
detectar se um objeto está em forma do Boe-Bot sem realmente tocá-lo. Não
seria bom também saber o quão longe o objeto está? Isso geralmente é uma
tarefa para o sonar, o qual envia um pulso de saída de som e registros para
ver quanto tempo leva para o eco voltar. O tempo que leva para que o eco
volte pode então ser usado para calcular a distância que o objeto está. Existe,
no entanto, uma forma de realizar a detecção à distância com o mesmo
circuito que utilizou no capítulo anterior. Com o seu Boe-Bot apto para
determinar a distância de um objeto, ele pode ser programado para seguir
um objeto em movimento, sem colidir nele. O Boe-Bot também pode ser
programado para seguir faixas pretas sobre um fundo branco.
Determinando a Distância com o Mesmo Circuito Detector/Led IV1
Você vai usar o mesmo circuito do capítulo anterior para detectar a
distância.
 Se o circuito ainda está construído em seu Boe-Bot, verifique se o
LED IV tem um resistor em série 1 kΩ
 Se você já desmontou o circuito do capítulo anterior, repita os passos
do Capítulo 7, atividade n # 1, na página 287.
Equipamentos e Materiais Recomendados:
(1) Régua
(1) Folha de papel
1
Infravermelho.
ATIVIDADE #1: TESTANDO A VARREDURA DE FREQUÊNCIA
Figura 8-1 mostra um trecho de uma marca específica de folha de dados do
IV detector (Panasonic PNA4602M; uma marca diferente pode ter sido
usada em seu kit). Este trecho é um gráfico que mostra o quanto menos
sensível o detector IV torna-se se o sinal IV que ele recebe pisca
ligado/desligado em uma frequência diferente de 38,5 kHz. Por exemplo, se
você enviar um sinal a 40 kHz e o IV piscar ligado/desligado, está apenas
50% sensível quanto seria a 38,5 kHz. Se o IV piscou ligado/desligado a 42
kHz, o detector está apenas 20% sensível. Especialmente para as frequências
que compõem o detector menos sensível, o objeto tem que estar mais perto
para aumentar o brilho do IV refletido para o detector poder detectá-lo.
Figura 8-1
Sensibilidade do filtro
depende da frequência que
ele porta
Outra maneira de pensar sobre isso, é que a frequência mais sensível irá
detectar os objetos que estão mais distantes, enquanto que as frequências
menos sensíveis só podem ser usadas para detectar objetos mais próximos.
Isso faz a detecção de distância simples. Escolha cinco frequências, em
seguida, teste-as de mais sensíveis para menos sensíveis. Tente em primeiro
lugar a frequência mais sensível. Se for detectado um objeto, verifique e veja
se a próxima frequência mais sensível detecta-o. Dependendo da frequência
que fizer o infravermelho refletido não ser visível para o detector IV, podese inferir a distância.
Varredura de frequência é a técnica de testar a saída de um circuito
usando uma variedade de frequências de entrada
Programação de Varredura de Frequência para Detecção de Distância
Figura 8-2 mostra um exemplo de como o Boe-Bot pode testar a distância
por meio de frequência. Neste exemplo, o objeto está na Zona 3. Isso
significa que o objeto pode ser detectado quando transmitido em 37500 e
38250 Hz, mas não pode ser detectado com 39500, 40500, e 41500 Hz. Se
você tivesse que mover o objeto na Zona 2, assim, o objeto pode ser
detectado quando 37.500, 38.250 e 39.500 Hz são transmitidos, mas não
quando 40.500 e 41.500 Hz são transmitidos.
Figura 8-2 Detecção de distância, frequência e zonas para o Boe-Bot
Object
15 14
Vd d
13 12
Red
Black
X4
Vdd
X5
Vin
Vs s
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Zone 0
41500 Hz
+
Bo ar d o f Ed u cati on
© 20 00 -2 00 3
Zone 1
40500 Hz
Zone 3
Zone 2
39500 Hz 38250 Hz
Zone 4
37500 Hz
Zone 5
No Detection
at any
Frequency
Você pode estar se perguntando por que o valor da zona 4 é de 37,5 kHz e
não 38,5 kHz. A razão pela qual eles não são os valores que você esperaria
com base no gráfico% de sensibilidade é porque o comando FREQOUT
transmite um sinal ligeiramente mais potente em 37.5 kHz do que ele faz em
38,5 kHz. As frequências listadas na Figura 8 são duas frequências que você
vai programar o BASIC Stamp para determinar a distância de um objeto.
A fim de testar o detector de IV em cada frequência, você vai precisar usar
FREQOUT para enviar cinco frequências e testar diferentes objetos em cada
uma delas para descobrir se o detector IV poderá vê-las. Os passos entre
cada frequência não são suficientes para usar a opção FOR ... NEXT Loop
e STEP. Você pode usar DATA e READ, mas isso seria complicado. Você pode
usar cinco comandos FREQOUT diferentes, mas isso seria um desperdício de
espaço de código. Em vez disso, a melhor abordagem para armazenar uma
pequena lista de valores que você deseja usar na sequência é um comando
chamado LOOKUP. A sintaxe para o comando de pesquisa LOOKUP é:
LOOKUP Index, [Value0, Value1, …ValueN], Variable
Se o argumento índice (Index) é 0, Value0 da lista, dentro dos colchetes,
será colocado em variável. Se o índice é 1, Value1 da lista será colocado em
variável. Poderia haver até 256 valores na lista, mas para o próximo
programa de exemplo, só precisaremos de 5. Aqui está como ele será
utilizado:
FOR freqSelect = 0 TO 4
LOOKUPfreqSelect,[37500,38250,39500,40500,41500],irFrequency
FREQOUT 8,1, irFrequency
irDetect = IN9
'Comandos não são mostrados...
NEXT
A primeira vez através do loop FOR ... NEXT, freqSelect é 0, portanto,
o comando LOOKUP coloca o valor 37500 na variável irFrequency. Desde
irFrequency contém 37.500 após o comando LOOKUP, o comando envia
FREQOUT a frequência do LED IV conectado a P8. Como no capítulo
anterior, o valor da IN9 é então guardado na variável irDetect. O segundo
tempo através do FOR ... NEXT LOOP. Em seguida, o valor de
freqSelect é agora 1, o que significa que o comando LOOKUP coloca
38250 na variável irFrequency, e o processo é repetido para essa
frequência mais elevada. A terceira vez, ele é repetido novamente com
39500, e assim por diante. O resultado é notável, especialmente
considerando que você está usando peças que foram projetadas para um
propósito completamente diferente, para tornar possível a comunicação entre
um
IV
remoto
portátil
e
uma
televisão.
Exemplo de Programa – TestLeftFrequencySweep.bs2
O programa TestLeftFrequencySweep.bs2 faz duas coisas. Primeiro, ele
testa o detector de IV a esquerda (ligado ao P8 e P9) para se certificar de que
está funcionando corretamente para a detecção de distância. No entanto,
também demonstra como é o varrimento de frequência é realizado, ilustrado
na
Figura
8-2.
Quando você executa o programa, o DEBUG Terminal exibirá sua zona de
medição. Existem muitos sim-não padrões possíveis que podem ser gerados,
dois são mostrados na figura 8-3. Os padrões de teste irão variar dependendo
das características do filtro no interior do detector de IV.
O programa determina que zona o objeto detectado está através da contagem
do número de ocorrências "Não". Observe que, embora os dois padrões de
teste do DEBUG Terminal na Figura 8-3 sejam diferentes, ambos têm três
"Sim" e "Não" nas duas ocorrências. Portanto, "Zona 2" é a localização do
objeto detectado em ambos os exemplos.
 Coloque, salve e execute o programa TestLeftFrequencySweep.bs2.
 Use uma folha de papel ou cartão em frente do LED IV / detector
para testar a detecção à distância.
 Comece com a folha muito perto do LED IV, talvez, ¼ de polegada,
(ou 1 cm) de distância a partir do LED infravermelho. A sua zona do
DEBUG Terminal deverá ser ou 0 ou 1.
 Gradualmente mova a folha de papel para longe do LED IV e faça
uma anotação de cada distância que faz para que o valor do fuso
obtido seja maior.
Figura
8-3
Teste de
distância
de
detecção
Exemplo
s de saída
Tenha em mente que essas medidas de distância são relativas e não
necessariamente precisas ou uniformemente espaçadas. No entanto, elas
vão dar o Boe-Bot um bom senso suficiente de distância do objeto para o
acompanhamento e controle de outras atividades.
As zonas 1-4 caem tipicamente no intervalo de 6 a 12 cm (15 a 30 cm) para os
LEDs blindados com uma resistência de 1 kW. Contanto que os objetos
possam ser detectados até 4 cm (10 cm) de distância, as experiências neste
capítulo funcionarão. Se o intervalo de detector de distância é menor do que
isso, tentar reduzir a sua resistência em série a partir de 1 kΩ para 470 Ω ou
220 Ω.
' -----[ Titulo ]-----------------------------------------------------------' Robótica com o Boe-Bot - TestLeftFrequencySweep.bs2
' Teste detector IV de distância responsável pela frequência de varredura.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Variáveis ]--------------------------------------------------------freqSelect
VAR
irFrequency VAR
irDetect
VAR
distance
VAR
Nib
Word
Bit
Nib
' -----[ Inicialização ]----------------------------------------------------DEBUG CLS,
"
OBJECT", CR,
"FREQUENCY DETECTED", CR,
"--------- --------"
' -----[ Rotina principal ]-------------------------------------------------DO
distance = 0
LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency
irDetect = IN9
distance = distance + irDetect
DEBUG CRSRXY, 4, (freqSelect + 3), DEC5 irFrequency
DEBUG CRSRXY, 11, freqSelect + 3
IF (irDetect = 0) THEN DEBUG "Yes" ELSE DEBUG "No "
PAUSE 100
NEXT
DEBUG CR,
"--------- --------", CR,
"Zone
", DEC1 distance
LOOP
Sua Vez– Testando o LED IV à Direita / Detector de Objeto
Embora haja alguma rotulagem envolvida, você pode modificar este
programa para testar o LED IV a direita e o detector alterando estas duas
linhas:
irDetect = IN9
... Para que eles leiam:
irDetect = IN0
 Modifique TestLeftFrequencySweep.bs2 para testar a medição de
distância do detector IV direito do objeto
 Execute o programa e verifique se ele pode medir uma distância
similar.
Exibindo Ambas as Distâncias
É útil, por vezes, ter um programa rápido para você poder testar ambos
detectores de distância do Boe-Bot ao mesmo tempo. Este programa é
organizado em sub-rotinas, que podem ser úteis para copiar e colar em
outros programas que requeiram detecção à distância.
Exemplo de Programa – DisplayBothDistances.bs2
 Coloque, salve e execute o programa DisplayBothDistances.bs2.
 Repetir o exercício de medição de distância, com uma folha de papel
em cada LED, em seguida, ambos os LEDs ao mesmo tempo.
'
'
'
'
'
-----[ Título ]-----------------------------------------------------------Robótica com o Boe-Bot - DisplayBothDistances.bs2
Teste detector IV de distância responsável por ambos os detectores de
objetos IV para
Varredura de frequência.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Variável ]---------------------------------------------------------freqSelect
irFrequency
irDetectLeft
irDetectRight
VAR
VAR
VAR
VAR
Nib
Word
Bit
Bit
distanceLeft VAR
distanceRight VAR
Nib
Nib
' -----[ Inicialização ]----------------------------------------------------DEBUG CLS,
"IR OBJECT ZONE", CR,
"Left Right", CR,
"----- -----"
' -----[ Rotina Principal ]-------------------------------------------------DO
GOSUB Get_Distances
GOSUB Display_Distances
LOOP
' -----[ Sub-rotina – Obter Distâncias ]------------------------------------Get_Distances:
distanceLeft = 0
distanceRight = 0
FREQOUT 8,1,irFrequency
irDetectLeft = IN9
distanceLeft = distanceLeft + irDetectLeft
irDetectRight = IN0
distanceRight = distanceRight + irDetectRight
PAUSE 100
NEXT
RETURN
' -----[ Sub-rotina – Exibir Distâncias ]-----------------------------------Display_Distances:
DEBUG CRSRXY,2,3, DEC1 distanceLeft,
CRSRXY,9,3, DEC1 distanceRight
RETURN
Sua Vez – Mais Testes de Distância
 Tente medir a distância de objetos diferentes e descobrir se a cor e /
ou textura faz qualquer diferença para a medição da distância.
ATIVIDADE #2: VEÍCULO SOMBRA BOE-BOT
Para um Boe-Bot seguir outro Boe-Bot, o que segue, também conhecido
como “veículo sombra”, tem que saber quão distante o veículo líder está à
frente. Se o veículo sombra está atrasado, o programa tem que detectar isso e
acelerar. Se o veículo sombra está muito perto do veículo da frente, o
programa tem que detectar isso também e diminuir a velocidade. Se a
distância está certa, ele pode esperar até que as medições indiquem que está
muito longe ou muito perto novamente.
A distância é apenas um tipo de valor que os robôs e outras máquinas
automatizadas são responsáveis. Quando uma máquina é projetada para
manter automaticamente um valor, tal como a distância, pressão ou o nível
de fluido, geralmente envolve um sistema de controle. Estes sistemas
consistem, por vezes, de sensores e válvulas, ou sensores e motores, ou, no
caso de o Boe-Bot, sensores e servos de rotação contínua. Há também alguns
tipos de processadores que pegam as medições dos sensores e os converte a
uma ação mecânica. O processador tem que ser programado para tomar
decisões com base nas entradas de sensores e controles das saídas mecânicas
em conformidade. No caso do Boe-Bot, o processador é o BASIC Stamp 2.
Controle “Closed loop” é um método comum de manter os níveis, e ele
funciona muito bem para ajudar o Boe-Bot manter a distância de um objeto.
Há vários diferentes tipos de controle de Loop fechado. Alguns dos mais
comuns são histerese, proporcional, integral e controle derivativo. Todos
esses tipos de controle são apresentados detalhadamente na aula “Process
Control” do Basic Stamp, listada no Prefácio.
A maioria das técnicas de controle pode ser implementada com apenas
algumas linhas de código em PBASIC. De fato, a maioria dos circuitos de
controle proporcional representado na figura 8-4 reduz-se apenas uma linha
de código PBASIC. Este diagrama é chamado de diagrama de 'bloco', e
descreve as etapas do processo de controle proporcional que o Boe-Bot vai
usar para medir a distância através do LED IV direito, o seu detector e
ajustar a posição a fim de manter a distância com o seu servo motor direito.
Center pulse width
750
Error = -2
+
-
Kp X error
35 X -2
Output
adjust
-70
+
+
Right servo
output
680
Measured right
distance = 4
System
Figura 8-4
Diagrama de
blocos de
controle
proporcional
para Servo
Direito, LED
IV e Detector
de Objeto
Vamos dar uma olhada nos números na Figura 8- 4 e aprender como o
controle proporcional trabalha. Este exemplo em particular é para o LED IV
direito, seu detector e o servo direito. O ponto de ajuste é designado como 2,
o que significa que queremos que o Boe-Bot mantenha uma zona de
distância de 2 entre si e qualquer objeto que detectar. A distância da zona
medida foi de 4, o que é muito distante. O erro é o ponto de ajuste menos a
distância medida, que é de 2 - 4 = -2. Isto é indicado pelos símbolos dentro
do círculo na esquerda. Este círculo é chamado de "somador”. Na sequência,
o erro alimenta um bloco do operador. Este bloco mostra que o erro será
multiplicado por um valor chamado de “constante proporcional” (Kp). O
valor de Kp é 35. A saída do bloco mostra o resultado de -2 × 35 = -70, o
que é chamado de "saída de ajuste”. Esta saída vai para ajustar um outro
somador e, desta vez, é adicionada ao centro da largura de pulso do servo
que é 750. O resultado é uma largura de pulso 680 que fará com que o servo
gire ¾ de volta no sentido horário. Isso faz a roda direita do Boe-Bot girar
para a frente, em direção ao objeto. Esta correção entra no sistema, que
consiste no Boe-Bot, e o objeto, que foi medido a uma distância de 4.
Na próxima interação do loop, a distância de medida pode mudar, mas tudo
bem, porque independentemente da distância medida, este loop de controle
irá calcular um valor que fará com que o servo se mova para corrigir
qualquer erro. A correção é sempre proporcional ao erro, que é a diferença
entre
o
ponto
de
referência
e
as
distâncias
medidas.
Um circuito de controle tem sempre um conjunto de equações que governam
o sistema. O diagrama de blocos na figura 8-4 é um modo de descrever
visualmente este conjunto de equações. Aqui estão as equações que podem
ser tomadas a partir deste diagrama de blocos, juntamente com soluções.
Erro
Ajustar a saída
Ajustar servo direito
=
=
=
=
=
=
=
=
definir o ponto de distância da direita – medir distância direita
2–4
error × Kp
–2 × 35
– 70
ajuste de saída + largura de pulso do centro
– 70 + 750
680
Ao fazer algumas substituições, as três equações acima podem ser reduzidas
a esta, o que dará o mesmo resultado.
Saída servo direito
=
(definir o ponto de distância a direita – medir a distância direita)
* Kp + pulso da largura do centro
Substituindo os valores do exemplo, podemos ver que a equação ainda
funciona:
=
=
((2 – 4) × 35) + 750
680
O servo esquerdo e o detector de objeto IV tem um algoritmo semelhante ao
mostrado na Figura 8-5. A diferença é que Kp é -35 ao invés de +35.
Assumindo o mesmo valor medido para o detector de objeto IV direito a
saída de ajuste dos resultados é uma largura de pulso de 820. Aqui está a
equação e cálculos para este diagrama de blocos:
Saída do servo esquerdo = (ponto de distância da esquerda – Medida de distância da
esquerda) * Kp + pulso de largura do centro
= ((2 – 4) × –35) + 750
= 820
O resultado deste controle de loop é uma largura de pulso que faz com que o
servo esquerdo gire cerca de ¾ de volta no sentido anti-horário a velocidade
máxima. Este também é um pulso para a frente na roda esquerda. A ideia de
feedback de retorno é que a saída do sistema é re-amostrada, pelo veículo
sombra Boe-Bot, e tomará outra medida de distância. Em seguida, o loop de
controle se repete de novo e de novo e de novo... cerca de 40 vezes por
segundo.
Center pulse width
750
Error = -2
+
-
Kp X error
-35 X -2
Output
adjust
+70
+
+
Left servo
output
820
Measured left
distance = 4
System
Programação do Veículo Sombra Boe-Bot
Lembre-se que a equação para a saída do servo direito foi:
Figura 8-5
Diagrama de
blocos de
controle
proporcional
para o Servo
Esquerdo,
LED IV e
Detector de
Objeto
Servo de saída da direita
=
(ponto de definição da distância à direita–Medida da
distância à direita) * Kp + largura de centro do puls
Aqui está um exemplo de resolução desta mesma equação PBASIC. O ponto
de ajuste direito tem uma distância de 2, a distância medida é uma variável
denominada “distanceRight” que vai armazenar a medição de distância
IV, Kp é 35, e a largura do centro de pulso é 750:
pulseRight = 2 - distanceRight * 35 + 750
Lembre-se que em PBASIC expressões matemáticas são executadas a partir
da esquerda para a direita. Primeiro, o valor de “distanceRight” é
subtraído de 2. O resultado desta subtração é então multiplicado por Kpr, que é
35 e, depois disso, a multiplicação é adicionada ao centro da largura de pulso
750.
Você pode usar parênteses para antecipar um cálculo, isto é, trazer para o início
algum cálculo originalmente mais a direita de uma linha de código PBASIC.
Lembre-se deste exemplo: você pode reescrever esta linha de código PBASIC:
pulseRight = 2 - distanceRight * 35 + 750
...assim:
pulseRight = 35 * (2 – distanceRight) + 750
Nesta expressão, 35 é multiplicado pelo resultado de (2 - distanceRight),
e, em seguida, é adicionado a 750.
O servo da esquerda é diferente porque Kp para esse sistema é -35
pulseLeft = 2 - distanceLeft * (-35) + 750
Uma vez que todos os valores -35, 35, 2, e 750 têm nomes, é
definitivamente um bom momento para declarar as constantes.
Kpl
Kpr
SetPoint
CenterPulse
CON
CON
CON
CON
-35
35
2
750
Com estas declarações de constantes no programa, você pode usar o nome
Kpl no lugar de -35, Kpr no lugar de 35, SetPoint no lugar de 2, e
Centerpulse no lugar de 750. Após estas declarações das constantes, os
cálculos de controle proporcionais agora são parecidos com estes:
pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse
pulseRight = SetPoint - distanceRight * Kpr + CenterPulse
O conveniente, em declarar constantes para estes valores, é que você pode
mudá-las em um único lugar no início do programa. As alterações feitas no
início do programa serão refletidas em todos os lugares em que essas
constantes são usadas. Por exemplo, alterando a diretiva CON Kpl de -35
para -40, cada instância Kpl em todo o programa mudará de -35 a -40. Isto é
extremamente útil para testar e ajustar os loops de controle proporcionais
direito e esquerdo.
Exemplo de Programa – FollowingBoeBot.bs2
O programa FollowingBoeBot.bs2 repete o loop de controle proporcional
que acabamos de discutir com cada pulso de servo. Em outras palavras,
antes de cada impulso, a distância é medida e o sinal de erro é determinado.
Então, o erro é multiplicado por Kp, e o valor resultante é adicionado /
subtraído de / para as larguras de pulso que são enviadas para os servos da
esquerda / e da direita.
 Coloque, salve e execute o programa FollowingBoeBot.bs2.
 Aponte o Boe-Bot para uma folha de papel “8 ½ x 11” colocada em
frente dele como se fosse uma muralha. O Boe-Bot deve manter uma
distância fixa entre si e a folha de papel.
 Tente rodar um pouco a folha de papel. O Boe-Bot deve rodar também.
 Tente usar a folha de papel para conduzir o Boe-Bot ao redor. O BoeBot deve segui-la.
 Mova a folha de papel para bem perto do Boe-Bot, e ele deve recuar
para longe do papel.
'
'
'
'
-----[Título ]------------------------------------------------------------Robótica com o Boe-Bot - FollowingBoeBot.bs2
Ajustando as posições do Boe-Bot a fim de manter os objetos detectados na
zona 2.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Constantes ]-------------------------------------------------------Kpl
CON
-35
Kpr
CON
35
SetPoint
CON
2
CenterPulse CON
750
VAR
Nib
irFrequency VAR
Word
irDetectLeft VAR
Bit
irDetectRight VAR
Bit
distanceLeft VAR
Nib
distanceRight VAR
Nib
pulseLeft
VAR
Word
pulseRight
VAR
Word
' -----[ Inicializando ]----------------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Rotina Principal]--------------------------------------------------DO
GOSUB Get_Ir_Distances
' Calculate proportional output.
GOSUB Send_Pulse
LOOP
' -----[ Subrotina - Get IV Distances ]-------------------------------------Get_Ir_Distances:
distanceLeft = 0
distanceRight = 0
irDetectLeft = IN9
irDetectRight = IN0
NEXT
RETURN
' -----[ Subrotina – Get Pulse ]--------------------------------------------Send_Pulse:
PAUSE 5
RETURN
Como o Programa FollowingBoeBot.bs2 Opera:
O programa FollowingBoeBot.bs2 declara quatro constantes, Kpr, Kpl,
Set Point e Centerpulse usando a diretiva COM. Onde quer que você veja
SetPoint, é realmente o número 2 (uma constante). Da mesma forma, em
todos os lugares que você vê Kpl, é realmente o número -35. Kpr na verdade
é 35, e Centerpulse é 750.
Kpl
Kpr
SetPoint
CenterPulse
CON
CON
CON
CON
-35
35
2
750
A primeira coisa que a rotina principal faz é chamar a sub rotina
Get_Ir_Distances. Depois que a sub-rotina Get_Ir_Distances
terminar, “distanceLeft” e “distanceRight” cada uma contém um
número correspondente à zona em que foi detectado um objeto para ambos
detectores de objetos IV tanto o esquerdo como o direito.
DO
As próximas duas linhas de código implementam os cálculos de controle
proporcionais a cada servo.
'Calcular saída proporcional
Agora que os cálculos pulseLeft e pulseRight são feitos, a sub-rotina
Send_Pulse pode ser chamada.
GOSUB Send_Pulse
Uma parcela do LOOP do DO ... LOOP envia imediatamente o programa de
volta para o comando e seguindo o DO no início do loop principal.
LOOP
Sua Vez
A figura 8-6 mostra o Boe-Bot líder seguido pelo veículo sombra. O BoeBot líder está executando uma versão modificada do FastIrRoaming.bs2, e o
sombra está girando o FollowingBoeBot.bs2. O controle proporcional faz do
veículo sombra Boe-Bot um fiel seguidor do Boe-Bot líder. O veículo líder
Boe-Bot pode amarrar uma cadeia de 6 ou 7 veículos sombras. Basta colocar
os painéis laterais do Boe-Bot líder e a porta traseira para o resto dos
veículos sombra Boe-Bot em cadeia.
Figura 8-6
Boe-Bot líder
(esquerda) e Veiculo
sombra do Boe-Bot
(direita)



Se você faz parte de uma classe monte painéis de papel sobre a cauda e
sobre ambos os lados do Boe-Bot, líder como mostrado na Figura 8 6.
Se você não faz parte de uma classe (e só tem um Boe-Bot), o veículo
sombra seguirá um pedaço de papel ou sua mão, assim ele seguirá o
Boe-Bot líder tão bem quanto.
Substitua as resistências de 1 Ω que liga o P2 e P8 do veículo líder para
os LEDs IV com os resistores 470 Ω ou 220 Ω.




Programe o Boe-Bot líder para evitar objetos usando uma versão
modificada
do
FastIrRoaming.bs2,
rebatizada
SlowerIrRoamingForLeadBoeBot.bs2.
Faça essas modificações no SlowerIrRoamingForLeadBoeBot.bs2:
o Aumente todos os argumentos Duração PULSOUT que estão
agora em 650-710.
o Reduza todos os argumentos Duração PULSOUT que estão
agora em 850-790.
O veículo sombra do Boe-Bot deve usar o programa
FollowingBoeBot.bs2 sem qualquer modificação.
Com ambos os veículos Boe-Bot executando seus respectivos
programas, coloque o veículo sombra atrás do Boe-Bot líder. O Boe-Bot
sombra deve seguir a uma distância fixa, contanto que não se distraia
com algum um outro objeto, tais como uma mão ou uma parede.
Você pode ajustar os pontos de ajuste e constantes de proporcionalidade
para mudar o comportamento do Boe-Bot sombra. Use sua mão ou um
pedaço de papel para levar o veículo sombra do Boe-Bot a fazer estes
exercícios:


Tente executar FollowingBoeBot.bs2 usando valores constantes de Kpr
e Kpl, variando de 15 a 50. Observe a diferença na sensibilidade do
Boe-Bot ao seguir um objeto.
Tente fazer ajustes do valor da constante do SetPoint. Tente valores
de 0 a 4.
ATIVIDADE #3: SEGUINDO UMA LINHA
Figura 8-7 mostra um exemplo de um trajeto que você pode construir e
programar seu Boe-Bot para seguir. Cada faixa deste trajeto é de três longos
pedaços de fita isolante de vinil de ¾ em (19 mm) colocadas ponta a ponta
em cartolina branca. Nenhum papel deve estar visível entre as tiras de fita
isolante.
15 1 4 V dd 13 1 2
6- 9VD C
9 Vdc
Ba ttery
R ed
Bl ack
X4
X5
Vss
Vdd
Vin
Vss
X3
Vss
P1
P3 P15
P5 P14
P7 P13
P9 P12
P11 P11
P13 P10
P15 P9
Vin P8
P7
P6
P5
P4
P3
+
R eset
P2
P1
P0
X2
0 1 2
Bo a rd o f Ed uc a ti o n
Pw r
S TAM
PS
iC
n
LAS
S
TM
1
S out
S in
AT N
V ss
P0
P1
P2
P3
P4
P5
P6
P7
U1
V in
V ss
R st
V dd
P 15
P 14
P 13
P 12
P 11
P 10
P9
P8
www.sta mp si nc la ss .c om
Vss
P0
P2
P4
P6
P8
P10
P12
P14
Vdd
X1
R ev C
© 2 000 -2 003
22” (56 cm)
Start
Figura 8-7
Trajeto Siga à
faixa
www.s tam ps in cl a ss.c om
U1
V in
V ss
R st
V dd
P 15
P 14
P 13
P 12
P 11
P 10
P9
P8
1
TM
ST
AM PS
i nC LAS
S
© 200 0- 200 3
R ev C
0 1 2
S out
S in
ATN
V ss
P0
P1
P2
P3
P4
P5
P6
P7
X
X3
3
Vss
P1
15
P1
P3 P
14
P1
4
P5 P
13
P1
P7 P
12
P1
P9 P
11
P1
P11 P
10
P1
P1 3 P
9
P9
P1 5 P
P8
Vi n P8
P
7
P7
P
6
P6
P
5
P5
P
4
P4
P
3
P3
P
2
P2
P
1
P1
P
0
P0
X2
R ese t
X1
Vs s
P0
P2
P4
P6
P8
P1 0
P1 2
P1 4
Vd d
Pw r
Bo a rd o f Ed u ca ti o n
+
Vd d
Vin
X4
Vss
X5
R ed
B lac k
9 Vd c
Ba t e ry
6- 9V DC
1514
V dd
1312
Finish
28” (71 cm)
Construir e Testar o Trajeto
Para uma navegação bem sucedida deste curso, serão necessários alguns
ajustes e testes do Boe-Bot.
Materiais Necessários:
(1) Folha de cartolina branca, dimensões aproximadas: 22 X 28 em (56 x 71
cm)
(1) Rolo de fita isolante de vinil preto, ¾ "(19 mm) de largura
 Em sua cartolina, use a fita isolante para fazer um trajeto como o
mostrado na Figura 8-7.
Testando o Trajeto:
 Aponte os detectores de objeto IV para baixo e para fora como
mostrado na Figura 8-8, que é o mesmo da Figura 7-11 repetida aqui
por conveniência.
X4
Vdd
X5
Vin
Figura 8-8
Detector IR
de objeto
direcionado
para baixo e
para fora a
fim de
detectar a
faixa
Vss
+
Board of Education
Rev C
© 2000-2003
Visão superior
Visão Lateral
 Assegure que seu trajeto feito de fita isolante está livre de
interferência da luz fluorescente. Veja mais detalhes no capítulo 7,
secção “Farejamento para interferência de IR”, página 298.
 Substitua os resistores em série 1 kΩ pelos LED IV com resistores 2
kΩ para aumentar a visão de perto do Boe-Bot.
 Execute DisplayBothDistances.bs2 a partir da página 332. Mantenha
seu Boe-Bot ligado ao seu cabo de programação para que você possa
ver as distâncias indicadas.
 Coloque o seu Boe-Bot olhando diretamente para o fundo branco do
seu cartaz, como mostrado na Figura 8-9.
 Verifique se as leituras da zona indicam que um objeto é detectado
numa zona muito perto. Ambos os sensores devem dar-lhe uma
leitura de 1 ou 0.
15 1 4
6- 9VD C
V dd
13 1 2
9 Vdc
Ba ttery
R ed
Bl ack
STA
i nC M PS
LASS
TM
1
V in
S out
S in
AT N
V ss
P0
P1
P2
P3
P4
P5
P6
P7
V ss
R st
V dd
P 15
U1
P 14
P 13
P 12
P 11
P 10
P9
P8
www.sta mps i nc la ss .c om
X4
X5
Pw r
Vdd
Vin
Vss
Vss
X3
P1
P3 P15
P5 P14
P7 P13
P9 P12
P11 P11
P13 P10
P15 P9
Vin P8
X1
P7
P6
P5
P4
P3
+
R eset
P2
P1
P0
X2
0 1 2
Vss
P0
P2
P4
P6
P8
P10
P12
P14
Vdd
R ev C
© 2 000 -2 003
Figura 8-9
Teste para zona de
reflexão – vista
superior.
 Coloque o Boe-Bot para que ambos os detectores de objeto IR
estejam focados diretamente para o centro da faixa de fita isolante
(ver Figura 8-10 e Figura 8- 11).
 Em seguida, ajustar a posição de seu Boe-Bot (em frente e para longe
da fita), até que ambos os valores da zona alcancem o nível 4 ou 5,
indicando que um objeto longe é detectado, ou o objeto não é
detectado.
 Se você está tendo dificuldades em conseguir os valores mais
elevados com o seu curso de fita isolante, consulte o quadro logo
abaixo da figura 8-11 na próxima página.
15 1 4
6- 9VD C
V dd
13 1 2
9 Vdc
Ba ttery
R ed
Bl ack
STA
i nC M PS
LASS
TM
1
V in
S out
S in
AT N
V ss
P0
P1
P2
P3
P4
P5
P6
P7
V ss
R st
V dd
P 15
U1
P 14
P 13
P 12
P 11
P 10
P9
P8
X4
X5
Pw r
Vdd
Vin
Vss
Vss
X3
P1
P3 P15
P5 P14
P7 P13
P9 P12
P11 P11
P13 P10
P15 P9
Vin P8
X1
P7
P6
P5
P4
P3
+
R eset
P2
P1
P0
X2
0 1 2
Vss
P0
P2
P4
P6
P8
P10
P12
P14
Vdd
R ev C
© 2 000 -2 003
Figura 8-10
Teste para zona de
não reflexão - Vista
Superior.
Figura 8-11
Teste para zona de
número alto - Vista
Lateral
Electrical Tape
Solução de problemas do trajeto de fita isolante
Se você não conseguir obter um valor elevado na zona quando os detectores de
infravermelho estão focados na fita isolante, pegue um pedaço de papel
separado e faça uma faixa de quatro tiras de largura, em vez de três. Se os
números de zona ainda são baixos, certifique-se que você está usando
resistores de 2 kΩ (vermelho -preto-vermelho) em série com os LEDs
infravermelhos. Você também pode tentar um resistor de 4,7 kΩ para fazer o
Boe-Bot enxergar mais perto. Se nada disso funcionar, tente uma marca
diferente de fita isolante de vinil preto. Ajustar o detector de LED IV mudando
o foco para mais perto ou mais longe da frente do Boe-Bot (ver Figura 8 -11)
também pode ajudar.
Se você está tendo problemas com as medições da zona de reflexão ao ler a
superfície branca, tente apontar os LEDs IV e detectores mais para baixo e
para a frente do Boe-Bot, mas tenha cuidado para não causar reflexo do chassi.
Você também pode tentar um resistor de menor valor como 1 kΩ (marrompreto-vermelho).
 Agora, coloque o Boe-Bot no curso de modo que suas rodas se
equilibrem na linha preta. Os detectores de infravermelho devem
estar voltados ligeiramente para fora. Veja close-up na Figura 8 -12.
Verifique se a distância de leitura para ambos os detectores de
infravermelho do objeto é 0 ou 1 novamente. Se as leituras são mais
altas, isto significa que eles devem estar apontados ligeiramente mais
para o exterior, para longe da extremidade da faixa.
Quando você move o Boe-Bot em qualquer direção indicada pela seta
dupla, um ou o outro detector objeto IV será focado na fita isolante. Quando
você fizer isso, as leituras para o detector objeto que está agora sobre a fita
isolante deve aumentar para 4 ou 5. Tenha em mente que se você mover o
Boe-Bot em direção a sua esquerda, os detectores da direita devem aumentar
em valor, e se você mover o Boe-Bot em direção a sua direita, os detectores
de esquerda devem mostrar o valor mais alto.
 Ajuste seus detectores de objetos IV até o Boe-Bot passar por este
último teste. Então você estará pronto para tentar seguir a faixa.
Figura 8-12: Faixa de teste de digitalização
15 1 4
6- 9VD C
X4
Vdd
X5
Vin
V dd
13 1 2
9 Vdc
Ba ttery
R ed
Bl ack
S TAM
in
C LASPS
S
Vss
TM
1
S out
S in
AT N
V ss
P0
P1
P2
V in
U1
V ss
R st
V dd
P 15
P 14
P 13
P3
P4
P 12
P 11
P5
P6
P7
P 10
P9
P8
X4
X5
Pw r
Vdd
Vss
Vin
Vss
X3
P1
P3 P15
P5 P14
P7 P13
P9 P12
P11 P11
P13 P10
P15 P9
Vin P8
P7
P6
P5
P4
P3
+
P2
P1
P1
P0
X2
0 1 2
Vss
P0
P2
P4
P6
P8
P10
P12
P14
Vdd
X1
R eset
R ev C
© 2 000 -2 003
+
Board of Education
Rev C
© 2000-2003
Close-up dos detectores de objeto
IV
Vista superior do Boe-Bot abrangendo a
faixa
Programação para Seguir na Tira
Você só vai precisar fazer alguns pequenos ajustes no
programaFollowingBoeBot.bs2 para fazer ele seguir na faixa. Primeiro, o
Boe-Bot deve mover-se em direção a objetos mais próximos do que o
SetPoint e longe de objetos novos a partir do ponto de ajuste. Este é o
oposto de como FollowingBoeBot.bs2 se comporta. Para inverter a direção
de como Boe-Bot se move quando detecta que o objeto não é a distância
SetPoint, basta alterar os sinais de Kpl e Kpr. Em outras palavras, mude
Kpl de -35 a 35, e altere Kpr de 35 a -35. Você ainda terá que experimentar
com o seu ponto de ajuste. Valores de 2 a 4 tendem a funcionar melhor. Este
exemplo seguinte usará um valor de ajuste (SetPoint) 3.
Exemplo de Programa: StripeFollowingBoeBot.bs2
 Abra






FollowingBoeBot.bs2
e
salve
isso
ao
StripeFollowingBoeBot.bs2.
Mude a declaração SetPoint de SetPoint CON 2 para SetPoint
CON 3.
Mude Kpl de -35 para 35.
Mude Kpr de 35 para -35.
Execute o programa.
Coloque seu Boe-Bot na localização “Start” mostrada na Figura
8-13. O Boe-Bot deve aguardar lá até você colocar sua mão em
frente ao detector de objetos IV. Isso fará com que ele inicie a rodar
para frente. Quando sair da linha de início e estiver pronto para
começar o percurso tire sua mão da frente, então isso o fará rastrear o
percurso. Quando ele enxergar as linhas “Finish” do fim do percurso
ele deve parar e esperar lá.
Supondo que você possa obter leituras de distância de 5 a partir da
fita isolante e 0 a partir da placa do poster, os valores constantes de
ajuste 2, 3 e 4 (SetPoint) devem funcionar. Experimente diferentes
valores de referência na pista e faça anotações de desempenho do
Boe-Bot.
15 1 4 V dd 13 1 2
6- 9VD C
9 Vdc
Ba ttery
R ed
Bl ack
S TAM PS
iC
n
LAS
S
TM
1
S out
S in
AT N
V ss
P0
P1
P2
P3
P4
P5
P6
P7
U1
V in
V ss
R st
V dd
P 15
P 14
P 13
P 12
P 11
P 10
P9
P8
www.sta mp si nc la ss .c om
X4
X5
Pw r
Vss
Vdd
Vin
Vss
Vss
X3
P1
P3 P15
P5 P14
P7 P13
P9 P12
P11 P11
P13 P10
P15 P9
Vin P8
P7
P6
P5
P4
P3
+
R eset
P2
P1
P0
X2
0 1 2
Vss
P0
P2
P4
P6
P8
P10
P12
P14
Vdd
X1
R ev C
© 2 000 -2 003
22” (56 cm)
Start
Figura 8-13
Percurso Seguir
na Tira.
www.s tam ps in cl a ss.c om
U1
V in
V ss
R st
V dd
P 15
P 14
P 13
P 12
P 11
P 10
P9
P8
1
TM
ST
AM PS
in
C LAS
S
© 200 0- 200 3
R ev C
0 1 2
S out
S in
ATN
V ss
P0
P1
P2
P3
P4
P5
P6
P7
X3
3
X
Vss
P1
P1 5
P3 P1
P1 4
4
P5 P1
P1 3
P7 P1
P1 2
P9 P1
P1 1
P11 P1
P1 0
P1 3 P1
P9
P1 5 P9
P8
Vi n P8
P7
P7
P6
P6
P5
P5
P4
P4
P3
P3
P2
P2
P1
P1
P0
P0
X2
R ese t
X1
Vs s
P0
P2
P4
P6
P8
P1 0
P1 2
P1 4
Vd d
Pw r
Bo a rd o f Ed u ca ti o n
+
Vd d
Vin
X4
Vss
X5
R ed
B lac k
9 Vd c
Ba t e ry
6- 9V DC
1514
V dd
1312
Finish
28” (71 cm)
'
'
'
'
'
'
'
'
-----[ Titulo ]-----------------------------------------------------------Robótica com o Boe-Bot - StripeFollowingBoeBot.bs2
Boe-Bot ajusta sua posição para se mover em direção a objetos que estão
mais próximos da
Zona 3 e longe de objetos maiores do que a zona 3. Útil para acompanhar a
fita isolando de '2,25 polegadas de largura.
{$STAMP BS2}
' Stamp diretiva.
{$PBASIC 2.5}
' PBASIC diretiva.
' -----[ Constantes ]-------------------------------------------------------Kpl
Kpr
SetPoint
CenterPulse
CON
CON
CON
CON
35
-35
3
750
' Mude de -35 para 35
' Mude de 35 para -35
' Mude de 2 para 3.
irFrequency
irDetectLeft
irDetectRight
distanceLeft
distanceRight
pulseLeft
pulseRight
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
Nib
Word
Bit
Bit
Nib
Nib
Word
Word
' -----[ rotina principal ]-------------------------------------------------DO
' Calculate proportional output.
GOSUB Send_Pulse
LOOP
' -----[ Sub-Rotina - Obter Distancia IV]-----------------------------------Get_Ir_Distances:
distanceLeft = 0
distanceRight = 0
irDetectLeft = IN9
irDetectRight = IN0
NEXT
RETURN
' -----[ Subrotina - obter Pulso ]------------------------------------------Send_Pulse:
PAUSE 5
RETURN
Sua Vez – Disputa Seguindo a Tira
Você pode transformar isso em uma disputa onde quem ganha é o que
cumpre o menor tempo de curso, desde que o Boe-Bot espere fielmente nas
linhas de "Start" e "Finish". Você pode fazer outros percursos também. Para
melhor desempenho, experimente com diferentes valores de SetPoint,
Kpl, e Kpr.
ATIVIDADE #4: MAIS PROJETOS E ATIVIDADES DO BOE-BOT
ONLINE
Então, o que você quer fazer com o seu Boe-Bot, qual é o próximo passo?
Possíveis próximos passos incluem:
•
•
•
•
Projetos com acessórios Boe-Bot
Concursos e desafios
Mais atividades com o Boe-Bot utilizando o kit que você já tem
Controle Remoto IV para o Boe-Bot (texto e kit)
Todos os recursos discutidos nesta atividade podem ser acessados através
da página www.parallax.com/go/Boe-Bot.
Projetos com Acessórios Boe-Bot
A Parallax tem sensores adicionais e kits de acessórios assim você pode
adicionar recursos e continuar a explorar o seu Boe-Bot. Aqui estão alguns
exemplos:
• Ping))) Ultrasonic Distance Sensor (#28015) é um sensor de
distância através de ultrassom, que proporciona maior alcance e
medições de distância mais precisas de objetos. Um kit de montagem
opcional (#570-28015) permite que o sensor varra uma área.
• Acelerômetro de eixo duplo para detecção de inclinação (#28017)
• Módulo de bússola para navegação (#29123)
• Um Kit para fazer o seu Boe-Bot um andador de seis patas (#30055)
• Um Kit de garras mecânicas para pegar e mover itens (#28202)
• Um Kit de esteiras de locomoção para navegação em todos os
terrenos (#28106)
•
Módulos XBeeRF e adaptadores para controle sem fio e
comunicação (ver www.parallax.com/go/XBee)
Figura 8-14: Sensor Ultra-sônico PING com Suporte, Kit de Pernas e Kit de Garras
para Boe-Bot
Concursos e Desafios
Interessado em um concurso?
Verifique o link www.parallax.com/go/Boe-Bot para verificar as regras do
concurso.
Algumas ideias também estão inclusas aqui no Apêndice C: Boe-Bot
Concursos de navegação que começa na página 378.
Controle Remoto IV para o Boe-Bot
Controle Remoto IV para o Boe-Bot está disponível em versão impressa
(#28139) com download gratuito em PDF. Este livro usa o mesmo circuito
que você tem atualmente construído em seu Boe-Bot, e tem exemplos de
programas que:
•
•
Faz com que você possa conduzir o seu Boe-Bot de volta
pressionando e segurando alguns botões no controle remoto.
Faça o seu Boe-Bot ouvir os comandos de configuração do controle
remoto que dizem o que fazer a seguir, como andar, seguir objetos,
permitir o controle remoto, e muito mais ...
A única peça adicional de material necessária é um controle remoto de TV
universal, que é um artigo comum na maioria dos lares e pode ser obtido de
forma barata por meio de diversos estabelecimentos, bem como através
www.parallax.com (#020-00001).
Mais Atividades com Seu Boe-Bot Utilizando o Kit Que Você Já Tem
Aqui estão alguns exemplos de atividades que você pode encontrar no
www.parallax.com/go/Boe-Bot que utiliza partes do kit Boe-Bot. Você não
precisa comprar todas as peças extras para experimentar estas atividades:
• Melhor detecção de distância variando o brilho do LED IV deão
invés da frequência
• Navegar em um labirinto
• Detectar uma chama de vela
SUMÁRIO
A varredura de frequência foi introduzida como uma maneira de determinar
a distância usando um LED IV do Boe-Bot e o detector. FREQOUT foi usado
para enviar sinais de IV em frequências que variam de 37,5 kHz (mais
sensível) para 41,5 kHz (menos sensível). A distância foi determinada pelo
rastreamento de quais frequências fizeram com que o detector de IV
informasse que um objeto foi detectado ou que não. Uma vez que nem todas
as frequências foram separadas pelo mesmo valor, o comando LOOKUP foi
introduzido como uma forma simples de usar a sequência de contagem
fornecida por um loop FOR ... NEXT para indexar listas sequenciais de
números.
Os sistemas de controle foram introduzidos junto com o controle em Loop
fechado. Controle proporcional num sistema de circuito fechado é um
algoritmo em que o erro é multiplicado por uma constante de
proporcionalidade para determinar o débito do sistema. O erro é a saída do
sistema de medição subtraído do ponto de referência. O BASIC Stamp foi
programado em PBASIC para operar Loop de controle para ambos os servos
da esquerda e da direita e para os detectores de distância. Pela reamostragem da distância e ajuste da saída do servo, antes de enviar impulsos
para os servos, o Loop de controle fez o Boe-Bot sensível a movimentos de
objetos. O Boe-Bot foi capaz de usar o controle proporcional para se fixara
seguir os objetos, e também para rastrear e seguir uma faixa de fita isolante
preta.
Último, mas não menos importante, os indicadores de outras atividades,
recursos e concursos foram introduzidos aqui.
Questões
1. Qual seria a sensibilidade relativa do detector IV se você usar
FREQOUT para enviar um sinal de 35 kHz? Qual é a sensibilidade
relativa com um sinal de 36 kHz?
2. Considere o trecho de código abaixo. Se o índice variável é 4, quais
números serão alocados na variável prime neste comando LOOKUP?
Que valores são armazenados pelo prime quando o índice é 0, 1, 2 e
7?
LOOKUP index, [2, 3, 5, 7, 11, 13, 17, 19], prime
3. Em que ordem são avaliadas as expressões matemáticas PBASIC?
Como você pode substituir essa ordem?
4. Que diretiva PBASIC você usa para declarar uma constante? Como
você daria o número 100 ao nome de "Ponto de ebulição?"
Exercícios
1. Liste a sensibilidade do detector de IV para cada kHz mostrado na
Figura 8-1.
2. Escreva um segmento de código que faz a varredura de frequência
para apenas quatro frequências em vez de cinco.
3. Faça uma lista para os testes que devem ser realizados para garantir o
seguimento na faixa de fita isolante.
Projetos
1. Criar diferentes tipos de cruzamentos de fita isolante e programar o
Boe-Bot para navegar por eles. As interseções poderiam ser de 90 °
para a esquerda, 90 ° para a direita, de três e quatro vias. Isso
envolverá o Boe-Bot reconhecendo que está em um cruzamento.
Quando o Boe-Bot executa StripeFollowingBoeBot.bs2, o Boe-Bot
fica parado nos cruzamentos. O objetivo é fazer o Boe-Bot perceber
que não está fazendo nada e romper com seu Loop de controle
proporcional.
Dicas: Você pode fazer isso através da criação de dois contadores,
um que aumenta em 1 a cada momento através do DO ... LOOP, e
outro que aumenta apenas quando o Boe-Bot proporciona um pulso
para a frente. Quando o contador aumentar cada vez que o DO ...
LOOP chegar a 60, usar IF ... THEN para verificar quantos pulsos
foram aplicados para a frente. Se menos de 30 pulsos para frente
foram aplicados, o Boe-Bot está provavelmente preso. Lembre-se de
repor os contadores a zero cada vez que o contador de loop chegar a
60. Depois do Boe-Bot reconhecer que está em um cruzamento, ele
precisa mover-se para a borda superior da interseção, então voltar
para cima e descobrir se vê a fita isolante ou o fundo branco à
esquerda e à direita, em seguida, fazer o giro correto de 90 °. Use um
movimento pré-programado para girar 90 °, sem controle
proporcional. Por três vias e quatro vias de cruzamentos, o Boe-Bot
pode virar para a direita ou esquerda.
2. Projeto avançado opcional— Projete a solução de um labirinto e
programe o Boe-Bot para resolvê-lo!
Soluções
Q1. A sensibilidade relativa a 35 kHz é de 30%. Para 36 kHz é de 50%.
Q2. Quando index = 4, prime = 11.
index = 0, prime = 2
Q3. As expressões são avaliadas da esquerda para a direita. Para
substituir, use parênteses para alterar a ordem.
Q4. Use a diretiva CON.
BoilingPoint CON 100 ( Ponto de ebulição)
E1. Frequência (kHz): 34 35 36 37 38
39 40 41 42
Sensibilidade :
14% 30% 50% 76% 100% 80% 55% 35% 16%
E2. Para resolver este problema, coloque apenas quatro frequências na
lista de pesquisa e diminua o índice FOR ...NEXT por 1.
a. FOR freqSelect = 0 TO 3
b. LOOKUP freqSelect, [37500, 38750, 39500,
40500], irFrequency
c. FREQOUT 8, 1, irFrequency
d. irDetect = IN9
e. … commands not shown
f. NEXT
g. Adicionar o comando DEBUG ao IF...THEN. Não esqueça do
ENDIF.
h.
i.
j.
k.
l.
READ Dots + index, noteDot
IF noteDot = 1 THEN
noteDuration = noteDuration * 3 / 2
DEBUG "Dotted Note!", CR
ENDIF
E3. • Fareje por interferência no IV com IrInterferenceSniffer.bs2.
• Executar exibição BothDistances.bs2.
• Leituras Brancas devem ser 0-1 em ambos os sensores.
• Leituras Pretas devem ser 4-5, em ambos os sensores.
• Equilibrar a leitura da linha, ambos os sensores devem ler 0-1.
• Mova o Boe-Bot para trás e para frente sobre a linha, o sensor sobre
a linha preta deve ler 4-5.
P1. Na solução abaixo, a sub-rotina Check_For_Intersection
implementa o algoritmo descrito. O servo esquerdo foi
arbitrariamente escolhido para contar os impulsos para a frente. Um
bit de tamanho variável denominado Stuck é utilizado como um
sinalizador para deixar a rotina principal saber quando um
cruzamento
tiver
sido
atingido.
Na
sub-rotina
Navigate_Intersection, o Boe-Bot vai para a frente após o
cruzamento e, em seguida, faz o backup, checando os sensores,
usando DO ... LOOP ... UNTIL. Em seguida, ele faz uma curva
de 90 graus pré-programada na direção correta. Se o cruzamento é
uma forma de 3 ou 4 vias de intersecção, o Boe-Bot irá virar
arbitrariamente na direção em que o preto é detectado pela primeira
vez. Uma constante, Turn90Degree, é fornecida para ajustar a curva
de 90 graus. Alguns indicadores visuais e sonoros estão inclusos, o
que ajuda na resolução de problemas e compreender o que o Boe-Bot
enxerga e decide, bem como a adição de um pouco de personalidade
e diversão.
' -----[ Título ]----------------------------------------------------
' Robótica com o Boe-Bot - IntersectionsBoeBot.bs2
' Navegue 90 graus à esquerda / direita, cruzamentos de 3/ 4-vias.
' Baseado em StripeFollowingBoeBot.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
' Stamp diretiva.
' PBASIC diretiva.
' -----[ Constantes ]-----------------------------------------------Kpl
Kpr
SetPoint
CenterPulse
Turn90Degree
CON
CON
CON
CON
CON
35
-35
3
750
30
' constante da esquerda proporcional
' constante da direita proporcional
' 0-1 é branco, 4-5 é preto
RightLED
LeftLED
PIN
PIN
1
10
' Indicadores LED
' Pulsos necessários para curva de 90˚
' -----[ Variáveis ]------------------------------------------------freqSelect
irFrequency
irDetectLeft
irDetectRight
distanceLeft
distanceRight
pulseLeft
pulseRight
numPulses
fwdPulses
counter
isStuck
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
Nib
Word
Bit
Bit
Nib
Nib
Word
Word
Byte
Byte
Byte
Bit
' varredura através de cinco frequências
' Freq. enviado ao emissor IV
' armazenar resultados dos detectores
' Calcular as zonas de distância
' Largura de pulso dos servos
' Contar total de pulsos
' Contar os pulsos a frente
' Boolean variável, o Boe-Bot está preso?
' -----[ Inicialização ]--------------------------------------------FREQOUT 4, 2000, 3000
' -----[ Rotina principal ]-----------------------------------------DO
GOSUB Update_LEDs
' leitura sensores IV
' Indicando linha branco/preto
' Calcular a saida proporcional e mover de acordo
GOSUB Send_Pulse
GOSUB Check_For_Intersection
' estamos presos no cruzamento?
IF (isStuck = 1) THEN
GOSUB Make_Noise
GOSUB Navigate_Intersection
ENDIF
' indicador sonoro
' Navegando através
LOOP
' -----[ Subrotines ]-----------------------------------------------Navigate_Intersection:
' Vá a diante até os dois sensors lerem branco, entre o cruzamento.
DO
pulseLeft = 850: pulseRight = 650 ' Forward
GOSUB Send_Pulse
GOSUB Update_LEDs
LOOP UNTIL (distanceLeft <=2) AND (distanceRight <=2)
GOSUB Stop_Quickly
' PARE
' Agora volte até um dos detectores ver o preto. Vire a direita ou
' esquerda quando um dos detectores enxergar o preto.
' Qualquer que ele veja por primeiro (aleatório), virá para este
' lado.
DO
pulseLeft = 650: pulseRight = 850 ' Backward
GOSUB Send_Pulse
GOSUB Update_LEDs
LOOP UNTIL (distanceLeft >=4) OR (distanceRight >=4)
GOSUB Stop_Quickly
' PARE
' Virar 90 graus na direção do detector que enxergar o preto primeiro
IF (distanceLeft >=4) THEN
' O detector da esquerda lê
preto
FOR counter = 1 TO Turn90Degree
' Gira 90 graus à esquerda
PULSOUT 13, 750
' Sem o controle proporcional
PULSOUT 12, 650
PAUSE 20
NEXT
ELSEIF (distanceRight >=4) THEN
' O detector da direita lê preto
FOR counter = 1 TO Turn90Degree
' Gira 90 graus a direita
PULSOUT 13, 850
PULSOUT 12, 750
PAUSE 20
NEXT
ENDIF
' Neste ponto, o Boe-Bot deve ter virado 90 graus para seguir o
' cruzamento. Continue seguindo a linha preta.
RETURN
Check_For_Intersection:
' Mantenha o controle de pulsos vs os pulsos para frente. Se houver
' menos de 30 pulsos a frente num total de 60 pulsos é provável que o
' Boe-Bot esteja travado no cruzamento.
isStuck = 0
numPulses = numPulses + 1
' Inicializar a variável Boolean
' Contar o total de pulsos enviados
SELECT numPulses
CASE < 60
IF (pulseLeft > CenterPulse) THEN
fwdPulses = fwdPulses + 1
' Contar os pulsos para frente
ENDIF
' (a frente é um pulso > 750)
CASE = 60
IF (fwdPulses < 30) THEN
isStuck = 1
ENDIF
CASE > 60
numPulses = 0
fwdPulses = 0
ENDSELECT
RETURN
' Se enviarmos 60 pulsos
' Quantos foram para frente?
' Se < 30, robo esta preso
' resetar o contador e voltar a 0
' (pode apagar =60 no caso mas
' Make_Noise)
Make_Noise:
' Faz um tom crescente, proporcional ao número de pulsos para frente
FOR counter = 1 TO fwdPulses STEP 3
FREQOUT 4, 100, 3800 + (counter * 10)
NEXT
RETURN
Updates_LEDs:
' Use LEDs para indicar quais detectores estão vendo preto ou branco.
' Branco = Off, Preto = On. Preto é a leitura de distancia > or = 4.
IF (distanceLeft >= 4) THEN HIGH LeftLED ELSE LOW LeftLED
IF (distanceRight >= 4) THEN HIGH RightLED ELSE LOW RightLED
RETURN
Stop_Quickly:
' Este comando para as rodas do Boe-Bot e não as deixam girar a
' frente.
PULSOUT 13, 750
PULSOUT 12, 750
PAUSE 20
RETURN
Get_Ir_Distances:
' Leitura de objeto pelos detectores IV e calculo de distancia.
' Linha preta tem leitura de 4-5. Superfície branca tem a leitura de
' 0-1.
distanceLeft = 0
distanceRight = 0
irDetectLeft = IN9
irDetectRight = IN0
NEXT
RETURN
Send_Pulse:
' Enviar um único pulso para os servos entre as leituras IV .
PAUSE 5
' PAUSA reduzida devido a leitura do IV
RETURN
P2. Se você criar um projeto interessante de labirinto para o Boe-Bot e
quiser compartilhá-lo com outras pessoas, você pode juntar-se as
aulas de Basic Stamp, ou a projetos de fóruns em
http://forums.parallax.com. Ou, você pode enviar um e-mail para a
Equipe
de
Educação
Parallax
diretamente
para
[email protected].
Lista de Peças e Opções de Kit · Página 365
Anexo A: Lista de Peças e Opções de Kit
Para concluir as atividades deste texto, você vai precisar de um robô BoeBot completo e os componentes eletrônicos necessários para construir os
circuitos de exemplo. Opções de kit são descritas neste apêndice. Todas as
informações neste apêndice foram atualizadas no momento de impressão do
manual. A Parallax poderá fazer substituições de peças ou alterações sem
aviso prévio, em caso de necessidade, ou para melhorar a qualidade do
produto. Para informações mais atualizadas, downloads e acessórios, visite
www.parallax.com/go/Boe-Bot.
Opções de Kit Completo para o Robô Boe-Bot
Além de um PC com uma porta serial ou USB, baterias e alguns utensílios
domésticos comuns, as opções de Kit para o Robô Boe-Bot contém todas as
peças e documentos que você precisa para completar os experimentos neste
texto.
Boe-Bot Kit Robot - Serial com adaptador USB (#28132)
Peças e quantidades estão sujeitas a alterações sem aviso prévio
Código
Descrição
Quantidade
BS2-IC
BASIC Stamp 2 módulo microcontrolador
1
28124
Kit de peças Robótica com o Boe-Bot
1
28125
Guia do Estudante Robótica com o Boe-Bot
1
28150
Board of Education - Serial
1
700-00064
Chave de fenda
1
800-00003
Cabo Serial
1
28031
Adaptador USB para Serial e cabo USB A para Mini B
1
Boe-Bot Kit Robot - Só USB (#28832)
Código
Descrição
Quantidade
BS2-IC
BASIC Stamp 2 módulo microcontrolador
1
28124
Robótica com o Boe-Bot Kit de peças
1
28125
Robótica com o Boe-Bot Guia do Estudante
1
28850
Board of Education USB
1
700-00064
Parallax uma chave de fenda
1
805-00006
USB A para cabo Mini B
1
Robótica com o Kit de Peças Boe-Bot
Se você já tem um Board of Education e BASIC Stamp 2, você pode
comprar o kit de peças Boe-Bot, com ou sem este livro impresso:
Robótica com o Boe-Bot: Peças e Texto, #28154
Robótica com o Boe-Bot: partes somente #28124
Código
Descrição
Quantidade
150-01020
1 kΩ resistor
2
150-01030
10 kΩ resistor
4
150-02020
2 kΩ resistor
2
150-02210
220 Ω resistor
8
150-04710
470 Ω resistor
4
150-04720
4.7 kΩ resistor
2
200-01031
0.01 µF capacitor
2
200-01040
0.1 µF capacitor
2
350-00003
LED Infravermelho
2
350-00006
LED vermelho
2
350-00029
Fototransistor
2
350-00014
Receptor infravermelho (Panasonic PNA4602M ou equivalente)
2
350-90000
Suporte LED para LED infravermelho
2
350-90001
Protetor de luz para LED infravermelho
2
400-00002
Interruptor de pressão, normalmente aberto
2
451-00303
Conector de 3 pinos
2
700-00056
Arame do Bigode
2
800-00016
Fios de conexão (saco de 10)
2
900-00001
Piezospeaker
1
Embalagem do Hardware do Boe-Bot
1
Conteúdo da Embalagem do Hardware do Boe-Bot
Peças de reposição de hardware para o Boe-Bot podem ser compradas
individualmente, como encontrado em nossa loja on-line “Robot
Componente Shop” (Loja de Componentes para Robô). Por favor, note que
o pacote de hardware não é vendido como uma unidade separada do kit do
robô Boe-Bot (completo) ou do kit de peças do Boe-Bot.
Conteúdo da Embalagem do Hardware do Boe-Bot
Parallax
Banco de
código
Descrição
700-00002
Parafuso Phillips 3/8” 4-40 pan-head
8
700-00003
Porca Hex, 4-40 zincada
10
700-00009
Roda livre traseira
1
700-00015
Arruela # 4
2
700-00016
Parafuso, 4-40 x 3/8" cabeça chata
2
700-00022
Chassi de alumínio Boe-Bot
1
700-00023
Pino de trava, 1/16" x 1.5”
1
700-00025
Arruela de borracha, 13/32"
2
700-00028
Parafuso Phillips, 4-40 x 1/4"
8
700-00038
Suporte de bateria com cabo
1
700-00060
Suporte de alumínio redondo 4-40
4
710-00007
Parafuso Phillips, 7/8" 4-40
2
713-00007
Espaçador ½”, em alumínio, redondo #4
2
721-00001
Roda de Plástico Parallax
2
721-00002
Elástico para a Roda
4
900-00008
Servo de rotação contínua Parallax
2
Quantidade
Construindo um Boe-Bot com um BASICStamp HomeWork Board
O HomeWork Board, que está incluso no kit de atividade do BASIC Stamp
(#90005), pode ser usado com o Robotics with the Boe-Bot Parts kit (kit de
peças de robótica do Boe-Bot) e esses itens adicionais:
(2) 3-pinos macho / conector de 3 pinos macho, #451-00303
(1) Suporte de baterias, #753-00001
Nota para Educadores: descontos de 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 detalhes. 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 Board of Education + BASIC Stamp 2
module (#28158). Contato de Vendas BS Educacional através do e-mail
[email protected] ou telefone +55 (11) 2533-9452.
Código de Cores dos Resistores e Regras da Breadboarding · Página 369
Anexo B: Código de Cores dos Resistores e Regras da
Breadboarding
Códigos de Cores de Resistores
Resistores como os que estamos usando neste guia do estudante tem listras
coloridas que indicam quais são os seus valores de resistência. Há uma
combinação de cor diferente para cada valor de resistência.
Pode haver uma quarta faixa que indica a tolerância do resistor. Tolerância é
medida em percentagem, e diz qual a tolerância de porcentagem 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 o
seu valor sim.
Cada uma das barras de cor que indica o valor da resistência corresponde a
um dígito / cores e são listados na tabela abaixo. Figura 1-B mostra como
usar cada barra de cor com a tabela para determinar o valor de um resistor.
Digito
0
1
2
3
4
5
6
7
8
9
•
•
Cor
Preto
Marrom
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco
Tolerance
Code
First Digit
Number of Zeros
Figura B-1
Resistor cor e
códigos
Second Digit
Primeira faixa é amarela, e significa que o dígito mais à esquerda é 4.
Segundo faixa é violeta, significa que o próximo dígito é 7.
•
Terceira faixa é marrom. Como marrom é 1, significa adicionar um
zero à direita dos dois primeiros dígitos.
O valor desse resistor é 470 Ω.
Regras da Breadboarding
Olhe para o seu Board of Education ou HomeWork Board. O quadrado
branco com muitos buracos, ou bases, é chamado de "solderless
breadboard”, ou seja, placa de prototipagem sem soldas. Este breadboard,
combinado com os faixas pretas de bases ao longo de dois dos seus lados, é
chamado de" área de prototipagem” (mostrado na Figura B- 2).
Os exemplos de circuitos neste texto são construídos ligando componentes,
como resistores, diodos emissores de luz, alto-falantes e sensores para esses
pequenos soquetes. Os componentes são ligados uns aos outros com as
tomadas breadboard. Você vai alimentar o seu circuito com eletricidade a
partir dos terminais de potência, que são as órbitas negras na parte superior
rotulada Vdd, Vin, e VSS. As tomadas pretas à esquerda são rotuladas P0,
P1, até P15. Estas tomadas permitem ligar seu circuito aos pinos de entrada /
saída do BASIC Stamp.
Vdd
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
Figura B-2
Área de prototipagem
Terminais de alimentação
(tomadas pretas ao longo da
parte superior), pinos de
acesso I/O (In/Out, soquetes
preto na lateral), e placa de
prototipagem sem solda
(soquetes brancos).
A placa de montagem tem 17 linhas de soquetes separados em duas colunas
por uma calha. A calha divide cada uma das linhas de dezessete tomadas em
duas filas de cinco. Cada fileira de cinco bases é conectada eletricamente
dentro da breadboard. Você pode usar essas linhas de soquetes para conectar
componentes ditados por um circuito esquemático. Se introduzir dois fios
em quaisquer das duas tomadas na mesma linha 5 de encaixe, eles estarão
eletricamente ligados uns aos outros.
Um diagrama esquemático do circuito é um roteiro que mostra como
conectar os componentes juntos. Utiliza símbolos únicos, cada um
representando um componente diferente. Os símbolos dos componentes
estão ligados por linhas para indicar uma conexão elétrica. Quando dois
símbolos de circuito estão ligados por linhas sobre uma representação
esquemática, a linha indica que a ligação eléctrica é feita. As linhas podem
também ser usadas para ligar os componentes de abastecimento de tensão.
Vdd, Vin, e Vss todos têm símbolos. VSS corresponde ao terminal negativo
da alimentação da bateria para o Board of Education ou BASIC Stamp
HomeWork Board. Vin é o terminal positivo da bateria, e Vdd é regulada
para + 5 volts.
Vamos dar uma olhada em um exemplo que usa um esquema para ligar as
peças mostradas na Figura B-3. Para cada uma destas peças, no desenho da
parte de cima é mostrado o símbolo esquemático.
Gold
Silver
or
Blank
Yellow
Violet
Brown
Figura B-3
Desenhos de peças e
símbolos esquemáticos
LED(esquerda) e
resistor 470 Ω (direita)
+
470 Ω
LED
A Figura B-4 mostra um exemplo de um diagrama esquemático do circuito
do lado esquerdo e um desenho de um circuito, que pode ser construído
usando este esquema da direita. Observe como o esquema mostra que uma
das extremidades da linha denteada indica que uma resistência está ligada ao
símbolo para VDD. No desenho, um dos dois terminais do resistor é
conectado a uma das tomadas rotuladas Vdd. No esquema, o outro terminal
da resistência está ligado ao símbolo por uma linha para o terminal + do
símbolo LED. Lembre-se, a linha indica as duas partes que estão conectadas
eletricamente. No desenho, isto é conseguido ligando o outro terminal da
resistência na mesma fileira de 5 tomadas, como na extremidade + do LED.
Isto conecta eletricamente as duas pistas. O outro terminal do LED é
mostrado ligado ao símbolo Vss no esquema. No desenho, o outro terminal
do LED está ligado a uma das tomadas rotuladas Vss.
Vdd
X3
Vdd
470 Ω
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura B-4
Exemplo esquemático
e Diagrama de Fiação
Esquemático
(esquerda) e
diagrama de fiação
(à direita)
Figura B-5 mostra um segundo exemplo de um diagrama esquemático e
fiação. Aqui, P14 é ligado a uma extremidade de uma resistência, com a
outra extremidade ligada ao terminal + de um LED, e o terminal - do LED
está ligado a Vss. Estes dois esquemas diferem por uma única conexão. O
extremidade da resistência que estava ligada a Vdd está agora ligado ao pino
P14 do BASIC Stamp I/O. O esquema pode parecer muito diferente do que
isso, porque o resistor é mostrado horizontalmente em vez de verticalmente.
Mas, em termos de conexões só difere por um, P14 no lugar de Vdd.
Vdd
X3
P14
470 Ω
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura B-5
Exemplo
Esquemático e
Diagrama de Fiação
Esquemático
(esquerda) e
diagrama de fiação
(à direita)
Aqui está um exemplo mais complexo, que envolve peças adicionais: um
resistor de 1 kW, um fototransistor e um capacitor. Os símbolos
esquemáticos e desenhos de peças para os componentes que ainda não são
familiares são mostrados na Figura B-6. Os terminais do fototransistor são
rotulados C, B e E. O terminal B é ótico, por isso não tem nenhuma conexão
elétrica. O terminal C é o pino maior, e o terminal E é o pino mais curto que
sai da caixa de plástico mais perto de um local plano ao lado.
Light
B
Collector
C
Base
Flat spot and shorter
pin indicate the
emitter (E) terminal
B
E
Current
Emitter
E
C
Figura B-6
Desenhos das peças e
símbolos
esquemáticos
Fototransistor (topo)
Capacitor não polar
(parte inferior)
0.1 μF Capacitor Schematic
Symbol and Part Drawing
Uma vez que este esquema mostrado na Figura B-7 solicita um resistor de 1
kΩ, que é 1000 Ω, o primeiro passo é consultar para determinar o código de
cor do resistor. O código de cor é marrom-preto-vermelho. Esta resistência
está ligada a P6 no esquema, que corresponde ao resistor conectado na
tomada denominada P6 na área de prototipagem (Figura B-8). No esquema,
o outro terminal da resistência não está ligado a um, mas a dois outros
terminais: o terminal C do fototransistor e um dos terminais do capacitor. Na
breadboard, um dos terminais do resistor está ligado a uma das 5 linhas de
soquetes da breadboard. Esta linha também tem o terminal C do
fototransistor e o outro terminal do capacitor conectado a ela. No esquema, o
terminal E do fototransistor e a outra ponta do capacitor estão conectados a
Vss. Quando construir circuitos em uma placa de montagem, um fio para
conectar uma linha inteira na breadboard para outra linha, ou até mesmo
para pinos de I/O ou terminais de energia, como Vdd ou Vss são
necessários. Neste caso, foi utilizado um fio para ligar uma linha Vss na
placa de montagem, breadboard. Então, a ligação da ponta E do
fototransistor e a outra ponta do capacitor estão conectadas à mesma linha
que os conecta ao Vss, completando o circuito.
Figura B-7
Esquemática com o
Resistor,
Fototransistor e
Capacitor
Figura B-8
Diagrama de
ligações do Resistor,
Fototransistor e
Capacitor
Local plano e pino
mais curto
Tenha em mente que os esquemas de ligações aqui apresentados como
soluções para os esquemas não são as únicas soluções para esses esquemas.
Por exemplo, a Figura 9-B mostra uma outra solução para o esquema que
acabamos de discutir. Siga as ligações e se convença de que isso satisfaz o
esquema.
Figura B-9
Diagrama de ligações
do Resistor,
Fototransistor e
Capacitor
Control
Horn
Local plano e
pino mais
curto
Observe a colocação
alternativa dos
componentes.
Boe-Bot Navigation Contests · Page 378
Anexo C: Competições de Navegação do Boe-Bot
Se você está planejando uma competição para robôs autônomos, estas regras
em cortesia da Seattle Robotics Society poderão ser úteis.
Concurso #1: Exercícios No Solo com Robô
Propósito
O exercício de competição de solo destina-se a dar a inventores de robôs
uma oportunidade de mostrar os seus robôs ou outras engenhocas técnicas.
Regras
As regras para esta competição são bastante simples. Designar uma área
plana de 3 metros por 3 metros, de preferência com algum limite físico nas
fronteiras. Cada participante receberá um máximo de cinco minutos nessa
área para mostrar o que seu robô pode fazer. O demonstrador do robô pode
falar e explicar os vários recursos e funções do robô. Como é hábito,
qualquer robô que possa danificar a área ou representar um perigo para o
público não será permitido na arena. Robôs não precisam ser autônomos,
mas são encorajados a ser. O julgamento será determinado pelo público, a
votação será indicada por palmas (o mais alto será determinado pelo juiz),
ou algum outro mecanismo de votação.
Concurso #2: Seguindo a Linha
Objetivo
Construir um robô autônomo que começa na Área "A" (na posição "S"),
percorre para a Área "B" (completamente através da linha), em seguida,
percorre para a área "C" (completamente através da linha), em seguida,
retorna para a área "A" (na posição "F"). O robô que faz isso no menor
espaço de tempo (incluindo bônus) ganha. O robô deve entrar nas áreas "B"
e "C" para se qualificar. O layout exato do percurso não será conhecido até o
dia da competição, mas terá as três áreas descritas anteriormente.
Testando a Habilidade
A capacidade de reconhecer um auxílio de navegação (a linha) e usá-lo para
alcançar a meta.
Tempo Máximo para Concluir Curso
Quatro minutos.
Exemplo de Percurso
Todas as medidas de curso são aproximadas. Há uma linha sólida dividindo
Área "A" da área "T" na posição "F" Isso indica que o curso termina. A
linha negra é de aproximadamente 6 centímetros de largura (2,25”) e
espaçadas aproximadamente um metro das paredes. Todas as curvas têm um
raio de pelo menos 30 centímetros e no máximo 1 metro. As paredes
possuem 10 centímetros de altura e cercam toda a área do percurso. O piso
deve ser branco e feito de papel ou com Dupont Tyvekum® forte plástico
usado em envelopes de correspondência e construção de casas.
As posições "S" e "F" são apenas para ilustrações e não são locais precisos.
Os competidores devem colocar o robô em qualquer lugar na área "A", em
qualquer direção quando se inicia. O robô deve estar completamente dentro
da área "A". As áreas "A", "B" e "C" não são de cor vermelha no percurso
real.
Figura D-1
Exemplo de percurso do
Concurso
Pontuando
A pontuação de cada concorrente é calculada tomando o tempo necessário
para concluir o curso (em segundos) menos de 10% para cada "conquista."
O competidor com a menor pontuação ganha.
Pontuação Seguindo a Linha
Realizado
Porcentagem
deduzida
Parar na área A após atingir B e C
10%
Não tocar em nenhuma das paredes
10%
Iniciar ao Comandado
10%
("Iniciar ao Comandado" significa que o robô inicia com um comando
externo, sem toque. Isto poderia, por exemplo, ser um som ou um comando
de luz.)
Concurso #3: Seguindo No Labirinto
Propósito
O grande labirinto tem como objetivo apresentar um teste de habilidades de
navegação por um robô autônomo. O sistema de pontuação é feito de tal
forma a favorecer robôs que são brutalmente rápidos ou que podem aprender
a passar pelo labirinto. O objetivo para um robô, que está parado na entrada
do labirinto, é encontrar o seu caminho através do labirinto e chegar a saída
no menor espaço de tempo possível.
Características Físicas
O labirinto é construído em madeira compensada de 3/4" ou 20 milímetros
de espessura. As paredes possuem aproximadamente 60 centímetros de
altura, e são pintadas em cores primárias e brilhante. As paredes são
definidas em uma grade com espaçamento de 24” ou 60 centímetros. Devido
à espessura do compensado e limitações na precisão, os corredores podem
ser estreitos com até 22” ou 55 centímetros. O labirinto pode ser de até 2
metros quadrados, mas pode ser menor, dependendo do espaço disponível
para o evento.
O labirinto será criado em um tapete do tipo industrial ou piso duro
(dependendo de onde o evento será realizado). O labirinto deverá estar em
um local coberto, para que o seu robô não precise ser à prova de chuva, no
entanto, podem ser expostos a diferentes temperaturas, vento e as condições
de iluminação. O labirinto é um labirinto bidimensional clássico: existe um
único caminho desde o início até ao fim, e não existem ilhas no labirinto.
Tanto a entrada como a saída situam-se nas paredes externas do labirinto.
Este tipo de labirinto pode ser resolvido seguindo tanto a parede esquerda
quanto a parede direita. O labirinto é cuidadosamente construído de modo
que não exista nenhuma vantagem ao seguir a parede esquerda ou direita.
Limitação do Robô
O limite principal do robô é que ele seja autônomo: uma vez iniciado pelo
proprietário ou operador, nenhuma interação é permitida até que o robô saia
pela saída, ou torna-se irremediavelmente preso. Obviamente, o robô precisa
ser pequeno o suficiente para caber dentro das paredes do labirinto. Ele pode
tocar as paredes, mas não pode mover as paredes. Os juízes podem
desqualificar um robô que parecer estar movendo as paredes
excessivamente. O robô não deve danificar as paredes do labirinto, nem o
chão. Qualquer forma de energia é permitida, desde que as leis locais não
requeiram proteção auditiva em sua presença ou coloquem quaisquer outras
limitações sobre ele.
Pontuação
Cada robô deve executar o percurso através do labirinto três vezes. O robô
com o menor tempo é o vencedor. O tempo máximo permitido por tentativa
é de 10 minutos. Se um robô não pode terminar neste tempo pré
determinado, a tentativa é interrompida e o robô recebe um tempo de 10
minutos. Se nenhum robô conseguir encontrar a saída do labirinto, o que
percorrer a maior distância dentro do labirinto será declarado vencedor,
conforme determinado pelo juiz da competição.
Logística
Cada robô fará uma tentativa, prosseguindo até que todos os robôs tenham
tentado fazer o percurso do labirinto. Cada robô então terá uma segunda
tentativa no labirinto, e então todos farão a terceira tentativa. O juiz vai
permitir alguma mudança se um competidor atrasar a sua execução devido a
dificuldades técnicas. O robô deverá se lembrar como foi no último percurso
e tentar utilizar isso em sua nova chance (mapeando o labirinto na primeira
tentativa) e pode usar essas informações em subsequências, desde que as
faça por si só. Não é permitido configurar manualmente o robô através de
hardware ou software para o percurso do labirinto.
Página 383
Partes e quantidades estão sujeitas a alterações sem prévio aviso. As peças podem se
diferenciar do que é apresentado nesta imagem a seguir. Qualquer dúvida favor entrar
em contato com a BS Educacional, através do [email protected] ou
telefone +55 (11) 2533-9478.

Robótica com Boe-Bot

Transcrição

Documentos relacionados

Ficha Técnica

SPOT LED GX53 SMD 7W VT-1868

Casamentos Formaturas Debutantes

364 fixação poste individual

Novidade Total Glass

Reinos Germânicos e Império Carolíngio

KB S-6 0 AN

Redução Consumo Energia

Um projeto básico, pequenas dimensões. Liset é um inovador

Teclado POSITIVO