GPIO ARM ASSEMBLY - T.I. KIT DE APRENDIZAGEM DO SISTEMA ROBÓTICO - LAB 6: 3 etapas

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

Olá, Em um Instructable anterior sobre como aprender a montagem ARM usando o Texas Instruments TI-RSLK (usa o microcontrolador MSP432), também conhecido como Laboratório 3 se você estiver fazendo o T. I. Claro, examinamos algumas instruções básicas, como escrever em um registrador e fazer um loop condicional. Percorremos a execução usando o IDE Eclipse.

Os minúsculos programas que executamos não faziam nada para interagir com o mundo exterior.

Meio chato.

Vamos tentar mudar isso um pouco hoje, aprendendo um pouco sobre as portas de entrada / saída, especificamente, os pinos GPIO digitais.

Acontece que este MSP432 vem em uma placa de desenvolvimento já com duas chaves de botão, um LED RGB e um LED vermelho, todos ligados a algumas portas GPIO.

Isso significa que, à medida que aprendemos a configurar e manipular esses pinos por meio da montagem, podemos ver esses efeitos visualmente.

Muito mais interessante do que apenas percorrer o depurador.

(Ainda vamos dar um passo - esta será a nossa função de 'atraso'):-D

Etapa 1: vamos tentar escrever / ler da RAM

Antes de começarmos a acessar e controlar o GPIO, devemos dar um pequeno passo.

Vamos começar apenas lendo e gravando em um endereço de memória padrão. Sabemos do Instructable anterior (veja as imagens lá) que a RAM começa em 0x2000 0000, então vamos usar esse endereço.

Vamos mover os dados entre um registrador de núcleo (R0) e 0x2000 0000.

Começamos com uma estrutura básica de arquivo ou conteúdo de um programa de montagem. Consulte este Instructable para criar um projeto de montagem usando Code Composer Studio (CCS) da TI e alguns projetos de amostra.

.dedão

.text.align 2.global main.thumbfunc main main:.asmfunc; ---------------------------------- -----------------------------------------------; (nosso código irá aqui); ------------------------------------------ ---------------------------------------.endasmfunc.end

Eu quero adicionar algo novo à seção superior, onde existem algumas declarações (diretivas). Isso ficará mais claro mais tarde.

ACONST.set 0x20000000; vamos usar isso mais abaixo (é uma constante)

; obviamente, '0x' denota o que se segue é um valor hexadecimal.

Portanto, o conteúdo do nosso arquivo inicial agora se parece com:

.dedão

.text.align 2 ACONST.set 0x20000000; vamos usar isso mais abaixo (é uma constante); obviamente, '0x' denota o que se segue é um valor hexadecimal..global main.thumbfunc main main:.asmfunc; --------------------------------------- ------------------------------------------; (nosso código irá aqui); ------------------------------------------ ---------------------------------------.endasmfunc.end

Agora que temos o acima, vamos adicionar o código entre as linhas tracejadas.

Começamos escrevendo em um local RAM. Primeiro, estabeleceremos o padrão de dados, um valor, que escreveremos na RAM. Usamos um registro principal para estabelecer esse valor ou dados.

Observação: lembre-se de que, no código, qualquer linha que tenha um ponto e vírgula (';') significa que é um comentário após esse ponto e vírgula.

;-----------------------------------------------------------------------------------------------

; ESCRITA;------------------------------------------------ ----------------------------------------------- MOV R0, # 0x55; O registro de núcleo R0 conterá os dados que queremos gravar no local da RAM.; obviamente, '0x' denota o que se segue é um valor hexadecimal.

A seguir, vamos dar uma olhada nas instruções que NÃO funcionam.

; MOV MOV não pode ser usado para gravar dados em um local de RAM.

; MOV é apenas para dados imediatos no registro; ou de um registro para outro; ou seja, MOV R1, R0.; STR deve usar STR.; STR R0, = ACONST; Termo incorreto na expressão (o '='); STR R0, 0x20000000; Modo de endereçamento ilegal para instruções de armazenamento; STR R0, ACONST; Modo de endereçamento ilegal para instruções de armazenamento

Sem explicar muito, tentamos usar o 'ACONST' acima. Essencialmente, é um substituto ou constante em vez de usar um valor literal como 0x20000000.

Não foi possível escrever para gravar no local da RAM usando o acima. Vamos tentar outra coisa.

; parece que devemos usar outro registro contendo a localização da RAM em

; pedido para armazenar naquele local de RAM MOV R1, # 0x20000000; defina a localização da RAM (não seu conteúdo, mas a localização) em R1.; obviamente, '0x' denota o que se segue é um valor hexadecimal. STR R0, [R1]; escreva o que está em R0 (0x55) na RAM (0x20000000) usando R1.; usamos outro registrador (R1) que tem endereço de localização de RAM; a fim de escrever PARA aquele local da RAM.

Outra maneira de fazer o acima, mas usando 'ACONST' em vez do valor do endereço literal:

; vamos fazer o acima novamente, mas vamos usar um símbolo em vez de um valor de localização de RAM literal.

; queremos usar 'ACONST' como um substituto para 0x20000000.; ainda temos que fazer o '#' para significar um valor imediato,; então (veja no topo), tivemos que usar a diretiva '.set'.; para provar isso, vamos mudar o padrão de dados em R0. MOV R0, # 0xAA; ok, estamos prontos para gravar na RAM usando o símbolo em vez do valor de endereço literal MOV R1, #ACONST STR R0, [R1]

O vídeo apresenta mais detalhes, bem como percorre a leitura do local da memória.

Você também pode visualizar o arquivo.asm de origem anexado.

Etapa 2: algumas informações básicas sobre a porta

Agora que temos uma boa ideia de como escrever / ler de um local de RAM, isso nos ajudará a entender melhor como controlar e usar o pino GPIO

Então, como interagimos com os pinos GPIO? De nossa análise anterior deste microcontrolador e suas instruções ARM, sabemos como lidar com seus registradores internos e como interagir com endereços de memória (RAM). Mas os pinos GPIO?

Acontece que esses pinos são mapeados na memória, então podemos tratá-los da mesma forma que os endereços da memória.

Isso significa que precisamos saber quais são esses endereços.

Abaixo estão os endereços iniciais das portas. A propósito, para o MSP432, uma "porta" é uma coleção de pinos, e não apenas um pino. Se você estiver familiarizado com o Raspberry Pi, acredito que seja diferente da situação aqui.

Os círculos azuis na imagem acima mostram a escrita na placa para os dois interruptores e LEDs. As linhas azuis apontam para os LEDs reais. Não teremos que tocar nos jumpers do cabeçalho.

Fiz as portas que nos preocupam em negrito abaixo.

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

Ainda não terminamos. Precisamos de mais informações.

Para controlar uma porta, precisamos de vários endereços. É por isso que, na lista acima, vemos "endereços pares" ou "endereços ímpares".

Blocos de endereços de registro de E / S

Precisaremos de outros endereços, como:

• Endereço de registro de entrada da porta 1 = 0x40004C00
• Endereço de registro de saída da porta 1 = 0x40004C02
• Endereço de registro de direção da porta 1 = 0x40004C04
• Porta 1 Selecione 0 Endereço de registro = 0x40004C0A
• Porta 1 Selecione 1 Endereço de registro = 0x40004C0C

E podemos precisar de outros.

Ok, agora sabemos a faixa de endereços de registro GPIO para controlar o único LED vermelho.

Uma observação muito importante: cada porta de E / S na placa MSP432 LaunchPad é uma coleção de vários (geralmente 8) pinos ou linhas, e cada um pode ser definido individualmente como uma entrada ou saída.

Isso significa, por exemplo, que se você estiver configurando valores para o "Endereço de registro de direção da porta 1", deverá se preocupar com qual bit (ou bits) está configurando ou alterando naquele endereço. Mais sobre isso mais tarde.

Sequência de programação da porta GPIO

A última peça de que precisamos é um processo ou algoritmo a ser usado para controlar o LED.

Inicialização única:

• Configure P1.0 (P1SEL1REG: Registro P1SEL0REG) <--- 0x00, 0x00 para a funcionalidade GPIO normal.
• Defina o bit 1 de registro de direção de P1DIRREG como saída ou HIGH.

Ciclo:

Escreva HIGH no bit 0 do registro P1OUTREG para ligar o LED vermelho

• Chame uma função de atraso
• Escreva LOW no bit 0 do registro P1OUTREG para desligar o LED vermelho
• Chame uma função de atraso
• Repetir Loop

Qual função de entrada / saída (configurar SEL0 e SEL1)

Muitos dos pinos do LaunchPad têm vários usos. Por exemplo, o mesmo pino pode ser GPIO digital padrão ou também pode ser usado em comunicações seriais UART ou I2C.

Para usar qualquer função específica para aquele pino, você precisa selecionar essa função. Você precisa configurar a função do pino.

Há uma imagem acima para esta etapa que tenta explicar esse conceito de forma visual.

Os endereços SEL0 e SEL1 formam uma combinação de pares que agem como algum tipo de seleção de função / recurso.

Para nossos propósitos, queremos GPIO digital padrão para o bit 0. Isso significa que precisamos do bit 0 para SEL0 e SEL1 serem BAIXOS.

Sequência de programação de portas (novamente)

1. Grave 0x00 no Registro SEL 0 P1 (endereço 0x40004C0A). Isso define um LOW para o bit 0

2. Grave 0x00 no Registro SEL 1 P1 (endereço 0x40004C0C). Isso define um LOW para o bit 0, configuração para GPIO.

3. Grave 0x01 no Registro DIR P1 (endereço 0x40004C04). Isso define um HIGH para o bit 0, significando OUTPUT.

4. Ligue o LED escrevendo um 0x01 para P1 OUTPUT Register (endereço 0x40004C02)

5. Faça algum tipo de atraso (ou apenas uma etapa durante a depuração)

6. Desligue o LED escrevendo um 0x00 para P1 OUTPUT Register (endereço 0x40004C02)

7. Faça algum tipo de atraso (ou apenas uma etapa durante a depuração)

8. Repita as etapas 4 a 7.

O vídeo associado a esta etapa nos conduz por todo o processo em uma demonstração ao vivo, à medida que avançamos e conversamos sobre cada instrução de montagem e mostramos a ação do LED. Por favor, desculpe a duração do vídeo.

Etapa 3: Você percebeu o defeito do vídeo?

No vídeo que percorre todo o processo de programação e iluminação do LED, havia uma etapa extra no loop principal, que poderia ter sido movida até a inicialização única.

Obrigado por reservar um tempo para ler este Instructable.

O próximo expande o que começamos aqui.