Tutorial Bricx para NXT, Notas de estudo de Cultura

Baixe Tutorial Bricx para NXT e outras Notas de estudo em PDF para Cultura, somente na Docsity!

Programando Robôs

NXT

Usando NXC

(Beta 30 or higher) (Version 2.2, June 7, 2007)

Por Daniele Benedettelli

Com Revisões de John Hansen

Prefácio

Tal como aconteceu para o bom e velho Mindstorms RIS, CyberMaster, e Spybotics, para libertar todo o potencial das Mindstorms NXT tijolo, você precisa de um ambiente de programação que é mais útil do que NXT-G, o Nacional Instrumentos LabView-como linguagem gráfica que vem com NXT retalho set. NXC é uma linguagem de programação, inventado por John Hansen, que foi especialmente concebido para a Lego robôs. Se você nunca escreveu um programa antes, não se preocupe. NXC é realmente fácil de usar e este tutorial vai levá-lo em seus primeiros passos nesse sentido. Para tornar ainda mais fácil escrever programas, existe a Bricx Command Center (BricxCC). Este utilitário permite que você escreva seus programas, para transferi-los para o robô, para iniciar e detê-los, procure NXT memória flash, converter arquivos sonoros para uso com o tijolo, e muito mais. BricxCC funciona quase como um processador de texto, mas com algumas extras. Este tutorial usará BricxCC (versão 3.3.7.16 ou superior), como ambiente de desenvolvimento integrado (IDE). Você pode baixá-lo gratuitamente a partir da web, no endereço http://bricxcc.sourceforge.net/ BricxCC é executado no PC Windows (95, 98, ME, NT, 2K, XP, Vista). NXC A língua também pode ser usado em outras plataformas. Você pode baixá-lo da página web http://bricxcc.sourceforge.net/nxc/ A maior parte deste tutorial deve ser igualmente aplicável a outras plataformas, exceto que você solta algumas das ferramentas incluídas no BricxCC e a cor-codificação. O tutorial foi atualizado para trabalhar com beta 30 de NXC e versões superiores. Alguns programas da amostra não irão compilar com versões mais antigas do que beta 30. Como nota lateral, minha página está cheia de RCX Lego Mindstorms NXT e conteúdo relacionado, incluindo uma ferramenta para PC comunicar com NXT: http://daniele.benedettelli.com

Agradecimentos

Muitos agradecimentos vão para John Hansen, cujo trabalho não tem preço!

• Prefácio
  • Agradecimentos
• Sumário
• 1. Gravando o seu primeiro programa
  • Construir um robô
  • Começando Bricx Command Center
  • Escrever o programa.......................................................................................................................
  • Executando o programa
  • Erros em seu programa...................................................................................................................
  • Mudar a velocidade
  • Resumo...........................................................................................................................................
• 2. Um programa mais interessante
  • Tornar voltas
  • Repetindo comandos
  • Adicionando comentários.............................................................................................................
  • Resumo
• 3. Usando variáveis
  • Passando em uma espiral..............................................................................................................
  • Números aleatórios
  • Resumo.........................................................................................................................................
• 4. Controle estruturas
  • A declaração IF
  • A declaração do
  • Resumo
• 5. Sensores
  • Esperando por um sensor
  • Agindo sobre um sensor de Toque
  • Sensor de Luz
  • Sensor de Som
  • Sensor de Ultra-som
  • Resumo
• 6. Tarefas e Sub-Rotinas
  • Tarefas
  • Sub-Rotinas
  • Definindo macros
  • Resumo
• 7. Fazendo música
  • Reproduzir arquivos sonoros
  • Reproduzir música
  • Resumo
• 8. Mais informações sobre os motores
  • Parando suavemente
  • Comandos avançados
  • Controle PID
  • Resumo
• 9. Mais informações sobre os sensores
  • Sensor modalidade e tipo
  • A rotação sensor
  • Colocar vários sensores em uma entrada
  • Resumo
• 10. Tarefas Paralelas
  • Um programa errado
  • Secções críticas e variáveis mutex
  • Usando Semáforos
  • Resumo
• 11. A comunicação entre robôs
  • Mestre - Escravo mensagens
  • Enviando números com aviso
  • Diretório de comandos
  • Resumo
• 12. Mais comandos
  • Temporizadores
  • Matricial visor
  • Sistema Arquivo
  • Resumo
• 13. Observações finais

1. Gravando o seu primeiro programa

Neste capítulo vou mostrar-lhe como escrever um programa extremamente simples. Estamos indo para programar um robô para avançar para 4 segundos, depois de recuar mais 4 segundos, e então parar. Não muito espetacular, mas irá apresentar-lhe a idéia de base da programação. E ele vai te mostrar como isso é fácil. Mas antes que nós possamos escrever um programa, primeiro precisamos um robô.

Construir um robô

O robô, utilizado ao longo deste tutorial é Tribot, o primeiro veículo que tenha sido instruído a construir quando tem NXT estabelecidos fora da caixa. A única diferença é que você deve se conectar a porta um motor direita, esquerda automóvel à porta C e do motor para a porta B.

Certifique-se de ter instalado corretamente Mindstorms NXT Fantom Drivers que vem com o seu conjunto.

Começando Bricx Command Center

Nós escrevemos nossos programas usando Bricx Command Center. Iniciá-lo clicando duas vezes sobre o ícone BricxCC. (Eu assumo você já instalou BricxCC. Se não, fazer o download a partir do web site (veja o prefácio), e instalá-lo em qualquer diretório que você gosta. O programa irá pedir a localização do robot. Mudar o robô, e pressione OK. O programa (o mais provável) encontrar automaticamente o robô. Agora a interface do usuário aparece como mostrado abaixo (sem o texto guia).

{ statement1; statement2; … } Nosso programa tem seis declarações. Olhemos para um deles no momento: OnFwd(OUT_A, 75); Esta declaração diz o robô para iniciar uma produção, ou seja, o motor ligado à saída marcada Ano NXT, para avançar. O número seguinte apresenta a velocidade do motor a 75% da velocidade máxima. OnFwd(OUT_C, 75); Mesma declaração, mas agora começamos a motor C. Após estas duas declarações, ambos os motores estão funcionando, e os robôs se move em frente. Wait(4000); Agora é tempo para esperar por um tempo. Esta afirmação diz-nos a esperar por 4 segundos.O argumento, isto é, o número entre parênteses, indica o número de 1 / 1000 de um segundo: assim que você pode dizer muito claramente ao programa como tempo para esperar. Para a 4 segundos, o programa está dormindo e o robô continua a avançar. OnRev(OUT_AC, 75); O robô tem agora longe suficiente para dizer que para avançar na direção inversa, ou seja, para trás. Note que nós pode definir ambos os motores de uma vez OUT_AC usando como argumento. Nós também podíamos ter combinado das duas primeiras declarações desta forma. Wait(4000); Novamente vamos esperar por 4 segundos. Off(OUT_AC); E finalmente nós dois motores switch off. Esse é todo o programa. Move-se ambos os motores em frente por 4 segundos, em seguida, para trás, para 4 segundos, e finalmente mudá-las. Você, provavelmente já notou as cores quando a digitação no programa. Eles aparecem automaticamente. As cores e estilos utilizado pelo editor quando se realiza sintaxe highlighting são personalizáveis.

Executando o programa

Depois de ter escrito um programa, ele precisa ser compilado (ou seja,

transformada em código binário que o robô pode compreender e executar) e enviado para o robô usando o cabo USB ou BT dongle (chamados de "descarregar" os

programas).

Aqui você pode ver o botão que lhe permite (da esquerda para a direita) compilar, faça o download, executar e parar o programa. Pressione o botão e segundo, assumindo que você fez que não há erros na digitação quando o programa, ele será correctamente compilados e baixadas. (Se houver erros em seu programa, você será notificado, ver abaixo.) Agora você pode executar o seu programa. Para isso, vá ao menu Meus Ficheiros OnBrick, Software arquivos, e execute 1_simple programa. Lembre-se: software NXT arquivos em arquivos têm o mesmo nome como fonte NXC arquivo. Além disso, para obter o programa ser executado automaticamente, pode utilizar o atalho CTRL + F5 ou depois de fazer o download do programa que você pode pressionar o botão verde correr. Será que o robot fazer o que você esperava? Se não, verifique fio conexões.

Erros em seu programa

Ao digitar nos programas, há uma hipótese razoável que você faça alguns erros. Os avisos do compilador erros e relatá-los a você, na parte inferior da janela, como na figura a seguir:

Ela seleciona automaticamente o primeiro erro (nós digitado incorretamente o nome do motor). Quando há mais erros, você pode clique sobre as mensagens de erro de ir para elas. Note que muitas vezes erros no início do programa causar outros erros em outros lugares. Então, melhor apenas corrigir alguns erros do primeiro e, em seguida, compile o programa novamente. Observe também que a sintaxe de ajuda imenso a evitar erros. Por exemplo, na última linha digitada of nós, em vez de Off. Porque este é um comando esconhecido, não é destacada. Existem também erros que não são encontrados pelo compilador. Se tivéssemos digitado OUT_B isto causar o mal motor a girar. Se o seu robô exibe um comportamento inesperado, o mais provável é algo de errado em seu programa.

Mudar a velocidade

Como você notou, o robô movido bastante rápido. Para alterar a velocidade que você só mudar o segundo parâmetro no interior parênteses. O poder é um número entre 0 e 100. 100 é o mais rápido, 0 significa parar (servo motores irá NXT mantenha posição). Aqui está uma nova versão do nosso programa em que o robô se move lentamente: task main() { OnFwd(OUT_AC, 30); Wait(4000); OnRev(OUT_AC, 30); Wait(4000); Off(OUT_AC); }

Resumo

O nosso primeiro programa não foi tão incrível. Então, vamos tentar torná-la mais interessante. Faremos isso em uma série de passos, introduzindo alguns aspectos importantes da nossa linguagem de programação NXC.

Tornar voltas

Você pode fazer seu robô turno, parando ou invertendo a direção de um dos dois motores. Aqui está um exemplo. Digite a sua senha, fazer o download para o seu robô e deixar correr. Deve dirigir um pouco e então faça um grau 90-direita turno.

task main() { OnFwd(OUT_AC, 75); Wait(800); OnRev(OUT_C, 75); Wait(360); Off(OUT_AC); }

Você pode ter que experimentar alguns ligeiramente diferentes números superiores a 500 na segunda Esperar () comando para fazer um 90 grau turno. Isso depende do tipo de superfície sobre a qual o robô executa. Ao invés de mudar isso no programa é mais fácil de usar um nome para este número. Em NXC você pode definir valores constantes conforme mostrado na programa seguinte.

#define MOVE_TIME 1000 #define TURN_TIME 360 task main() { OnFwd(OUT_AC, 75); Wait(MOVE_TIME); OnRev(OUT_C, 75); Wait(TURN_TIME); Off(OUT_AC); }

As duas primeiras linhas definem duas constantes. Estas podem agora ser utilizados em todo o programa. Definindo constantes é boa por dois motivos: ela torna o programa mais legível, e é mais fácil de alterar os valores. Note que BricxCC dá declarações a definir sua própria cor. Como veremos no capítulo VI, você pode também definir as coisas outros que não constantes.

Repetindo comandos

Vamos agora tentar escrever um programa que faz com que o robô em uma unidade quadrada. Indo em uma praça significa: condução em frente, virar 90 graus, condução em frente de novo, virar 90 graus, etc Podíamos repetir o referido pedaço de Código quatro vezes, mas isso pode ser feito muito mais fácil com a repeat declaração.

#define MOVE_TIME 500 #define TURN_TIME 500 task main() { repeat (4) { OnFwd(OUT_AC, 75); Wait(MOVE_TIME); OnRev(OUT_C, 75); Wait(TURN_TIME); } Off(OUT_AC); }

O número dentro da repetição da declaração parênteses indica quantas vezes o seu código dentro parênteses deve ser repetido. Note que, no programa acima, também as declarações travessão. Isso não é necessário, mas torna o programa mais legível. Como um último exemplo, vamos fazer o robô unidade 10 vezes em um quadrado. Aqui está o programa:

#define MOVE_TIME 1000 #define TURN_TIME 500 task main() { repeat (10) { repeat (4) { OnFwd(OUT_AC, 75); Wait(MOVE_TIME); OnRev(OUT_C, 75); Wait(TURN_TIME); } } Off(OUT_AC); }

Existe agora uma declaração repetir dentro da outra. Chamamos isso de "nested" repetir declaração. Você pode repetir ninho declarações o quanto quiser. Tome um cuidado olhar para os suportes e as indentação utilizada no programa. O tarefa começa no primeiro escalão e termina no último. A primeira repetição declaração começa no segundo escalão e termina na quinta. A repetição aninhada declaração começa no terceiro escalão, e termina na quarta. Como você vê os parênteses sempre vêm em pares, e a peça entre os parênteses que travessão.

Adicionando comentários

Para tornar o programa ainda mais legível, é bom para acrescentar alguns comentários a ele. Sempre que você colocar / / em um linha, o resto da linha é ignorado e pode ser usado para comentários. Um longo comentário pode ser colocada entre / * e * /. Comentários são destacadas na sintaxe BricxCC. A programação completa pode parecer como se segue:

/* 10 SQUARES This program make the robot run 10 squares */

Variáveis forma um aspecto muito importante de todas as linguagens de programação. As variáveis são locais na memória que pode armazenar um valor. Podemos utilizar esse valor em locais diferentes e podemos mudá-la. Vamos descrever a utilização de variáveis usando um exemplo.

Passando em uma espiral

Suponhamos que queremos adaptar o programa acima de forma a que o robot movimentações em uma espiral. Isto pode ser alcançado , tirando o sono do que tempo de maior circulação para cada lado direto. Isto é, queremos aumentar o valor de MOVE_TIME cada vez. Mas como podemos fazer isso? MOVE_TIME é uma constante e, portanto, não pode ser alterado. Nós necessitamos de uma variável vez. Variáveis podem ser facilmente definida no NXC. Aqui está a espiral programa.

#define TURN_TIME 360 int move_time; // define a variable task main() { move_time = 200; // set the initial value repeat (50) { OnFwd(OUT_AC, 75); Wait(move_time); // use the variable for sleeping OnRev(OUT_C, 75); Wait(TURN_TIME); move_time += 200; // increase the variable } Off(OUT_AC); }

O interessante linhas são indicados com os comentários. Em primeiro lugar, definir uma variável, digitando a palavra-chave int seguido por um nome que escolhemos. (Normalmente usamos minúscula letras para a variável nomes e letras maiúsculas para constantes, mas isso não é necessário). O nome deve iniciar com uma letra, mas pode conter os dígitos e sublinhado assinar. Não são permitidos outros símbolos. (O mesmo se aplicava aos constantes, tarefa nomes, etc) A palavra está para o int inteiro. Apenas números inteiros podem ser armazenados na mesma. Na segunda linha vamos atribuir o valor 200 para a variável. A partir deste momento em diante, sempre que você usar a variável, o seu valor será 200. Agora segue a repetir em loop que usamos a variável para indicar a hora de dormir e, no final do ciclo que aumentar o valor da variável por 200. Então, a primeira vez que o robô dorme 200 ms, 400 ms, o segundo tempo, o terceiro time 600 ms, e assim ligado. Além de acrescentar valor a uma variável que também pode multiplicar uma variável com um número usando *=, subtrair usando -= e dividir usando / =. (Note que, para a divisão do resultado é arredondado para o número inteiro mais próximo.) Você também pode adicionar uma variável para o outro, e anote mais complicado expressões. O próximo exemplo, não têm qualquer efeito em seu robô de hardware, uma vez que não sabemos como usar o visor NXT ainda!

int aaa; int bbb,ccc; int values[];

task main() { aaa = 10; bbb = 20 * 5; ccc = bbb; ccc /= aaa; ccc -= 5; aaa = 10 * (ccc + 3); // aaa is now equal to 80 ArrayInit(values, 0, 10); // allocate 10 elements = 0 values[0] = aaa; values[1] = bbb; values[2] = aaa*bbb; values[3] = ccc; }

Nota sobre as primeiras duas linhas que podemos definir múltiplas variáveis em uma linha. Nós também podíamos ter combinado tudo três deles em uma linha. A variável denominada valores é uma matriz, ou seja, uma variável que contém mais de um Número: um array pode ser indexada com um número dentro de colchetes. Em NXC inteiro matrizes são declaradas assim: int name[]; Então, esta linha aloca 10 elementos initializing eles a 0. ArrayInit(values, 0, 10);

Números aleatórios

Em todos os programas acima, definimos exatamente o que o robô era suposto fazer. Mas as coisas se tornam muito mais interessante quando o robô vai fazer coisas que não sabemos. Queremos que haja alguma aleatoriedade na moções. Em NXC você pode criar números aleatórios. O seguinte programa usa isso para deixar a unidade em torno de um robô forma aleatória. É constantemente unidades encaminha para um valor aleatório de tempo e, em seguida, faz uma aleatória turno.

int move_time, turn_time; task main() { while(true) { move_time = Random(600); turn_time = Random(400); OnFwd(OUT_AC, 75); Wait(move_time); OnRev(OUT_A, 75); Wait(turn_time); } }

O programa define duas variáveis e, em seguida, atribui-lhes números aleatórios. Random(600)significa um aleatória número entre 0 e 600 (o valor máximo não está incluído no intervalo de números devolvida). Cada vez Random chamar os números serão diferentes. Note que pudéssemos evitar o uso das variáveis por escrito directamente por exemplo, Wait(Random(600)). Você também verá um novo tipo de laço aqui. Em vez que a utilização da declaração repetir que escrevemos while (true). O tempo declaração reitera as declarações abaixo dela, enquanto a condição entre parênteses é a verdade. A especial palavra verdadeira é sempre verdadeira, então as declarações entre os parênteses são repetidas indefinidamente (ou, pelo menos até que você pressione o cinzento escuro botão NXT). Você vai aprender mais sobre a declaração enquanto no Capítulo IV.

Nos capítulos anteriores vimos a repetir, e enquanto declarações. Estas declarações controlar a forma como os outros declarações do programa são executados. Eles são chamados de "estruturas de controlo". Neste capítulo veremos alguns outras estruturas de controlo.

A declaração IF

Às vezes você deseja que uma determinada parte do seu programa só é executado em determinadas situações. Neste caso, o declaração, se for utilizado. Permitam-me dar um exemplo. Vamos mudar novamente o programa que temos vindo a trabalhar com tão longe, mas com um novo giro. Queremos que o robô de condução ao longo de uma linha recta e então fazer a esquerda ou à direita turno. Para isso precisamos de números aleatórios novamente. Nós escolher um número aleatório que é positivo ou negativo. Se o número é inferior a 0 fazemos uma curva à direita, caso fizermos uma esquerda turno. Aqui está o programa:

#define MOVE_TIME 500 #define TURN_TIME 360 task main() { while ( true ) { OnFwd(OUT_AC, 75); Wait(MOVE_TIME); if (Random() >= 0) { OnRev(OUT_C, 75); } else { OnRev(OUT_A, 75); } Wait(TURN_TIME); } }

A declaração se parece um pouco como o tempo declaração. Se a condição entre parênteses é a verdade a parte entre os parênteses é executado. Caso contrário, a parte entre os parênteses depois da palavra o resto é executado. Permitir nos olhar um pouco melhor a condição que nós usamos. Ele lê Random() >= 0. Isto significa que Random() deve ser maior que ou igual a 0 para tornar a condição verdadeira. Você pode comparar valores de formas diferentes. Aqui estão os mais importantes: == Igual a < Menor que <= Menor ou igual a

Maior que = Maior que ou igual a ! = Não igual a Você pode combinar condições usar &&, que significa "e", ou ||,, o que significa "ou". Aqui estão alguns exemplos de condições: true sempre verdade false nunca verdade ttt != 3 verdade quando ttt não é igual a 3 (ttt >= 5) && (ttt <= 10) verdade quando ttt oscila entre 5 e 10 (aaa == 10) || (bbb == 10) verdade se aaa ou bbb forem igual a 10

Note que a declaração se tem duas partes. A parte imediatamente após a condição, que é executado quando o condição é verdadeira, assim como a parte após a outra, que é executada quando a condição é falsa. A palavra-chave e outra a parte depois

que são opcionais. Assim, você pode omiti-los, se não há nada a fazer quando a condição é falsa.

A declaração do

Existe uma outra estrutura de controlo, a fazer declaração. Tem a seguinte forma:

do { statements; } while (condition);

As declarações entre os parênteses após a fazer parte são executadas enquanto a condição é verdadeira. A condição tem a mesma forma como no caso acima descrito declaração. Aqui está um exemplo de um programa. O robô é executado aleatoriamente em torno de 20 segundos e depois pára.

int move_time, turn_time, total_time; task main() { total_time = 0; do { move_time = Random(1000); turn_time = Random(1000); OnFwd(OUT_AC, 75); Wait(move_time); OnRev(OUT_C, 75); Wait(turn_time); total_time += move_time; total_time += turn_time; } while (total_time < 20000); Off(OUT_AC); }

Note também que fazer a declaração comporta quase o mesmo que o tempo declaração. Mas enquanto que na declaração do condição é testada antes de executar as declarações, enquanto que nos fazem menção a condição é testada no final. Por enquanto a declaração, as declarações poderiam nunca ser executado, mas para fazer a declaração que são executadas em menos uma vez.

Resumo

Neste capítulo, vimos duas novas estruturas de controlo: a declaração IF e a declaração DO. Juntamente com o declaração e repetir a declaração enquanto eles são as declarações que controlam a maneira pela qual o programa é executada. É muito importante que você entenda o que eles fazem. Então, melhor tentar mais alguns exemplos yourself antes de continuar.

5. Sensores

Claro que você pode se conectar sensores para fazer o robô NXT reagir a eventos externos. Antes que eu posso mostrar como a isso, temos de mudar o robô um

Vamos agora tentar fazer o robô evitar obstáculos. Sempre que o robô atinge um objeto, nós deixá-lo voltar um pouco, fazer uma vez, e em seguida continuar. Aqui está o programa:

task main() { SetSensorTouch(IN_1); OnFwd(OUT_AC, 75); while ( true ) { if (SENSOR_1 == 1) { OnRev(OUT_AC, 75); Wait(300); OnFwd(OUT_A, 75); Wait(300); OnFwd(OUT_AC, 75); } } } Tal como no exemplo anterior, primeiro indicar o tipo de sensor. Em seguida, o robô começa avançar. No loop infinito enquanto estamos constantemente a testar se o sensor é tocado, e, em caso afirmativo, mover de volta para 300 ms, vire à direita para 300 ms, e, em seguida, continuar em frente novamente.

Sensor Luz

Além de tocar o sensor, você também terá um sensor luz, um som e um sensor digital com sensores ultra-sônicos Mindstorms NXT sistema. O sensor de luz pode ser acionado para emitir luz ou não, assim você pode medir a quantidade de luz refletida ou luz ambiente em uma determinada direção. Medir a luz reflectida é particularmente útil quando tornando um robô seguir uma linha no chão. Isto é o que vamos fazer no próximo exemplo. Para continuar com a experimentos, acabamento Tribot edifício. Conecte sensor de luz de entrada 3, sensor de som de entrada 2 e sensores ultra-sônicos entrada para 4, conforme indicado por instruções.

Temos também o teste com o bloco faixa preta que vem com o NXT set. O princípio básico da linha seguinte é que o robô continua a tentar ficar direita, na

fronteira com a linha preta, girando fora da linha, se a luz nível é muito baixo (e sensor está no meio da linha) e virando para a linha, se o sensor está fora da faixa e detecta um elevado nível luz. Aqui está um programa muito simples fazer linha seguinte com uma única luz limiar valor.

#define THRESHOLD 40 task main() { SetSensorLight(IN_3); OnFwd(OUT_AC, 75); while ( true ) { if (Sensor(IN_3) > THRESHOLD) { OnRev(OUT_C, 75); Wait(100); until (Sensor(IN_3) <= THRESHOLD); OnFwd(OUT_AC, 75); } } }

O programa, primeiro porto 3 configura como uma luz sensor. Em seguida põe- se o robot para avançar e vai para um loop infinito. Sempre que a função valor é maior que 40 (usamos aqui uma constante tal que este pode ser adaptado fácil, porque depende muito do entorno luz) que reverter um motor e aguarde até que estamos no bom caminho novamente. Como você vai ver quando você executar o programa, o movimento não é muito bom. Tente adicionar um Wait(100) comando até antes do comando para fazer o robô mover melhor. Note que o programa não funciona para que se deslocam no sentido anti- horário. Para ativar o movimento ao longo arbitrária um caminho muito mais complicado programa é necessário. Para ler luz ambiente com intensidade levou off, configure o sensor do seguinte modo: SetSensorType(IN_3,IN_TYPE_LIGHT_INACTIVE); SetSensorMode(IN_3,IN_MODE_PCTFULLSCALE); ResetSensor(IN_3);

Som sensor

Usando o som sensor pode transformar o seu caro NXT fixado em um chocalho! Nós estamos indo para escrever um programa que espera por um som alto, e impulsiona o robô até que outro som é detectado. Fixe o sensor sonoro para a porta 2, conforme descrito no manual Tribot instruções.

#define THRESHOLD 40 #define MIC SENSOR_ task main()