Robótica com Boe-Bot - Parallax Inc

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

mailto:[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


mailto:educa%C3%A7%C3%[email protected]


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



http://www.bseducacional.com.br/


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. Deve-se modificar esses dois comandos para que as respostas apareçam em linhas diferentes no DEBUG Terminal.

DEBUG DEC 7 * 11 DEBUG DEC 7 + 11

Projetos 1. Use o DEBUG para mostrar a solução do problema de cálculo:

1+2+3+4 2. Salve seu primeiro programa YourTurn.bs2 com um outro nome.

Se 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

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.

Horn de controle

Chave phillips

A etiqueta deve ser lida “Rotação Contínua”

Dentro da caixa há um motor elétrico, circuitos e engrenagens

Cabo de alimentação e controle de sinal

Flange de montagem

Plugue conector para o servo RC

Flange de montagem

Furo de acesso ao potenciometro para ajuste de retorno de centro


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.

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

470 ΩYellow

VioletBrown

GoldSilverorBlank


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.

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.

+ _

LED


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.


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.

P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω

P15P14

P11P10P9P8P7P6P5P4P3P2P1P0

P13P12

X2

X3Vdd VssVin

++

Figura 2-4 Dois LEDs Conectados ao BASIC Stamp I / O pins P13 e P12 Esquemático(esquerda) e esquema de ligações (à direita)


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

NNN+

=

NN

N

+

_ -

+

---++

+

---++

+

--+

NNN+

NN

N

Vdd

Vss

5 V

Vdd

Vss

5 V


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.

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

SOUTSINATNVSS

P0P1P2P3P4P5P6P7

VINVSSRESVDD (+5V)P15P14P13P12P11P10P9P8

24

23

22

21

20

19

18

17

16

15

14

13

1

2

3

4

5

6

7

8

9

10

11

12

BS2-IC

BS2

Vdd

Vss

SOUTSINATNVSS

P0P1P2P3P4P5P6P7

VINVSSRESVDD (+5V)P15P14P13P12P11P10P9P8

24

23

22

21

20

19

18

17

16

15

14

13

1

2

3

4

5

6

7

8

9

10

11

12

BS2-IC

BS2

Vdd

Vss


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ão-padrã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 O LED on / off estados são mostrados acima no diagrama de temporização.

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.

Vdd (5 V)

Vss (0 V)

500 ms

1000 ms

…

500 ms


Você também pode fazer que vários LEDs pisquem ao mesmo tempo. Modifique o programa para os comandos parecidos com este:

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 é:

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.

Figura 2-8 Diagrama de tempo para PulseP13Led.bs2

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.

s13.0s000002.065000

s265000Duration

=×=×= µ

Vdd (5 V)

Vss (0 V)

0.13 s 0.13 s

2.0 s


' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Programa funcionando!" 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 DEBUG "Programa funcionando!" 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. Modifique o programa para os comandos parecidos com este:

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.


Figura 2-10 BASIC Stamp Switching 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.

(916) 624-8333www.parallaxinc.comwww.stampsinclass.com

Rev B

X3Vdd VssVin

Board of Education

© 2000-2003

P3P2P1P0

X2

Rev C

Rev B

BlackRed

X3Vdd VssVin

X4 X5

15 14 13 12 STAMPS CLASSin

Vdd VssVR1

5X2

X3 nc

Rev A


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

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.

Reset

0 1 2


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

Selecione Vin se você estiver usando a bateria que vem com os kits Boe-Bot.

Selecione Vdd se você estiver usando uma fonte DC que se conecta a uma tomada AC (adaptador AC).

Figura 2-12 Seleção de Abastecimento das portas de seu Servo no Board of Education

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.

BlackRed

X4 X5

15 14 13 12Vdd

Vin

BlackRed

X4 X5

15 14 13 12Vdd

Vin


Figura 2-13 Conexões do servo para o Board of Education

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

Vin

Vss

P13 WhiteRedBlack

Vin

Vss

P12 WhiteRedBlack

WhiteRedBlack

BlackRed

X4 X5

15 14 13 12Vdd

WhiteRed

Black


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.

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.

P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω

P15P14

P11P10P9P8P7P6P5P4P3P2P1P0

P13P12

X2

X3Vdd VssVin

++


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.

Figura 2-17 Esquema de conexão do Servo para o BASIC Stamp HomeWork Board Nota: Vbp significa bateria de tensão. Veja o i-box abaixo.

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.

Vbp

Vss

P12 WhiteRedBlack

Vbp

Vss

P13 WhiteRedBlack


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

Porta conexões 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

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

P13 Vbp Vss Vbp P12

Solid Black Wire Black wire with

white stripe

White Red Black Red White


Reconstruir o circuito de LED, como mostrado na Figura 2-20.

Figura 2-20 Sinal de Circuito de LED do monitor do servo.

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

P15P14

P11P10P9P8P7P6P5P4P3

P1P0

P13P12

P2

X2

X3Vdd VssVin


HomeWork Board

Rev B

© 2002

+Vss

+

P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω


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.

Figura 2-22 Diagrama de tempo para CenterServoP12.bs2 Os pulsos de 1,5 ms instruem o servo a ficar parado.

P12

1.5 ms 1.5 ms

20 ms


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:

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

750s000002.0

s0015.0s2

durationPulseargumentDuration =µ

=


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 DEBUG "Programa funcionando!" DO PULSOUT 12, 750 PAUSE 20 LOOP

0 1 2


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


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 DEBUG "Programa funcionando!" 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 VAR Word anotherValue VAR 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 ' Declarar variáveis anotherValue VAR Word value = 500 ' Inicializa variáveis anotherValue = 2000 DEBUG ? value ' Mostra valores DEBUG ? anotherValue value = 10 * anotherValue ' Executa operações DEBUG ? value ' Mostra valores novamente DEBUG ? anotherValue 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 ' Inicializar variáveis anotherValue = 2000

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 DEBUG ? anotherValue

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.

value = 10 * anotherValue 'Executar operações DEBUG ? value 'Mostrar valores novamente DEBUG ? anotherValue


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:

value = 10 * anotherValue 'Executar operações DEBUG ? value 'Mostrar valores novamente

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 FOR myCounter = 1 TO 10 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:

FOR myCounter = 21 TO 9 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.

Lembre-se do argumento opcional STEP StepValue PASSO StepValue. Você pode usá-lo para fazer contagem myCounter em etapas. 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 Boe-Bot. 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.

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.

Vdd (5 V)

Vss (0 V)

1.3 ms 1.3 ms

20 ms

www.parallax.com

standard servo


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 DEBUG "Programa funcionando!" 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 DEBUG "Programa funcionando!" 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.

Figura 2-26 A 1,7 ms trem de pulso torna a velocidade de Turno Completo Servo anti-horá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

Vdd (5 V)

Vss (0 V)

1.7 ms 1.7 ms

20 ms

www.parallax.com standard servo


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 DEBUG "Programa funcionando!" 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 Descrição Comportamento P13 P12

850 650 Velocidade máxima, P13 servo anti-horário, servo P12 no sentido horário.

650 850

850 850

650 650

750 850

650 750

750 750

Ambos os servos devem permanecer ainda por causa dos ajustes feitos na centralização Atividade # 4

760 740

770 730

850 700

800 650


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.

Vamos dizer que você quer que o servo de funcione 4,6 segundos. Seu loop FOR ... NEXT terá que executar o dobro de vezes:

FOR counter = 1 TO 200 PULSOUT 13, 850 PAUSE 20 NEXT

s30.2s0230.0100

ms0.23100time

=×=×=


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 DEBUG "Programa funcionando!" counter VAR Byte FOR counter = 1 TO 100 PULSOUT 13, 850 PAUSE 20 NEXT FOR counter = 1 TO 200 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 – Servo conectado à P13 1.3 ms – Servo conectado à P12 20 ms – Duração da pausa 1.6 ms – Code overhead --------- ------------------------------ 24.6 ms – 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:

FOR counter = 1 TO 122 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 DEBUG "Programa funcionando!" counter VAR Byte FOR counter = 1 TO 122 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT


FOR counter = 1 TO 122 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.

FOR counter = 9 TO 21 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 DEBUG "Programa funcionando!" DO PULSOUT 12, 650 ' P12 servo gira no sentido horário PULSOUT 14, 650 ' P14 LED pisca é iluminado PAUSE 20 LOOP

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 3. Número de pulsos = 3 s / s = 0,0246 121,9 = 122 4. Número de pulsos = 3 s / s = 0,0246 121,9 = 122 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 DEBUG "Programa funcionando!" counter VAR Word FOR counter = 1 TO 120 ' Loop por três segundos PULSOUT 13, 850 ' P13 servo anti-horário PULSOUT 12, 850 ' P12 servo anti-horário PAUSE 20 NEXT FOR counter = 1 TO 124 ' Loop por três segundos PULSOUT 13, 650 ' P13 servo sentido horário PULSOUT 12, 650 ' P12 servo sentido horário PAUSE 20 NEXT FOR counter = 1 TO 122 ' Loop por três segundos PULSOUT 13, 650 ' P13 servo sentido horário PULSOUT 12, 850 ' P12 servo sentido anti-horário


PAUSE 20 NEXT FOR counter = 1 TO 122 ' Loop por três segundos PULSOUT 13, 850 ' P13 servo anti-horário PULSOUT 12, 650 ' P12 servo horário PAUSE 20 NEXT END

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 Montando o Boe-Bot. 2 Testar novamente os servos para se certificar de que eles estão

conectados corretamente. 3 Ligar e testar um alto-falante que o avisará quando as baterias do Boe-

Bot estiverem baixas. 4 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:

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 Peças (esquerda); montadas (à direita)

Phillips Screw Output

Shaft

Control Horn


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

Lista de Peças para o Boe-Bot com 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 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

Lista de Peças para o Boe-Bot com Board of Education: Ver lado esquerdo 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

Lista de Peças para Boe-Bot com o HomeWork Board: Ver lado direito da figura 3-9. (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

Figura 3-10 Portas Servo conectadas na Board of Education e na HomeWork Board

Board of Education 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.

BlackRed

X4 X5

15 14 13 12Vdd

WhiteRedBlack

WhiteRed

Black

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

P13 - White Vbp - Red Vss - Black Vbp - Red P12 - White

Solid Black

White Stripe


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.

Figura 3-14 Testando a roda direita

Clockwise 3 seconds

Stop 1 second

Counterclockwise 3 seconds


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ção-

3 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 FOR counter = 1 TO 122 ' No sentido horário, 3 segundos. PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 1 TO 40 ' Para um segundo. PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 1 TO 122 ' No sentido anti-horário, 3 segundos. PULSOUT 12, 850 PAUSE 20 NEXT


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.

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.

Clockwise 3 seconds Stop 1 second Counterclockwise 3 seconds


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 alto-falante 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”.

Figura 3-17 Programa do Circuito Indicador de Start/Reset

P4

Vss


Figura 3-18 Diagramas de fiação para o Programa Start / Reset Indicador de Circuito Board of Education (esquerda) e HomeWork Board (direita)

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

P15P14P13P12P11P10P9P8P7P6P5

P3P2P1P0

P4

X2

X3Vdd VssVin

Board of Education © 2000-2003Rev C

Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P4

P10P9P8P7P6P5

P3P2P1P0

X2

X3Vdd VssVin

Rev B(916) 624-8333www.parallax.comwww.stampsinclass.com

To Servos

+

HomeWork Board


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 ' Stamp diretiva ' $PBASIC 2.5 ' PBASIC diretiva DEBUG CLS, "Beep!!!" ' Exibe enquanto alto falante emite som. FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset DO ' DO...LOOP DEBUG CR, “Aguardando Reset...” ' Exibe mensagem PAUSE 500 ' A cada 0.5 segundos LOOP ' 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.

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

Transmitir Windowpane

Receber Windowpane


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 Word pulseWidth VAR Word pulseWidthComp VAR Word FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. DO DEBUG "Informe a largura de pulso: "


DEBUGIN DEC pulseWidth pulseWidthComp = 1500 - pulseWidth FOR counter = 1 TO 244 PULSOUT 12, 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 VAR Word pulseWidth VAR Word pulseWidthComp VAR 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: " DEBUGIN DEC pulseWidth

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.

FOR counter = 1 TO 244 PULSOUT 12, pulseWidth 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.

Figura 3- 20 Exemplo de transferência de Curva para Servo de Rotação Contínua da Parallax

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.

Rotational Velocity vs. Pulse Width for Servo

-60

-40

-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, ms

Rot

atio

nal V

eloc

ity, R

PM

Right Servo


Tabela 3 1: Largura de Pulso e RPM para Parallax Servo Rotação Contínua Largura de Pulso (ms)

Velocidade (RPM)

Largura de Pulso (ms)

Velocidade (RPM)


Velocidade (RPM)


Velocidade (RPM)

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

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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Sinal de início de programa. FOR counter = 1 TO 122 ' Sentido horário por 3 segundos. PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 1 TO 40 ' Pára por um segundo. PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 1 TO 122 ' Sentido anti-horário por 3 segundos. PULSOUT 12, 850 PAUSE 20 NEXT 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 VAR Word ' Largura de pulso do servo esquerdo rtPulseWidth VAR Word ' Largura de pulso do servo direito pulseCount VAR Byte ' 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 ' Envia número específico de pulsos PULSOUT 13, ltPulseWidth ' Servo esquerdo mexe PULSOUT 12, rtPulseWidth ' Servo direito mexe PAUSE 20 NEXT LOOP

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

2 Ajustar as manobras de Atividade N º 1 de modo que elas sejam mais precisas.

3 Use matemática para calcular o número de pulsos para fazer o Boe-Bot percorrer uma distância pré-determinada.

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

5 Escreva sub-rotinas para executar as manobras básicas para que cada sub-rotina possa ser usada repetidas vezes em um programa.

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

Figura 4-1 Direções do seu Boe-Bot.

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.

Vire a esquerda

Para trás

Vire a direita

Para frente


Figura 4-2 Rotação da roda de movimento.

Lado esquerdo 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 servo-corre. 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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. FOR counter = 1 TO 122 ' Faz os servos funcionarem por 3 segundos. PULSOUT 13, 850

Sentido-

horário

frente

Sentido anti-horário frente


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



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


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


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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset.


FOR counter = 1 TO 64 ' Para frente PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 24 ' Vire a esquerda, cerca de 1/4 de volta PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 24 ' Vire a direita, cerca de 1/4 de volta PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 64 ' 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).


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.


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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. FOR counter = 1 TO 407 ' Numero de pulsos – tempo de execução. PULSOUT 13, 850 ' Servo esquerdo, máxima velocidade, sentido ' anti-horário. PULSOUT 12, 650 ' Servo direito, máxima velocidade, sentido ' horário. PAUSE 20


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 virar à esquerda do programa ForwardLeftRightBackward.bs2:

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 Boe-Bot 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:

speed

distancetime =


Exemplo – Tempo no Sistema Inglês 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á.

Exemplo – Tempo no Sistema Métrico 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á.

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:

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.

hours2miles70hour1miles140

miles/hour 70miles 140time

=

×=

=

hours2km100

hour1km200

/hourkilometers 100kilometers 200time

=

×=

=

speedBot-Boedistance Bot-Boetimerunservo =


Figura 4-3: Medindo a Distância do Boe-Bot

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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. FOR counter = 1 TO 41 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT END

www.stampsinclass.com

Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATNVssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1

VssP1P3P5P7P9P11P13P15Vin

VssP0P2P4P6P8P10P12P14Vdd

U1

TM

0 1 2© 2000-2003

Vdd

P15P14P13P12P11P10P9P8P7P6P5P4P3P2P1P0

X2

X3Vdd VssVin

Rev C

1 2 3 4 5 61 2 3 4 5 6 7 8 9 10 11 12 13 14 15

inch

cm

7 8 9 1016 17 18 19 20 21 22 23 24 25

Measured Distance


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 À 9 in/s, seu Boe-Bot tem 2,22 s para percorrer 20 polegadas.

Exemplo – Tempo para 51 centímetros À 23 cm/s, seu Boe-Bot tem 2,22 s para percorrer 51 centímetros.

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

s22.2in 9s1in 20

in/s 9in 20time

=

×=

=

s22.2cm 23s1cm 15

cm/s 23cm 51time

=

×=

=


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.

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.

pulses90pulses...24.90

spulses65.40s22.2ulsesp

≈=

×=

spulses65.40

speedBotBoecetandisBotBoeulsesp ×

−−

=


Exemplo – Tempo para 20 polegadas À 9 in/s, seu Boe-Bot precisa de 2,22 s para percorrer 20 in.

Exemplo – Tempo para 51 centímetros À 23 cm/s, seu Boe-Bot precisa de 2,22 s para percorrer 51 cm.

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:

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.


pulses65.40920s1pulses65.40

in 9 s1in 20

spulses65.40

in/s 9in 20ulsesp

≈=

×÷=

××=

×=


pulses65.402351s1pulses65.40

cm23 s1cm15

spulses65.40

cm/s 23cm 51ulsesp

≈=

×÷=

××=

×=

spulses65.40

speedBotBoecetandisBotBoeulsesp ×

−−

=


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 NEXT

Figura 4-4 Exemplo de rampa

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 DEBUG "Programa funcionando!" pulseCount VAR Word ' Contador do loop FOR...NEXT. ' -----[ Inicialização ]---------------------------------------------------- FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. ' -----[ Rotina Principal ]--------------------------------------------------- ' Subindo a rampa. FOR pulseCount = 1 TO 100 ' Loop para subir a rampa com 100 pulsos.

1, 2, 3, …100


PULSOUT 13, 750 + pulseCount ' Pulso = 1.5 ms + pulseCount. PULSOUT 12, 750 - pulseCount ' Pulso = 1.5 ms – pulseCount. PAUSE 20 ' Pausa por 20 ms. NEXT ' Andando para a frente por 75 pulsos. FOR pulseCount = 1 TO 75 ' Loop manda 75 pulsos a frente. PULSOUT 13, 850 ' 1.7 ms pulsos para servo esquerdo. PULSOUT 12, 650 ' 1.3 ms pulsos para servo direito. PAUSE 20 ' Pausa por 20 ms. NEXT ' Descendo a rampa e parada total. FOR pulseCount = 100 TO 1 ' Loop para descer a rampa com 100 pulsos. PULSOUT 13, 750 + pulseCount ' Pulso = 1.5 ms + pulseCount. PULSOUT 12, 750 - pulseCount ' Pulso = 1.5 ms - pulseCount. PAUSE 20 ' Pausa por 20 ms. NEXT END ' Fica parado até pressionar reset.

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. FOR pulseCount = 1 TO 100 PULSOUT 13, 750 - pulseCount PULSOUT 12, 750 + pulseCount 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. FOR pulseCount = 0 TO 30 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 + pulseCount PAUSE 20 NEXT ' Descendo a rampa com curva para a direita. FOR pulseCount = 30 TO 0 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 + pulseCount 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 SUB-ROTINAS 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 sub-rotinas.

Dentro da Sub-Rotina Uma sub-rotina PBASIC tem duas partes. Uma parte é o chamado da sub-rotina. É 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 sub-rotina” 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 "Antes da sub-rotina”, CR PAUSE 1000 GOSUB My_Subroutine DEBUG "Após sub-rotina", CR PAUSE 1000 LOOP My_Subroutine: DEBUG "Comando na sub-rotina", CR PAUSE 1000 RETURN

Figura 4-5 Sub-rotinas básicas

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 "Antes da sub-rotina”, CR PAUSE 1000 GOSUB My_Subroutine DEBUG "Após sub-rotina", CR END 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.

1

2


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 High_Pitch DEBUG "De volta no principal", CR PAUSE 1000 GOSUB Low_Pitch DEBUG "De volta no principal, de novo", CR PAUSE 1000 DEBUG "Repete...”, CR, CR LOOP 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 DEBUG "Programa funcionando!" counter VAR Word FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. GOSUB Forward GOSUB Left GOSUB Right GOSUB Backward END Frente: FOR counter = 1 TO 64 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 RETURN Esquerda: FOR counter = 1 TO 24 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 RETURN Direita: FOR counter = 1 TO 24 PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT PAUSE 200 RETURN Para trás: FOR counter = 1 TO 64 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 FOR counter = 1 TO 64 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT

' Descendo a rampa de ré a velocidade máxima. FOR pulseCount = 100 TO 1 PULSOUT 13, 750 - pulseCount PULSOUT 12, 750 + pulseCount 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 DEBUG "Programa funcionando!" counter VAR Word pulseLeft VAR Word pulseRight VAR Word pulseCount VAR Byte FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. ' Para frente pulseLeft = 850: pulseRight = 650: pulseCount = 64: GOSUB Navigate ' Curva para esquerda pulseLeft = 650: pulseRight = 650: pulseCount = 24: GOSUB Navigate ' Curva para direita pulseLeft = 850: pulseRight = 850: pulseCount = 24: GOSUB Navigate ' Para trás pulseLeft = 650: pulseRight = 850: pulseCount = 64: GOSUB Navigate END Navigate: FOR counter = 1 TO pulseCount 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 Boe-Bot 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 VAR Word ' Armazena número de pulsos. address VAR Byte ' Armazena endereço do EEPROM. instruction VAR Byte ' Armazena instrução do EEPROM. ' -----[ EEPROM Dados ]------------------------------------------------------ ' Address: 0123456789 ' Essas duas linhas comentadas mostram ' |||||||||| ' EEPROM endereço de cada dado DATA "FLFFRBLBBQ" ' Instruções de navegação. ' -----[ Inicialização ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. ' -----[ Rotina Principal ]--------------------------------------------------- DO UNTIL (instruction = "Q") READ address, instruction ' Dados das instruções de endereço. address = address + 1 ' Adiciona 1 no endereço na próxima leitura SELECT instruction ' Chama diferentes sub-rotinas CASE "F": GOSUB Forward ' Para cada caractere possível CASE "B": GOSUB Backward ' Que pode ser obtido em CASE "L": GOSUB Left_Turn ' EEPROM. CASE "R": GOSUB Right_Turn ENDSELECT LOOP END ' Fica parado até pressionar o Reset. ' -----[ Sub-rotina - Frente ]----------------------------------------------- Forward: ' Sub-rotina para andar para frente. FOR pulseCount = 1 TO 64 ' Envia 64 pulsos. PULSOUT 13, 850 ' 1.7 ms pulsos para o servo esquerdo. PULSOUT 12, 650 ' 1.3 ms pulsos para o servo direito. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna para loop da rotina principal. ' -----[ Sub-rotina – Trás ]-------------------------------------------------- Backward: ' Sub-rotina para andar para trás. FOR pulseCount = 1 TO 64 ' Envia 64 pulsos. PULSOUT 13, 650 ' 1.3 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 loop da rotina principal.


' -----[ Sub-rotina – Curva a esquerda ]-------------------------------------- Left_Turn: ' Sub-rotina para virar à esquerda. FOR pulseCount = 1 TO 24 ' Envia 24 pulsos. PULSOUT 13, 650 ' 1.3 ms pulsos para o servo esquerdo. PULSOUT 12, 650 ' 1.3 ms pulsos para o servo direito. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna para loop da rotina principal. ' -----[ Sub-rotina - Curva a direita ]--------------------------------------- Right_Turn: ' Sub-rotina vire a direita. FOR pulseCount = 1 TO 24 ' 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 0 2 4 6 8 Pulses_Count DATA Word 64, Word 24, Word 24, Word 64, Word 0 Pulses_Left DATA Word 850, Word 650, Word 850, Word 650 Pulses_Right DATA 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 PULSOUT 13, pulseLeft PULSOUT 12, pulseRight PAUSE 20 NEXT

....becomes....


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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. DEBUG "Programa funcionando!" ' -----[ Variáveis ]---------------------------------------------------------- counter VAR Word pulseCount VAR Word ' Armazena o número de pulsos. addressOffset VAR Byte ' Armazena o deslocamento do nome.


instruction VAR Byte ' Armazena instruções EEPROM. pulseRight VAR Word ' Armazena a largura dos pulsos de Servo. pulseLeft VAR Word ' -----[ EEPROM Dados ]------------------------------------------------------- ' addressOffset 0 2 4 6 8 Pulses_Count DATA Word 64, Word 24, Word 24, Word 64, Word 0 Pulses_Left DATA Word 850, Word 650, Word 850, Word 650 Pulses_Right DATA Word 650, Word 650, Word 850, Word 850 ' -----[ Inicialização ]------------------------------------------------------ FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. ' -----[ 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 FOR counter = 1 TO pulseCount PULSOUT 13, pulseLeft PULSOUT 12, pulseRight 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-esquerda-direita-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 Word 60, Word 80, Word 100, Word 110, Word 110, Word 100, Word 80, Word 60, Word 0 Pulses_Left DATA Word 850, Word 800, Word 785, Word 760, Word 750, Word 740, Word 715, Word 700, Word 650, Word 750 Pulses_Right DATA Word 650, Word 700, Word 715, Word 740, Word 750, Word 760, Word 785, Word 800, Word 850, Word 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 Boe-

Bot 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 Boe-Bot 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. Roda esquerda no sentido anti-horário, roda direita no sentido

horário. Q2. A roda direita está girando no sentido horário (para frente), e a

roda esquerda não está se movendo.


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 13, 750 + pulseCount PULSOUT 12, 750 – pulseCount PAUSE 20 NEXT

Q6. A diretiva DATA. Q7. O comando READ. Q8. SELECT...CASE...ENDSELECT. Q9. UNTIL e WHILE.

E1. FOR counter = 1 to 350 ' Backward

PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20

NEXT


E2. FOR counter = 1 to 8 ' Rotate right 30 degrees

PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT FOR counter = 1 to 12 ' Rotate right 45 degrees PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT FOR counter = 1 to 16 ' Rotate right 60 degrees PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT

FOR counter = 1 to 100 ' Forward PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 0 TO 30 ' Ramping pivot turn PULSOUT 13, 750 + counter PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 30 TO 0 PULSOUT 13, 750 + counter PULSOUT 12, 750 PAUSE 20 NEXT

FOR counter = 1 to 100 ' Forward PULSOUT 13, 850


PULSOUT 12, 650 PAUSE 20 NEXT

P1. P13 P12 Descrição Comportamento 850 650 Full Speed: P13 CCW, P12 CW Forward 650 850 Full Speed: P13 CW, P12 CCW Backward 850 850 Full Speed: P13 CCW, P12 CCW Right rotate 650 650 Full Speed: P13 CW, P12 CW Left rotate 750 850 P13 Stopped, P12 CCW Full speed Pivot back left 650 750 P13 CW Full Speed, P12 Stopped Pivot back right 750 750 P13 Stopped, P12 Stopped Stopped 760 740 P13 CCW Slow, P12 CW Slow Forward slow 770 730 P13 CCW Med, P12 CW Med Forward medium 850 700 P13 CCW Full Speed, P12 CW 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 DEBUG "Programa funcionando!" pulseCount VAR Word ' Contador de pulsos dos servos. FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. ' -----[ 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 DEBUG "Programa funcionando!" counter VAR Nib ' Triângulo tem três lados. pulseCount VAR Word ' Contador de pulsos dos servos FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. Main: FOR counter = 1 TO 3 ' Repete três vezes para o triângulo GOSUB Forward GOSUB Right_Rotate120 NEXT END Forward: FOR pulseCount = 1 TO 163 ' Para frente, uma jarda PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Right_Rotate120: FOR pulseCount = 1 TO 21 ' Gira para direita, 120 graus PULSOUT 13, 850 PULSOUT 12, 850


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 Boe-Bot 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 3-pinos m/m (2) Resistências, 220 Ω (vermelho-vermelho-marrom) (2) Resistências, 10 kΩ (marrom-preto-laranja)

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.


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.

Whisker below washer

Whisker above washer


Figura 5-4 Esquema dos bigodes

P7

P5

Vss Vss

Vdd Vdd

Right Whisker

LeftWhisker

10 kΩ10 kΩ

220 Ω

220 Ω


Figura 5-5: Diagrama de Fiação dos Bigodes para o Board of Education

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.

P15P14P13P12P11P10P9P8

P6

P3P2P1P0

P7

P5P4

X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

Left Whisker

Right Whisker

+


Figura 5-6: Diagrama de Fiação do Bigode para o HomeWork Board

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.

P15P14

P11

P13P12

P7

P5P4

P10P9P8

P6

P3P2P1P0

X2

X3Vdd VssVin


To Servos

Left Whisker

Right Whisker

+

HomeWork Board


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.

Figura 5-7 Esquema de bigodes Uma segunda olhada

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

P7

P5

Vss Vss

Vdd Vdd

Right Whisker

LeftWhisker

10 kΩ10 kΩ

220 Ω

220 Ω


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 ler-se: 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 Desligue a alimentação de sua placa e servos. 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).

Figura 5-9 Esquema de Teste do LED dos bigodes Adicione estes circuitos de LED.

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

P1

P10

Vss Vss

LEDLED

220 Ω

220 Ω


Figura 5-10: Bigode mais Diagrama de Fiação do LED para o Board of Education.

P15P14P13P12P11P10

P7

P5P4

P1

P9P8

P6

P3P2

P0X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

Left Whisker

Right Whisker

+

Flat spot on plastic case indicates cathode.

This lead is the anode

This lead is the anode.


Figura 5-11: Bigode mais Diagrama de Fiação do LED para o HomeWork Board.

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

P15P14

P11

P13P12

P10

P7

P5P4

P1

P9P8

P6

P3P2

P0X2

X3Vdd VssVin


To Servos

Left Whisker

Right Whisker

+

HomeWork Board

Flat spot on plastic case indicates cathode

Connect the anode to the 220 Ω resistor.

The anode connects to the 220 Ω resistor.


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 (IN7 = 0) THEN ' Bigode direito detecta obstáculo GOSUB Back_Up ' Volta e vira a esquerda GOSUB Turn_Left ELSE ' Ambos bigodes 1, sem contato GOSUB Forward_Pulse ' Impulso para a frente e ENDIF ' 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. DEBUG "Programa funcionando!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Byte ' FOR...NEXT contador de loop. ' -----[ Initialization ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Programa de sinal start/reset. ' -----[ Rotina Principal ]--------------------------------------------------- DO IF (IN5 = 0) AND (IN7 = 0) THEN ' 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 (IN7 = 0) THEN ' Bigode direito detecta obstáculo GOSUB Back_Up ' Volta e vira a esquerda GOSUB Turn_Left ELSE ' Ambos bigodes 1, sem contato GOSUB Forward_Pulse ' Impulso para a frente e ENDIF ' Checa novamente LOOP ' -----[ Sub-Rotinas ]-------------------------------------------------------- Forward_Pulse: ' Envia um único pulso para a frente PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 RETURN Turn_Left: ' Curva a esquerda, 90 graus FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Curva a direita, 90 graus PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN Back_Up: ' Ré FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

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.

IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN7 = 0) THEN 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..

IF (IN5 = 0) AND (IN7 = 0) THEN HIGH 10 HIGH 1 GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN HIGH 10 GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN7 = 0) THEN 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.


DEBUG "Programa funcionando!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Byte ' FOR...NEXT loop counter. counter VAR Nib ' Counts alternate contacts. old7 VAR Bit ' Stores previous IN7. old5 VAR Bit ' Stores previous IN5. ' -----[ Initialization ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Signal program start/reset. counter = 1 ' Start alternate corner count. old7 = 0 ' Make up old values. old5 = 1 ' -----[ 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 ' Both whiskers detect obstacle GOSUB Back_Up ' Back up & U-turn (left twice) GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN ' Left whisker contacts GOSUB Back_Up ' Back up & turn right GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Right whisker contacts GOSUB Back_Up ' Back up & turn left


GOSUB Turn_Left ELSE ' Both whiskers 1, no contacts GOSUB Forward_Pulse ' Apply a forward pulse ENDIF ' and check again LOOP ' -----[ Sub-Rotinas ]-------------------------------------------------------- Forward_Pulse: ' Send a single forward pulse. PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 RETURN Turn_Left: ' Left turn, about 90-degrees. FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Right turn, about 90-degrees. PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN Back_Up: ' Back up. FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

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 VAR Nib old7 VAR Bit old5 VAR 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 ' 4 kHz beep for 100 ms FREQOUT 4, 100, 4000 ' Repeat twice GOSUB Back_Up ' Back up & U-turn GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN ' Left whisker contacts FREQOUT 4, 100, 4000 ' 4 kHz beep for 100 ms GOSUB Back_Up ' Back up & turn right GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Right whisker contacts FREQOUT 4, 100, 4000 ' 4 kHz beep for 100 ms 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. DEBUG "Programa funcionando!" ' -----[ 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 ' Pulse servos in circular path PULSOUT 12, pulseWidth ' 12 slower than 13 so it arcs PAUSE 20 IF (IN5 = 0) THEN ' Left whisker makes circle IF (pulseWidth <= 845) THEN ' smaller, down to servo max pulseWidth = pulseWidth + 5 ' pulseWidth of 850. toneFreq = toneFreq + 100 FREQOUT 4, 100, toneFreq ' Play tone as indicator. ENDIF ELSEIF (IN7 = 0) THEN ' Right whisker makes circle IF (pulseWidth >= 655) THEN ' larger, down to servo min pulseWidth = pulseWidth - 5 ' pulseWidth of 650. toneFreq = toneFreq - 100 FREQOUT 4, 100, toneFreq ' Play tone as indicator. ENDIF ENDIF LOOP

Navegação Sensível à Luz com Fototransistores · Página 217

Capítulo 6: Navegação Sensível À Luz Com Fototransistores

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.

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.


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.

Figura 6-1 Esquema do Fototransistor Símbolos e parte do desenho

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.

C

B

E

Light

C

B

E

Current

Collector

Base

Emitter

Flat spot and shorter pin indicate the emitter (E) terminal


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

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

Violet Red

Yellow

Blue

Ultraviolet

450

495

570

590

620

750 Orang

Green

10…380

…100,00

Wavelength (nm) Color

Infrared

Para uma melhor visualização, faça o download de um PDF full-color do livro de www.parallax.com / go / Boe-Bot.


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)

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.

Desligue a alimentação de sua placa e servos. 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.

Figura 6-3: Fototransistors vs.

IR LEDs

Flatter on top

More Rounded Dome

Phototransistor

Infrared LED

USE THIS ONE!


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

Luz brilhante

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

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

To P6


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

VAA

A

kmARIVP

5.35.3

275.1

20001000

75.1275.1

6

=Ω=

Ω×=

Ω×=

Ω×=×=

VAA

A

kmARIVP

5.05.0

225.0

20001000

25.0225.0

6

=Ω=

Ω×=

Ω×=

Ω×=×=


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 OS NÍVEIS DE LUZ COM FOTOTRANSISTORES 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.

Figura 6-8 Distinguindo fototransistores de LEDs infravermelhos; Identificando o capacitor 0.1 μF

Liso no topo

Dome mais arredondada

Phototransistor Infrared LED

Capacitor 0.1 μF Símbolo esquemático e

desenho da peça


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. Desligue a alimentação de sua placa e servos. 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

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.

Flat Spots, pins menores

Flat Spots, pins menores


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 tornar-se 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 ' 1 Começa a carregar PAUSE 1 ' 2 Espera o capacitor ser carregado RCTIME 6, 1, tLeft ' 3 Mede o tempo de decaimento DEBUG HOME, "tLeft = ", DEC5 tLeft ' Exibe resultados PAUSE 100 ' Espera 0.1 segundo LOOP ' 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

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

tLeft

tRight

≈ 5 V

1.4 V

0 V

≈ 5 V

1.4 V

0 V

HIGH 6

PAUSE 1

RCTIME 6, 1, tLeft

PAUSE 1 RCTIME 3, 1, tRight HIGH 3


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 ' 5 V × 128 ÷ 256 = 2.5 V. PWM 6, 96, 1 ' 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 não poderiam ser bons para a medida de voltagem de queda de tempo.

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 VAR Word ' Armazena o tempo de decaimento do sensor esquerdo tRight VAR Word ' Armazena o tempo de decaimento do sensor direito PAUSE 1000 ' Espera de 1 s antes do DEBUG DO ' Loop principal


PWM 6, 184, 1 ' Carrega capacitor com 3.59 V RCTIME 6, 1,tLeft ' Mede o tempo de decaimento PWM 3, 184, 1 ' Carrega capacitor com 3.59 V RCTIME 3, 1,tRight ' Mede o tempo de decaimento DEBUG HOME, "tLeft = ", DEC5 tLeft, CR, ' Mostra os resultados "tRight = ", DEC5 tRight PAUSE 100 ' Espera 0.1 segundos LOOP ' Repete o loop principal

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 VAR Word ' Primeiro tempo de decaimento do sensor direito tRight2 VAR Word ' Segundo tempo de decaimento do sensor direito PAUSE 1000 ' Espera 1 s antes de um DEBUG DO ' Loop principal HIGH 3 ' 1 P3 HIGH para começar a carregar PAUSE 1 ' 2 Espera o capacitor carregar RCTIME 3, 1, tRight1 ' 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, ' Exibe resultados CR, "tRight2 = ", DEC5 tRight2 PAUSE 100 ' Espera 0.1 segundo LOOP ' Repete o loop principal 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 ≈ 5 V

≈ 2.5 V 1.4 V

0 V


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 ' $STAMP BS2 ' $PBASIC 2.5 tLeft VAR Word tRight VAR Word PPAUSE 1000 DDEBUG "Programa funcionando... " DDO HIGH 6 PAUSE 1 RCTIME 6, 1,tLeft HIGH 3 PAUSE 1 RCTIME 3, 1,tRight PULSOUT 13, 850 PULSOUT 12, 650 LOOP

' TestMaxDarkWithPwm.bs2 ' $STAMP BS2 ' $PBASIC 2.5 tLeft VAR Word tRight VAR Word PAUSE 1000 DEBUG "Programa funcionando... " DO PWM 6, 80, 1 RCTIME 6, 1,tLeft PWM 3, 80, 1 RCTIME 3, 1,tRight PULSOUT 13, 850 PULSOUT 12, 650 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

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

Diante de uma Fonte de Luz Sombra sobre sensor de luz a esquerda do Boe-Bot


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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. '-----[ Constantes/Variáveis ]----------------------------------------------- Negative CON 1 ' Para números negativos ' Application Variables light VAR Word ' Indicador de brilho/escuridão ndShade VAR Word ' Sombra diferencial normalizada ' Sub-Rotina Variables tLeft VAR Word ' Armazena as medidas da esquerda de RCTIME tRight VAR Word ' Armazena as medidas da direita de RCTIME n VAR Word ' Numerador d VAR Word ' Denominador q VAR Word ' Quociente sumDiff VAR Word ' Para soma e diferenca de cálculos duty VAR Byte ' PWM duty argument da variável i VAR Nib ' Variável de contagem Index temp VAR Nib ' Armazenamento temporário para cálculo sign VAR Bit ' Var.BIT15 = 1 if neg, 0 if pos '-----[ Inicializacão ]------------------------------------------------------ FREQOUT 4, 2000, 3000 ' Começa bip DEBUG CLS ' Limpa o DEBUG Terminal '-----[ Rotina Principal ]--------------------------------------------------- DO ' Loop principal GOSUB Light_Shade_Info ' Obtém light & ndShade


DEBUG HOME, "light = ", DEC3 light, ' Exibe light & ndShade "/324", CLREOL, CR, "ndShade = ", SDEC3 ndShade, CLREOL PAUSE 100 ' Atrasa 0.1 seconds LOOP ' Repete o loop principal '-----[ 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: ' Sub-rotina de etiqueta GOSUB Light_Sensors ' Obtem material RC light medidas sumdiff = (tLeft + tRight) MAX 65535 ' começar o level de luz com soma IF duty <= 70 THEN ' Se duty com o min light=duty-(sumdiff/905) MIN 1 ' Achar o quanto escuro está IF sumdiff = 0 THEN light = 0 ' se o tempo de espera, max escuridão ELSEIF duty = 255 THEN ' Se duty acom o max light=duty+((1800-(sumdiff))/26) ' ache o quanto mais brilhante ELSE ' Se duty na faixa light = duty ' light = duty ENDIF ' Feito o lvel de luz GOSUB Duty_Auto_Adjust ' Ajuste PWM duty para o proximo loop n = tLeft ' Estabelecer tLeft/(tLeft+tRight) d = tLeft + tRight GOSUB Fraction_Thousandths ' Divide (retorna milésimos) ndShade = 500-q ' Normalizar o differencial de sombra RETURN ' 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: ' Subrotina de etiqueta PWM 6, duty, 1 ' Carga cap em P6 circuito RCTIME 6, 1, tLeft ' Meça decadência P6 PWM 3, duty, 1 ' meça cap em P3 circuito RCTIME 3, 1, tRight ' Medir a queda RETURN ' 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.

A 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 sensibilidade, que por sua vez controla quanto tempo os comandos demoraram para chegar nas suas medições de luz. O programa tem uma sub-rotina 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. Depois de 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.


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:

+

×−=tRighttLeft

tLeftndShade 1000500

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

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

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.


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, " -+---------+---------+-", ' Nível de sombra visualização gráfica CR, " -500 500" '-----[ Rotina principal ]--------------------------------------------------- DO ' Loop principal GOSUB Light_Shade_Info ' Obter light & ndShade ' Exibir DEBUG HOME, CRSRX, 8, "light = ", ' Nome da variável light em x=8 DEC3 light, "/324",CR, CR, ' Valor da variável de 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 de ndShade 6+((ndShade+500)/50), "*" ' x-posição PAUSE 100 ' Espera 0.1 segundo LOOP ' Repete o loop principal

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


Igual luz - velocidade máxima para a frente.

Sombra escura sobre a direita - roda inversa velocidade máxima esquerda.

Igual sombra - de volta até a velocidade máxima para a frente.

Indicador de velocidade

do lado esquerdo

Indicador de velocida a direita

Roda direita parado

Esquerda roda inversa velocidade máxima

Escura sombra a esquerda - desacelerar roda direita

Figura 6-19: Exemplos de Sombra e indicador de roda


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 ' Duração do pulso do servo esquerdo pulseRight VAR Word ' 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 GOSUB Light_Shade_Info ' Obtém light & ndShade ' 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 IF (ndShade + 500) > 500 THEN ' Se há mais sombra à direita... pulseLeft = 900 - ndShade MIN 650 MAX 850 ' Diminui roda esq com sombra dir pulseRight = 650 ' Roda direita velocidade máxima ' para a frente ELSE ' Se há mais sombra à esquerda... pulseLeft = 850 ' Esquerda roda a toda velocidade ' para a frente pulseRight= 600 - ndShade MIN 650 MAX 850 ' Diminui roda dir com sombra esq ENDIF DEBUG CRSRXY, 1, 10, DEC3 pulseLeft, ' Exibir os valores das variáveis ' de pulso CRSRX, 29, DEC3 pulseRight ' 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),"<" ' e indica direção LOOP ' Repete o loop principal

' ... 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 ' Application Variables pulseLeft VAR Word pulseRight VAR Word light VAR Word ndShade VAR Word ' 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

' Application Variables pulseLeft VAR Word pulseRight VAR Word light VAR Word ndShade VAR Word ' Sub-Rotina Variables 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 GOSUB Light_Shade_Info ' Obtém light & ndShade ' Rotina de Navegação IF (ndShade + 500) > 500 THEN ' 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 pulseRight= 600 - ndShade MIN 650 MAX 850

' devagar roda direita w/ sombra a esquerda ENDIF PULSOUT 13, pulseLeft ' Controle de pulso do servo a esquerda PULSOUT 12, pulseRight ' controle de pulso de servo a direita LOOP ' 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:

pulseLeft = 900 - ndShade MIN 650 MAX 850

...e: pulseRight= 600 - ndShade MIN 650 MAX 850

Por exemplo, você pode aumentar a sensibilidade da luz/sombra do Boe-Bot, 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 GOSUB Light_Shade_Info IF light > 320 THEN FREQOUT 4, 500, 3000 PAUSE 500 FREQOUT 4, 500, 3500 PAUSE 500 END ENDIF


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 PULSOUT 13, pulseLeft PULSOUT 12, pulseRight 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

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

Infrared LED

Receptor infravermelho Receptor

infravermelho

Infrared LED


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

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

IR Receptor

LED IV

IR on/off at ≈38 kHz para certos períodos de tempo


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

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.

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.


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.


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.

Figura 7-6 Tirando o LED IV no escudo de montagem

+-

IR LED will snap in.

Mais liso na ponta

Mais aredondado na ponta

Phototransistor Infrared LED

USE ESTE


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. Desligue a alimentação de sua placa e servos. 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

Figura 7-7 Esquerda e Direita Detectores Objeto IV

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.

Vdd

Vss

P9

P8

IR LED

Vss

1 k Ω

220

Ω

Vdd

Vss

P0

P2

IR LED

Vss

1 k Ω

220 Ω


Figura 7-8: Diagramas de fiação para emissor infravermelho e circuitos do receptor

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

P15P14P13P12P11P10

P7P6P5

P3

P1

P9P8

P4

P2

P0X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P9P8

P4

P2

P0

P10

P7P6P5

P3

P1

X2

X3Vdd VssVin


To Servos

+

HomeWork Board

Leva anódio

Leva anódio

esquerdo

direito

direito

esquerdo


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 VAR Bit DO


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


Figura 7-9 LEDs indicadores de Esquerda e Direita

Figura 7-10: Diagramas de fiação para emissor infravermelho e circuitos do receptor

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

P10

Vss

220 Ω

RedLED

P1

Vss

220 Ω

RedLED

P15 P14 P11 P13 P12 P10 P9 P8

P4 P2 P1 P0

P7 P6 P5 P3

X2

X3 Vdd Vss Vin

Rev B (916) 624-8333 www.parallax.com www.stampsinclass.com

To Servos

+

HomeWork Board

anode lead

anode lead

P15 P14 P13 P12 P11 P10 P9 P8

P4 P2 P1 P0

P7 P6 P5 P3

X2

X3 Vdd Vss Vin

Board of Education © 2000-2003 Rev C

Vdd

Black Red X4 X5

15 14 13 12

To Servos

+

anode lead

anode lead


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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. ' -----[ Variáveis ]--------------------------------------------------------- irDetectLeft VAR Bit irDetectRight VAR 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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. counter VAR Nib DEBUG "IV interference not detected, yet...", CR


DO IF (IN0 = 0) OR (IN9 = 0) THEN DEBUG "IV Interference detected!!!", CR FOR counter = 1 TO 5 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 DEBUG "Programa funcionando!" 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 Bit irDetectRight VAR 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. DEBUG "Programa funcionando!" ' -----[ Variavéis ]--------------------------------------------------------- irDetectLeft VAR Bit irDetectRight VAR Bit pulseCount VAR Byte ' -----[ Inicialização ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Sinal do programa start/reset. ' -----[ rotina principal ]-------------------------------------------------- DO FREQOUT 8, 1, 38500 ' Store IV detector de valores em irDetectLeft = IN9 ' bit variaveis. FREQOUT 2, 1, 38500 irDetectRight = IN0 IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN GOSUB Back_Up ' ambos detectam obstáculo GOSUB Turn_Left ' Back up & U-turn (esquerda duas vezes) GOSUB Turn_Left ELSEIF (irDetectLeft = 0) THEN ' detector a esquerda GOSUB Back_Up ' Back up & turn direita GOSUB Turn_Right ELSEIF (irDetectRight = 0) THEN ' 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: ' Enviar um único pulso para a frente. PULSOUT 13,850 PULSOUT 12,650


PAUSE 20 RETURN Turn_Left: ' Vire à esquerda, a cerca de 90 graus. FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Vire à direita, cerca de 90 graus. PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN Back_Up: ' Volte a fazer FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

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 DEBUG "Programa funcionando!" irDetectLeft VAR Bit ' Declarações de variáveis irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. DO ' Rotina principal FREQOUT 8, 1, 38500 ' Checar o IV Detectores irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' Decida como navegar IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 650


ELSE pulseLeft = 850 pulseRight = 650 ENDIF PULSOUT 13,pulseLeft ' Aplicar o pulso PULSOUT 12,pulseRight PAUSE 15 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 VAR Bit irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR 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.

IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN 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.

PULSOUT 13,pulseLeft ' Aplicar o pulso. PULSOUT 12,pulseRight PAUSE 15

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.

Figura 7-11 Detectores de objetos IV dirigido para baixo para verificar se há uma queda

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)

P15 P14 P13 P12 P11 P10 P9 P8

P4 P2 P1 P0

P7 P6 P5 P3

X2

X3 Vdd Vss Vin

Board of Education © 2000-2003 Rev C

Vdd

Black Red X4 X5

15 14 13 12 To Servos

+


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-preto-vermelho) 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Ω (amarelo-

vermelho-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-violeta-marrom) ou até 220 Ω (vermelho-vermelho-marrom) resistores em série com os LEDs IV em vez de 2 kΩ.

Figura 7-12 Fita de contorno elétrico simulando a ponta da mesa

22” (56 cm)

22” (

56 c

m)


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 VAR Bit ' Declaração de variáveis. irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word loopCount VAR Byte pulseCount VAR Byte FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset.


DO ' Rotina principal. FREQOUT 8, 1, 38500 ' Checar o IV detectores. irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' 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 ELSEIF (irDetectRight = 1) THEN ' 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 ' Enviar pulseCount pulsos PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 20 NEXT 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.

ELSEIF (irDetectRight = 1) THEN 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 PULSOUT 13,pulseLeft PULSOUT 12,pulseRight 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 VAR Bit ' declarações de variáveis irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word ' -----[ Inicialização ]---------------------------------------------- DEBUG "Program Running!" FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. ' -----[ 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 ELSEIF (irDetectLeft = 0) THEN ' detetar esquerda pulseLeft = 850 ' voltar a direita pulseRight = 850 ELSEIF (irDetectRight = 0) THEN ' deletar a direita pulseLeft = 650 ' voltar a esquerda pulseRight = 650 ELSE ' nada deletado pulseLeft = 850 ' ir para frente pulseRight = 650 ENDIF PULSOUT 13, pulseLeft ' Aplicar o pulso PULSOUT 12, pulseRight PAUSE 15 GOSUB Check_IRs ' Cheque IVs novamente LOOP ' -----[ Sub-Rotinas ] ------------------------------------------------ Check_IRs: FREQOUT 8, 1, 38500 ' Cheque IV Detectores irDetectLeft = IN9 FREQOUT 2, 1, 38500 IrDetectRight = IN0 RETURN

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 VAR Bit ' esquerda IV lendo irDetectRight VAR Bit ' direita IV lendo pulseLeft VAR Word ' valores de pulsos para servos pulseRight VAR Word ' -----[ 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 IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 850 ' para frente pulseRight = 650 ' Object on left - go left ELSEIF (irDetectLeft = 0) THEN pulseLeft = 650 ' a esquerda em direção ao objeto pulseRight = 650 ' Object on right - go right ELSEIF (irDetectRight = 0) THEN 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 PULSOUT 13,pulseLeft ' Aplicar os pulsos PULSOUT 12,pulseRight


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 ' Cheque IV Detectores irDetectLeft = IN9 FREQOUT 2, 1, 38500 IrDetectRight = IN0 RETURN

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 VAR Bit ' esquerda IV sensorlendo irDetectRight VAR Bit ' direita IV sensor lendo pulseLeft VAR Word ' Pulsos mandados para os servos pulseRight VAR Word counter VAR Nib ' contador de loop ' -----[ Inicialização ]---------------------------------------------- DEBUG "Program Running!" FREQOUT 4, 2000, 3000 ' Sinal de programa start/reset. ' -----[ Rotina principal ]--------------------------------------------- Main: DO GOSUB Roam GOSUB Sniff LOOP ' -----[ Subrotinas ] ------------------------------------------------ Sniff: ' de IrInterferenceSniffer.bs2 IF (IN0 = 0) OR (IN9 = 0) THEN


FOR counter = 1 TO 5 'Bip 5 vezes HIGH 1 ' e flashs LEDs HIGH 10 FREQOUT 4, 50, 4000 LOW 1 LOW 10 PAUSE 20 NEXT ENDIF RETURN Roam: ' de FastIrRoaming.bs2 FREQOUT 8, 1, 38500 ' Cheque IV Detectores irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' Decida como navegar. IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 650 ELSE pulseLeft = 850 pulseRight = 650 ENDIF PULSOUT 13,pulseLeft ' Aplicar o pulso. PULSOUT 12,pulseRight PAUSE 15 RETURN

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, pode-se 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

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.

P15P14P13P12P11P10P9

P5

P3

P8P7

P2P1P0

P6

P4

X2

X3Vdd VssVin

Boar d of Education © 20 00 -2 00 3

Vd d

BlackRed

X4 X5

15 14 13 12

+

ObjectObject

Zone 5No Detectionat any Frequency

Zone 437500 Hz

Zone 338250 Hz

Zone 239500 Hz

Zone 140500 Hz

Zone 041500 Hz


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 Exemplos 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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva.


' -----[ Variáveis ]--------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetect VAR Bit distance VAR Nib ' -----[ Inicialização ]----------------------------------------------------- DEBUG CLS, " OBJECT", CR, "FREQUENCY DETECTED", CR, "--------- --------" ' -----[ Rotina principal ]-------------------------------------------------- DO distance = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1, 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:

FREQOUT 8,1, irFrequency


irDetect = IN9

... Para que eles leiam: FREQOUT 2,1, irFrequency 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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. ' -----[ Variável ]---------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetectLeft VAR Bit irDetectRight VAR Bit


distanceLeft VAR Nib distanceRight VAR 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 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency 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.

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

System

Error = -2Kp X error

35 X -2

Center pulse width750

Output adjust

-70

Right servooutput

680

Measured rightdistance = 4

-++

+


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 = definir o ponto de distância da direita – medir distância direita = 2 – 4

Ajustar a saída = error × Kp = –2 × 35 = – 70 Ajustar servo direito = 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.

Figura 8-5 Diagrama de blocos de controle proporcional para o Servo Esquerdo, LED IV e Detector de Objeto

Programação do Veículo Sombra Boe-Bot Lembre-se que a equação para a saída do servo direito foi:

System

Error = -2Kp X error

-35 X -2

Center pulse width750

Output adjust

+70

Left servooutput

820

Measured leftdistance = 4

-++

+


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 CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 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 Boe-

Bot 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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. DEBUG "Programa funcionando!" ' -----[ Constantes ]-------------------------------------------------------- Kpl CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 750 ' -----[ Variáveis ]--------------------------------------------------------- freqSelect 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. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse LOOP ' -----[ Subrotina - Get IV Distances ]-------------------------------------- Get_Ir_Distances: distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN ' -----[ Subrotina – Get Pulse ]--------------------------------------------- Send_Pulse: PULSOUT 13,pulseLeft PULSOUT 12,pulseRight 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 CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 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 GOSUB Get_Ir_Distances

As próximas duas linhas de código implementam os cálculos de controle proporcionais a cada servo. 'Calcular saída proporcional pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse

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


Figura 8-7 Trajeto Siga à faixa

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:

28” (71 cm)

22” (

56 c

m)

www.stampsinc lass .c om

R eset

S TAM PS C LAS Sin

Board of Educ ation

Pw r

9 VdcBattery

6- 9VD C

S outS inAT NV ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2 000 -2 003

V dd


X2

X3Vdd VssVin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin

R ev C

+


Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATN

VssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2000-2003

Vdd


X2

X3VddVss Vin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3VddVss Vin

Rev C

+

Start

Finish


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.

Figura 8-8 Detector IR de objeto direcionado para baixo e para fora a fim de detectar a faixa

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.

Vdd VssVin


X4 X5

+


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.

www.stamps inc lass .c om

R eset

STA M PS C LASSi n

Board of Educ ation

Pw r

9 VdcBattery

6- 9VD C

S outS inAT N

V ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2 000 -2 003

V dd


X2

X3Vdd VssVin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin

R ev C

+


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


R eset

STA M PS C LASSi n

Board of Educ ation

Pw r

9 VdcBattery

6- 9VD C

S outS inAT N

V ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2 000 -2 003

V dd


X2

X3Vdd VssVin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin

R ev C

+

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Ω (marrom-preto-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

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.

Vdd VssVin


X4 X5

+


R eset

S TAM PS C LAS Sin

Board of Educ ation

Pw r

9 VdcBattery

6- 9VD C


P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2 000 -2 003

V dd


X2

X3Vdd VssVin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin

R ev C

+


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.


Figura 8-13 Percurso Seguir na Tira.

' -----[ 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. DEBUG "Programa funcionando!" ' -----[ Constantes ]-------------------------------------------------------- Kpl CON 35 ' Mude de -35 para 35 Kpr CON -35 ' Mude de 35 para -35 SetPoint CON 3 ' Mude de 2 para 3. CenterPulse CON 750 ' -----[ Variáveis ]--------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetectLeft VAR Bit irDetectRight VAR Bit distanceLeft VAR Nib distanceRight VAR Nib pulseLeft VAR Word pulseRight VAR Word

28” (71 cm)

22” (

56 c

m)

www.stampsinc lass .c om

R eset

S TAM PS C LAS Sin

Board of Educ ation

Pw r

9 VdcBattery

6- 9VD C


P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2 000 -2 003

V dd


X2

X3Vdd VssVin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin

R ev C

+


Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATN

VssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2000-2003

Vdd


X2

X3VddVss Vin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3VddVss Vin

Rev C

+

Start

Finish


' -----[ Inicialização ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ rotina principal ]-------------------------------------------------- DO GOSUB Get_Ir_Distances ' Calculate proportional output. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse LOOP ' -----[ Sub-Rotina - Obter Distancia IV]------------------------------------ Get_Ir_Distances: distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN ' -----[ Subrotina - obter Pulso ]------------------------------------------- Send_Pulse: PULSOUT 13,pulseLeft PULSOUT 12,pulseRight 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 ecomunicaçã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 re-amostragem 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 index = 1, prime = 3 index = 2, prime = 5 index = 7, prime = 19

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. READ Dots + index, noteDot i. IF noteDot = 1 THEN j. noteDuration = noteDuration * 3 / 2 k. DEBUG "Dotted Note!", CR l. 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 ' Stamp diretiva. ' $PBASIC 2.5 ' PBASIC diretiva. DEBUG "Programa funcionando!" ' -----[ Constantes ]------------------------------------------------ Kpl CON 35 ' constante da esquerda proporcional Kpr CON -35 ' constante da direita proporcional SetPoint CON 3 ' 0-1 é branco, 4-5 é preto CenterPulse CON 750 Turn90Degree CON 30 ' Pulsos necessários para curva de 90˚ RightLED PIN 1 ' Indicadores LED LeftLED PIN 10 ' -----[ Variáveis ]------------------------------------------------- freqSelect VAR Nib ' varredura através de cinco frequências irFrequency VAR Word ' Freq. enviado ao emissor IV irDetectLeft VAR Bit ' armazenar resultados dos detectores irDetectRight VAR Bit distanceLeft VAR Nib ' Calcular as zonas de distância distanceRight VAR Nib pulseLeft VAR Word ' Largura de pulso dos servos pulseRight VAR Word numPulses VAR Byte ' Contar total de pulsos fwdPulses VAR Byte ' Contar os pulsos a frente counter VAR Byte isStuck VAR Bit ' Boolean variável, o Boe-Bot está preso? ' -----[ Inicialização ]--------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Rotina principal ]------------------------------------------ DO GOSUB Get_Ir_Distances ' leitura sensores IV GOSUB Update_LEDs ' Indicando linha branco/preto ' Calcular a saida proporcional e mover de acordo pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse GOSUB Check_For_Intersection ' estamos presos no cruzamento?


IF (isStuck = 1) THEN GOSUB Make_Noise ' indicador sonoro GOSUB Navigate_Intersection ' Navegando através ENDIF 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 Get_Ir_Distances 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 Get_Ir_Distances 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 ' Inicializar a variável Boolean numPulses = numPulses + 1 ' 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 ' Se enviarmos 60 pulsos IF (fwdPulses < 30) THEN ' Quantos foram para frente? isStuck = 1 ' Se < 30, robo esta preso ENDIF CASE > 60 numPulses = 0 ' resetar o contador e voltar a 0 fwdPulses = 0 ' (pode apagar =60 no caso mas ENDSELECT ' Make_Noise) RETURN 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 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN Send_Pulse: ' Enviar um único pulso para os servos entre as leituras IV . PULSOUT 13,pulseLeft PULSOUT 12,pulseRight 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ô Boe-Bot 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) 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 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 Peças e quantidades estão sujeitas a alterações sem aviso prévio

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 Peças e quantidades estão sujeitas a alterações sem aviso prévio

Parallax Banco de código

Descrição Quantidade

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


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 Cor 0 Preto 1 Marrom 2 Vermelho 3 Laranja 4 Amarelo 5 Verde 6 Azul 7 Violeta 8 Cinza 9 Branco

Figura B-1 Resistor cor e códigos

• Primeira faixa é amarela, e significa que o dígito mais à esquerda é 4. • Segundo faixa é violeta, significa que o próximo dígito é 7.

First Digit

Second Digit

Number of Zeros

Tolerance Code


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


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.


X2

X3Vdd VssVin


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.

Figura B-3 Desenhos de peças e símbolos esquemáticos LED(esquerda) e resistor 470 Ω (direita)

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.

470 Ω

YellowViolet

Brown

GoldSilverorBlank

+

LED


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.


X2

X3Vdd VssVin

Vdd

Vss

LED

470 Ω

+


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.

P14

Vss

LED470 Ω

P15

P13P12P11P10P9P8P7P6P5P4P3P2P1P0

P14

X2

X3Vdd VssVin

+


Figura B-6 Desenhos das peças e símbolos esquemáticos Fototransistor (topo) Capacitor não polar (parte inferior)

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.

0.1 μF Capacitor Schematic Symbol and Part Drawing

C

B

E

Light

C

B

E

Current

Collector

Base

Emitter

Flat spot and shorter pin indicate the emitter (E) terminal


Figura B-7 Esquemática com o Resistor, Fototransistor e Capacitor

Figura B-8 Diagrama de ligações do Resistor, Fototransistor e Capacitor

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.

Local plano e pino mais curto


Figura B-9 Diagrama de ligações do Resistor, Fototransistor e Capacitor Observe a colocação alternativa dos componentes.

Control Horn

Local plano e pino mais curto

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.

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 - Parallax Inc

Documents

Transcript of Robótica com Boe-Bot - Parallax Inc