Parte 3: GPIO: Montagem do ARM: Seguidor de linha: TI-RSLK: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Olá. Esta é a próxima edição em que continuamos usando o assembly ARM (em vez de uma linguagem de nível superior). A inspiração para este Instructable é o Laboratório 6 do Texas Instruments Robotics System Learning Kit, ou TI-RSLK.

Estaremos usando o microcontrolador do kit, a placa de desenvolvimento MSP432 LaunchPad, mas talvez você encontre algo útil para extrair deste Instructable mesmo se você não estiver usando o LaunchPad ou seguindo o T. I. currículo.

Começamos com um Instructable apresentando ARM Assembly, o ambiente de desenvolvimento e como fazer um projeto.

O próximo Instructable on ARM Assembly introduziu como interagir com entrada / saída (GPIO).

Em seguida, expandimos nosso conhecimento e introduzimos funções, controlando LEDs e interruptores.

Agora, com este Instructable, podemos usar o que aprendemos para fazer algo mais divertido, mais útil: detectar uma linha.

Isso pode nos ajudar mais tarde, quando construirmos um robô seguidor de linha.

No currículo, a maior parte da programação é feita em C ou C ++, mas é útil se familiarizar com o assembly, antes de começarmos a depender de linguagens de nível superior e bibliotecas.

Etapa 1: O Hardware

Não quero refazer o hardware em detalhes, pois já existem fontes, mas adicionaremos explicações quando necessário.

Para este Instrutível, usaremos o Arrray de Sensor de Refletância da Pololu, já que ele vem como parte do TI-RSLK (o kit do robô). É o usado no curso e no Laboratório 6 do currículo.

Se você não tiver isso, você pode usar qualquer detector de infravermelho (ou série deles) que produza um sinal digital, HIGH ou LOW, para presença e ausência.

O sensor de matriz é melhor porque pode ajudar a detectar se estamos bem no centro da linha ou em um dos lados. Além disso, como veremos mais tarde, pode nos ajudar a detectar o ângulo do robô em relação à linha.

A matriz de refletância possui detectores muito próximos uns dos outros. Isso significa que devemos obter vários sinais de detecção, dependendo, é claro, da espessura da linha.

Se sim, então se o robô não estiver diretamente alinhado com a linha, ele deve retornar uma saída de que a linha é mais larga do que deveria (porque estamos em um ângulo).

Para uma melhor explicação do acima, dê uma olhada no documento do Lab 6.

Para obter ajuda na fiação / conexão do sensor à placa de desenvolvimento MSP432 LaunchPad, aqui estão algumas instruções úteis.

Também adicionei as mesmas (semelhantes?) Instruções em PDF a esta etapa.

Se você ler atentamente os documentos da Pololu, eles explicam o motivo do "desvio de 3,3 V", que você vai querer fazer jumpers se estiver usando 3,3 V em vez de 5 V.

Como ainda não estamos construindo o robô, mas apenas aprendendo sobre a montagem do ARM e também como interagir com as peças (subsistemas) do robô, não precisamos seguir as instruções acima ao pé da letra.

Por enquanto, conectar a matriz de sensor de linha apenas ferve / se reduz ao seguinte:

• conecte 3,3 V e GND da placa MSP432 ao conjunto de sensores.
• conecte um pino de porta (sugiro P5.3) do MSP432 ao pino de ativação do LED na matriz do sensor de linha. Esse pino no sensor está entre 3,3 V e GND.
• conecte todos os oito pinos / bits de uma única porta (sugiro P7.0 a P7.7) aos oito pinos da matriz do sensor rotulada de "1" a "8". Essas são as linhas que ficarão ALTAS ou BAIXAS dependendo do que sentirem.

Como você pode ver nas imagens desta etapa, e no vídeo, não coloquei o sensor no chassi do robô, pois queria facilidade de programação, depuração, teste, aprendizado.

Assim, com tudo conectado, estamos prontos para entrar no software.

Etapa 2: Seguimento de linha

O sensor de matriz de refletância é muito bacana porque pode ajudar de pelo menos duas maneiras.

• Determine se o robô está centrado na linha ou está se deslocando para um lado.
• O robô está alinhado na direção da linha ou em ângulo?

Cada um dos detectores da matriz fornece essencialmente um bit de informação, ALTO ou BAIXO.

A ideia é combinar todos esses bits em um único número ou padrão de bit único e usar esse padrão para tomar decisões (para se mover corretamente).

Etapa 3: Antes de realmente começarmos…

.. precisamos aprender algo novo sobre a programação de montagem ARM. E não me refiro apenas a outra instrução. Esses tendem a ser menores.

Até agora não usamos a "pilha" em nossos programas.

Contamos com o uso da maioria dos registros de CPU do núcleo globalmente em diferentes sub-rotinas.

A única coisa que fizemos foi salvar e restaurar o endereço LR (registrador de link) para uma função - aquela que chamou várias outras funções. (Eu uso "função" e "sub-rotina" alternadamente aqui).

O que temos feito não é bom. E se quisermos aninhar outras funções? E se tivermos mais de um nível de aninhamento?

Nos exemplos anteriores, optamos por usar o registro R6 como o armazenamento para o LR ou endereço de retorno. Mas se quisermos fazer um aninhamento mais / mais profundo, não podemos continuar a alterar o valor de R6. Teríamos que escolher outro registro. E outro. E então se torna trabalhoso manter o controle de qual registro de CPU principal contém qual LR para restaurar para qual função.

Agora vamos dar uma olhada na "pilha".

Etapa 4: a pilha

Aqui está algum material de leitura que explica a pilha.

Sou um grande defensor de algumas ideias:

• apenas a teoria necessária, vá para a prática rapidamente
• aprenda conforme necessário, concentre-se em realmente fazer algo e não apenas em exercícios ou exemplos sem propósito.

Há bastante documentação online do ARM e do MSP432 que fala sobre a pilha, então não vou repetir tudo isso. Também vou reduzir o uso da pilha aqui ao mínimo - salvando o endereço de retorno (o Registro de link).

Essencialmente, precisamos apenas de instruções:

PUSH {lista de registro}

POP {lista de registro}

Ou, no nosso caso, especificamente:

PUSH {LR}

POP {LR}

Portanto, uma função / sub-rotina de montagem seria assim:

funcLabel:.asmfunc

PUSH {LR}; esta provavelmente deve ser uma das primeiras instruções de entrada.; faça mais código aqui..; blá blá blá…; ok, terminamos com a função, estamos prontos para retornar à função de chamada POP {LR}; isso restaura o endereço de retorno correto para a chamada; função. BX LR; return.endasmfunc

O vídeo mostra um exemplo ao vivo de várias funções aninhadas.

Etapa 5: o software

O arquivo anexado denominado "MSP432_Capítulo…" contém muitas informações úteis sobre as portas do MSP432 e, desse documento, obtemos as seguintes portas, registros, endereços etc. Está um pouco desatualizado, no entanto. No entanto, não vi os endereços detalhados listados para a porta 5 e superior. (apenas "funções alternativas"). Mas ainda é útil.

Estaremos usando duas portas. P5, P7, P1 e P2.

A saída P5.3 (um único bit) será para controlar o LED IR habilitado no sensor. Estamos usando o P5.3 porque é um pino exposto no mesmo cabeçalho que as outras conexões MSP432 que vão para a matriz do sensor.

P7.0 a P7.7 serão as oito entradas que coletam os dados do sensor; o que "vê".

P1.0 é o único LED vermelho e poderíamos usá-lo para nos dar algumas indicações dos dados.

P2.0, P2.1, P2.2 é o LED RGB e podemos usá-lo também, com suas diferentes possibilidades de cores, para nos dar uma indicação dos dados do sensor.

Se você leu os Instructables anteriores relacionados a tudo isso, você já sabe como configurar o programa.

Basta ter a seção de declaração para as portas e bits, etc.

Você terá uma seção "principal".

Deve haver um loop, onde lemos continuamente os dados de P7, tomamos decisões sobre esses dados e acendemos os dois LEDs de acordo.

Aqui estão novamente os endereços de registro de porta:

• GPIO P1: 0x4000 4C00 + 0 (endereços pares)
• GPIO P2: 0x4000 4C00 + 1 (endereços ímpares)
• GPIO P3: 0x4000 4C00 + 20 (endereços pares)
• GPIO P4: 0x4000 4C00 + 21 (endereços ímpares)
• GPIO P5: 0x4000 4C00 + 40 (endereços pares)
• GPIO P6: 0x4000 4C00 + 41 (endereços ímpares)
• GPIO P7: 0x4000 4C00 + 60 (endereços pares)
• GPIO P8: 0x4000 4C00 + 61 (endereços ímpares)
• GPIO P9: 0x4000 4C00 + 80 (endereços pares)
• GPIO P10: 0x4000 4C00 + 81 (endereços ímpares)

O que está em negrito é o que usaremos para este Instructable.

Etapas do programa para ler detectores de infravermelho

O seguinte é psuedo-código para escrever o programa em C, mas ainda é útil, e o seguiremos bem de perto na versão assembly do programa.

programa principal0) Inicializar // portas enquanto (1) {1) Definir P5.3 alto (ligar o LED IV) 2) Tornar P7.0 uma saída e definir alto (carregando o capacitor) 3) Aguarde 10 us, Clock_Delay1us (10); 4) Faça P7.0 uma entrada 5) Execute este loop 10.000 vezes a) Leia P7.0 (converte a tensão em P7.0 em binário) b) Saída binária para P1.0 (permite que você veja o binário em tempo real) 6) Ajuste P5.3 baixo (desligue o LED IV, economizando energia) 7) Aguarde 10 ms, Clock_Delay1ms (10); } // repetir (voltar ao while ())

Etapa 6: vamos melhorar o código

O objetivo ou uso da matriz de LEDs IV da Pololu é detectar uma linha e saber se o robô (futuro) está diretamente centrado na linha ou fora de um lado. Além disso, uma vez que a linha tem uma certa espessura, se a matriz de sensores for diretamente perpendicular à linha, o número N de sensores terá uma leitura diferente do resto, ao passo que se a matriz de LEDs IR estiver em algum ângulo (não perpendicular), então Os pares N + 1 ou N + 2 LED IR / detector devem agora fornecer uma leitura diferente.

Assim, dependendo de quantos sensores indicam a presença da linha, devemos saber se estamos centrados e se estamos angulados ou não.

Para este experimento final, vamos ver se podemos fazer com que o LED vermelho e o LED RGB nos forneçam mais informações sobre o que a matriz de sensores está nos dizendo.

O vídeo detalha todos os detalhes. O código final também está anexado.

Isso completa a série de montagem ARM relacionada ao GPIO. Esperamos voltar com mais ARM Assembly posteriormente.

Obrigada.